4f:I[707087,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"RegistryDependencies"] 50:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 51:Tacc,import { defaultLinearAuth, linearChannel } from "eve/channels/linear"; import { formatPolicySummary, linearOperationsConfig } from "../lib/linear-operations-config.js"; const isString = (value: string | undefined): value is string => value !== undefined; type LinearIssueContext = { readonly identifier?: string; readonly id?: string; readonly team?: { readonly id?: string; readonly key?: string; readonly name?: string; } | null; readonly project?: { readonly id?: string; readonly name?: string; readonly slug?: string; } | null; }; type LinearAgentSessionEventLike = { readonly action?: string; readonly agentSession?: { readonly issue?: LinearIssueContext | null; } | null; }; const issueMatchesScope = (issue: LinearIssueContext | null | undefined): boolean => { if (!issue) return true; const teamCandidates = [issue.team?.id, issue.team?.key, issue.team?.name].filter(isString); const projectCandidates = [issue.project?.id, issue.project?.slug, issue.project?.name].filter(isString); const teamAllowed = linearOperationsConfig.coveredTeams.length === 0 || teamCandidates.length === 0 || teamCandidates.some((team) => linearOperationsConfig.coveredTeams.includes(team)); const projectAllowed = linearOperationsConfig.coveredProjects.length === 0 || projectCandidates.length === 0 || projectCandidates.some((project) => linearOperationsConfig.coveredProjects.includes(project)); return teamAllowed && projectAllowed; }; const formatLinearContext = (event: LinearAgentSessionEventLike): string => { const issue = event.agentSession?.issue; const issueLabel = issue?.identifier ?? issue?.id ?? "unknown issue"; const teamLabel = issue?.team?.key ?? issue?.team?.name ?? issue?.team?.id ?? "unknown team"; const projectLabel = issue?.project?.name ?? issue?.project?.slug ?? issue?.project?.id ?? "no project"; return [ "Surface: Linear Agent Session.", `Issue: ${issueLabel}`, `Team: ${teamLabel}`, `Project: ${projectLabel}`, "Linear is the source of truth. Keep proposals and executed actions attached to the relevant Linear object.", "Policy summary:", formatPolicySummary(), ].join("\n"); }; export default linearChannel({ credentials: { accessToken: process.env.LINEAR_AGENT_ACCESS_TOKEN, webhookSecret: process.env.LINEAR_WEBHOOK_SECRET, }, onAgentSession: (_ctx, event) => { const eventLike = event as LinearAgentSessionEventLike; if (event.action !== "created" && event.action !== "prompted") return null; if (!issueMatchesScope(eventLike.agentSession?.issue)) return null; return { auth: defaultLinearAuth(event), context: [formatLinearContext(eventLike)], }; }, }); 52:T71c,import { connectSlackCredentials } from "@vercel/connect/eve"; import { defaultSlackAuth, loadThreadContextMessages, slackChannel } from "eve/channels/slack"; const SLACK_OPERATING_CONTEXT = [ "Surface: Slack.", "Slack is intake, coordination, notification, and scheduled delivery.", "The final operational source of truth must live in Linear whenever work is created or changed.", "Before sensitive Linear changes, ask for approval in the originating Slack thread or move the final confirmation to Linear.", ].join("\n"); const getRequiredEnv = (name: string): string => { const value = process.env[name]?.trim(); if (!value) { throw new Error( `${name} is required. Create a Vercel Connect Slack connector and set this to the returned connector UID.`, ); } return value; }; export default slackChannel({ credentials: connectSlackCredentials(getRequiredEnv("SLACK_CONNECT_UID")), async onAppMention(ctx, message) { const auth = defaultSlackAuth(message, ctx); try { const priorMessages = await loadThreadContextMessages(ctx.thread, message, { since: "last-agent-reply", }); const transcript = priorMessages .map( (threadMessage) => `${threadMessage.isMe ? "agent" : (threadMessage.user ?? "user")}: ${threadMessage.markdown}`, ) .join("\n"); return { auth, context: transcript ? [SLACK_OPERATING_CONTEXT, `Recent Slack thread context since the last agent reply:\n\n${transcript}`] : [SLACK_OPERATING_CONTEXT], }; } catch { return { auth, context: [SLACK_OPERATING_CONTEXT], }; } }, onDirectMessage: (ctx, message) => ({ auth: defaultSlackAuth(message, ctx), context: [SLACK_OPERATING_CONTEXT], }), }); 53:Tcf2,import { connect } from "@vercel/connect/eve"; import { defineMcpClientConnection } from "eve/connections"; import { getCoveredInitiative, linearOperationsConfig, } from "../lib/linear-operations-config.js"; const READ_TOOLS = [ "list_issues", "get_issue", "list_comments", "list_projects", "get_status_updates", "list_cycles", "list_issue_labels", "list_issue_statuses", "get_issue_status", "extract_images", "search_documentation", ] as const; const WRITE_TOOLS = [ "save_issue", "save_comment", "save_project", "save_document", "save_status_update", "delete_status_update", ] as const; const normalizeToolName = (toolName: string): string => toolName.split("__").at(-1) ?? toolName; const asRecord = (value: unknown): Record => typeof value === "object" && value !== null && !Array.isArray(value) ? (value as Record) : {}; const getStringField = (input: Record, field: string): string | undefined => { const value = input[field]; return typeof value === "string" && value.trim() ? value : undefined; }; const getRequiredEnv = (name: string): string => { const value = process.env[name]?.trim(); if (!value) { throw new Error( `${name} is required. Create a Vercel Connect Linear connector and set this to the returned connector UID.`, ); } return value; }; const needsSaveIssueApproval = (toolInput: unknown): boolean => { const input = asRecord(toolInput); if (!getStringField(input, "id")) return true; const changedFields = Object.keys(input).filter((field) => field !== "id"); return changedFields.length > 0; }; const needsStatusUpdateApproval = (toolInput: unknown): boolean => { const input = asRecord(toolInput); const type = getStringField(input, "type"); const initiativeIdOrName = getStringField(input, "initiativeId") ?? getStringField(input, "initiativeName") ?? getStringField(input, "initiative") ?? getStringField(input, "projectMilestoneId"); const coveredInitiative = getCoveredInitiative(initiativeIdOrName ?? ""); if ( type === "initiative" && linearOperationsConfig.policy.autoInitiativeUpdates && coveredInitiative?.weeklyUpdateEnabled === true ) { return false; } return true; }; export default defineMcpClientConnection({ url: "https://mcp.linear.app/mcp", description: "Linear workspace operations: read issues, comments, projects, cycles, labels, statuses, status updates, and create approved operational updates.", auth: connect(getRequiredEnv("LINEAR_CONNECT_UID")), tools: { allow: [...READ_TOOLS, ...WRITE_TOOLS], }, approval: ({ toolName, toolInput }) => { const normalizedToolName = normalizeToolName(toolName); if (READ_TOOLS.includes(normalizedToolName as (typeof READ_TOOLS)[number])) return false; if (normalizedToolName === "save_comment") return false; if (normalizedToolName === "save_status_update") return needsStatusUpdateApproval(toolInput); if (normalizedToolName === "save_issue") return needsSaveIssueApproval(toolInput); if ( normalizedToolName === "save_project" || normalizedToolName === "save_document" || normalizedToolName === "delete_status_update" ) { return true; } return true; }, }); 54:Tc3e,# Mission You are Linear Operations Agent, an Eve agent that helps teams turn Linear issues, Slack discussions, cycles, projects, backlog, and initiatives into clear operational work. Linear is the source of truth. Slack is for intake, coordination, notification, and scheduled delivery. Schedule runs should be concise and should avoid noise. Final operational changes must be attached to the relevant Linear object whenever the work creates or updates Linear state. Use the Linear MCP connection for Linear data. Do not assume tool schemas beyond what the MCP tool exposes at runtime. Prefer read tools first, then ask for approval before sensitive writes. Never invent issue identifiers, statuses, priorities, owners, labels, projects, cycles, or initiative data. ## Operating Modes ### Assisted Respond to explicit requests from Linear or Slack: triage, duplicate detection, clarification, decomposition, planning, incident support, project reporting, or initiative reporting. ### Proactive Schedule runs publish operational digests to configured Slack channels, except weekly initiative updates, which are written directly to Linear as initiative status updates for explicitly configured initiatives only. ### Approval All Linear writes are **approval-gated**. Ask for approval before sensitive changes: issue creation, state changes, priority changes, assignee/delegate/project/cycle changes, duplicate or parent relationships, project/document changes, status update deletes, and any bulk action. Use the channel where the request started unless Linear is the better final confirmation surface. ### Evidence-backed recommendations Every proposed priority, owner, label, project, cycle, or status change must cite evidence from Linear or Slack context. Do not invent metadata. ### Read-only When the policy or context is read-only, only read, analyze, summarize, and propose. Do not write to Linear unless the channel context and approval policy allow it. ## Default Response Shape Keep outputs operational and concise: - Summary - Findings - Missing information - Recommendation - Proposed Linear action - Approval request, when needed Always distinguish proposal from action already executed. ## Linear Behavior In Linear, respond in the Agent Session context. Keep the reference to the original request. Add clear context on the issue, project, cycle, or initiative involved. If an issue is vague, ask the smallest set of clarifying questions needed to make it actionable. ## Slack Behavior In Slack, interpret the thread as intake context. Separate discussion, decision, and action. Prepare or propose Linear work, then link or describe the target Linear object. Do not let Slack become the long-term source of truth. ## Schedule Behavior For recurring jobs, highlight only items that need attention, group similar findings, propose concrete next steps, and avoid invasive changes. Deliver operational digests to Slack. For weekly initiative updates, write the update directly to the configured Linear initiative; if Linear roadmaps or initiatives are unavailable, report the error clearly in Slack. 55:T1969,export type CoveredInitiative = { readonly idOrName: string; readonly slackChannelId?: string; readonly weeklyUpdateEnabled: boolean; }; export type SlackChannelKind = "default" | "triage" | "cycle" | "backlog" | "p1Monitoring"; export type LinearOperationsConfig = { readonly coveredTeams: readonly string[]; readonly coveredProjects: readonly string[]; readonly coveredInitiatives: readonly CoveredInitiative[]; readonly slack: { readonly defaultChannelId?: string; readonly triageChannelId?: string; readonly cycleChannelId?: string; readonly backlogChannelId?: string; readonly p1MonitoringChannelId?: string; readonly projectChannels: Readonly>; }; readonly policy: { readonly readOnlyTeams: readonly string[]; readonly maxBulkIssueCount: number; readonly highPriorityValues: readonly number[]; readonly autoInitiativeUpdates: boolean; }; readonly schedules: { readonly dailyTriageDigest: string; readonly cycleHealth: string; readonly weeklyBacklogHygiene: string; readonly weeklyProjectSummary: string; readonly weeklyInitiativeUpdates: string; readonly p1Monitoring: string; }; }; const DEFAULT_MAX_BULK_ISSUE_COUNT = 10; const HIGH_PRIORITY_VALUES = [1, 2] as const; const compactCsv = (value: string | undefined): string[] => (value ?? "") .split(",") .map((item) => item.trim()) .filter(Boolean); const optional = (value: string | undefined): string | undefined => { const trimmed = value?.trim(); return trimmed ? trimmed : undefined; }; const parseBoolean = (value: string | undefined, fallback: boolean): boolean => { if (value === undefined) return fallback; return value.trim().toLowerCase() !== "false"; }; const parsePositiveInteger = (value: string | undefined, fallback: number): number => { const parsed = Number.parseInt(value ?? "", 10); return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback; }; const parseProjectChannels = (value: string | undefined): Record => { const entries: Record = {}; for (const pair of compactCsv(value)) { const [project, channelId] = pair.split(":").map((part) => part.trim()); if (project && channelId) entries[project] = channelId; } return entries; }; const parseCoveredInitiatives = (value: string | undefined): CoveredInitiative[] => { return compactCsv(value).map((rawItem) => { const [idOrName = "", slackChannelId, enabledFlag] = rawItem .split("|") .map((part) => part.trim()); return { idOrName, slackChannelId: optional(slackChannelId), weeklyUpdateEnabled: enabledFlag === undefined || enabledFlag.toLowerCase() !== "false", }; }); }; export const linearOperationsConfig = { coveredTeams: compactCsv(process.env.LINEAR_OPS_COVERED_TEAMS), coveredProjects: compactCsv(process.env.LINEAR_OPS_COVERED_PROJECTS), coveredInitiatives: parseCoveredInitiatives(process.env.LINEAR_OPS_COVERED_INITIATIVES), slack: { defaultChannelId: optional(process.env.LINEAR_OPS_DEFAULT_SLACK_CHANNEL_ID), triageChannelId: optional(process.env.LINEAR_OPS_TRIAGE_SLACK_CHANNEL_ID), cycleChannelId: optional(process.env.LINEAR_OPS_CYCLE_SLACK_CHANNEL_ID), backlogChannelId: optional(process.env.LINEAR_OPS_BACKLOG_SLACK_CHANNEL_ID), p1MonitoringChannelId: optional(process.env.LINEAR_OPS_P1_SLACK_CHANNEL_ID), projectChannels: parseProjectChannels(process.env.LINEAR_OPS_PROJECT_CHANNELS), }, policy: { readOnlyTeams: compactCsv(process.env.LINEAR_OPS_READ_ONLY_TEAMS), maxBulkIssueCount: parsePositiveInteger( process.env.LINEAR_OPS_MAX_BULK_ISSUE_COUNT, DEFAULT_MAX_BULK_ISSUE_COUNT, ), highPriorityValues: HIGH_PRIORITY_VALUES, autoInitiativeUpdates: parseBoolean(process.env.LINEAR_OPS_AUTO_INITIATIVE_UPDATES, true), }, schedules: { dailyTriageDigest: process.env.LINEAR_OPS_DAILY_TRIAGE_CRON ?? "0 7 * * 1-5", cycleHealth: process.env.LINEAR_OPS_CYCLE_HEALTH_CRON ?? "30 7 * * 1-5", weeklyBacklogHygiene: process.env.LINEAR_OPS_WEEKLY_BACKLOG_CRON ?? "0 8 * * 1", weeklyProjectSummary: process.env.LINEAR_OPS_WEEKLY_PROJECT_CRON ?? "30 8 * * 1", weeklyInitiativeUpdates: process.env.LINEAR_OPS_WEEKLY_INITIATIVE_CRON ?? "0 9 * * 1", p1Monitoring: process.env.LINEAR_OPS_P1_MONITORING_CRON ?? "0 13 * * 1-5", }, } satisfies LinearOperationsConfig; export const getSlackChannelId = (kind: SlackChannelKind): string | undefined => { switch (kind) { case "triage": return linearOperationsConfig.slack.triageChannelId ?? linearOperationsConfig.slack.defaultChannelId; case "cycle": return linearOperationsConfig.slack.cycleChannelId ?? linearOperationsConfig.slack.defaultChannelId; case "backlog": return linearOperationsConfig.slack.backlogChannelId ?? linearOperationsConfig.slack.defaultChannelId; case "p1Monitoring": return ( linearOperationsConfig.slack.p1MonitoringChannelId ?? linearOperationsConfig.slack.defaultChannelId ); case "default": return linearOperationsConfig.slack.defaultChannelId; } }; export const getProjectSlackChannelId = (projectNameOrId: string): string | undefined => linearOperationsConfig.slack.projectChannels[projectNameOrId] ?? linearOperationsConfig.slack.defaultChannelId; export const getCoveredInitiative = (idOrName: string): CoveredInitiative | undefined => linearOperationsConfig.coveredInitiatives.find((initiative) => initiative.idOrName === idOrName); export const isExplicitlyCoveredInitiative = (idOrName: string | undefined): boolean => idOrName !== undefined && getCoveredInitiative(idOrName) !== undefined; export const formatPolicySummary = (): string => { const readOnlyTeams = linearOperationsConfig.policy.readOnlyTeams.join(", ") || "none configured"; const coveredTeams = linearOperationsConfig.coveredTeams.join(", ") || "all teams"; const coveredProjects = linearOperationsConfig.coveredProjects.join(", ") || "all projects"; const initiatives = linearOperationsConfig.coveredInitiatives.map((initiative) => initiative.idOrName).join(", ") || "none configured"; return [ `Covered teams: ${coveredTeams}`, `Covered projects: ${coveredProjects}`, `Read-only teams: ${readOnlyTeams}`, `Explicit initiatives for weekly updates: ${initiatives}`, `Max bulk issue count: ${linearOperationsConfig.policy.maxBulkIssueCount}`, ].join("\n"); }; 56:T5e6,import { defineSchedule } from "eve/schedules"; import slack from "../channels/slack.js"; import { getSlackChannelId, linearOperationsConfig, } from "../lib/linear-operations-config.js"; const getEnabledInitiatives = () => linearOperationsConfig.coveredInitiatives.filter((initiative) => initiative.weeklyUpdateEnabled); export default defineSchedule({ cron: linearOperationsConfig.schedules.weeklyInitiativeUpdates, async run({ to, waitUntil, appAuth }) { const initiatives = getEnabledInitiatives(); if (initiatives.length === 0) return; for (const initiative of initiatives) { const channelId = initiative.slackChannelId ?? getSlackChannelId("default"); if (!channelId) continue; waitUntil( to(slack, { channelId }).send( [ "Create a weekly Linear initiative update for this explicitly configured initiative only.", `Configured initiative: ${initiative.idOrName}.`, "Analyze related issues, projects, recent completions, open work, blockers, risks, dependencies, pending decisions, scope changes, and recommended next steps.", 'Write the final update directly to Linear with save_status_update({ type: "initiative" }).', "If Linear reports that roadmaps or initiatives are not enabled in this workspace, post a clear Slack error to this configured channel instead of producing a generic digest.", ].join("\n"), { auth: appAuth } ), ); } }, }); 57:T40c,--- name: incident-support description: Support P0/P1 bug and incident issues by identifying missing evidence, related work, priority, owner, stakeholder update, and follow-up actions. --- # Incident support Use for urgent bugs, incidents, P0/P1 monitoring, or questions about critical issue readiness. ## Process 1. Read the critical issue, comments, status, priority, assignee, labels, project, and related issues. **Done when** every field is checked or noted as absent. 2. Identify impact, environment, reproduction steps, affected versions, timestamps, recent deploys, and mitigation state. **Done when** each category is filled or listed as missing evidence. 3. Search for related incidents, fixes, or duplicate reports. 4. Propose owner, stakeholder update, and follow-up issues only when supported by evidence from steps 1–3. 5. For scheduled monitoring, alert in Slack without changing Linear state. ## Output Use the agent default response shape, plus impact summary, related issues, and operational risk. 58:T4be,--- name: initiative-reporting description: Create weekly Linear initiative updates for explicitly configured initiatives, including progress, blockers, risks, and next steps. --- # Initiative reporting Use for weekly initiative update schedules or direct requests about configured initiatives. ## Process 1. Work only on initiatives explicitly configured for coverage. 2. Read linked projects, issues, recent completions, open work, status updates, blockers, dependencies, comments, and scope changes. **Done when** state, progress, blockers, risks, pending decisions, and next actions are captured. 3. Draft a concise weekly update from that evidence. 4. Write the final update directly to the Linear initiative using `save_status_update({ type: "initiative" })` when the initiative is configured and weekly updates are enabled. **Done when** the update is saved or a clear error is reported. 5. If Linear reports that roadmaps or initiatives are unavailable, post a clear error to the configured Slack channel. 6. Do not create initiative updates for unconfigured initiatives. ## Output Initiative status, recent progress, blockers, risks, pending decisions, and recommended next steps. 59:T41a,--- name: triage description: Triage a Linear issue into type, priority, owner, team, labels, missing information, duplicates, and next step. --- # Triage Use when a user asks for issue triage or whether an issue is actionable. ## Process 1. Read the issue title, description, comments, labels, status, team, project, cycle, priority, and assignee. **Done when** every field is checked or noted as absent. 2. Search for related or duplicate issues using Linear MCP read tools. **Done when** at least one targeted search has run and top candidates are recorded. 3. Classify the issue type: bug, feature, task, incident, support, product question, cleanup, or unclear. 4. List missing information that blocks execution. 5. Propose priority, owner or owner team, labels, project or cycle, and next step. Every proposal must be evidence-backed from steps 1–2. 6. State recommendations separately from any actions already applied. ## Output Use the agent default response shape, plus classification and related or duplicate issues. 5a:T6ad,import { defineEval } from "eve/evals"; import { includes } from "eve/evals/expect"; export default defineEval({ description: "Triages an issue from provided Linear data as an evidence-backed proposal without applying any Linear writes.", async test(t) { await t.send(` Triage this Linear issue. The get_issue tool returned: { "id": "a1b2c3d4-0000-4000-8000-000000000001", "identifier": "OPS-231", "title": "App crashes when opening settings", "description": "Since the last release, tapping Settings crashes the app on Android. Several users reported it in support. Stack trace attached in the first comment points to a null preferences store.", "state": { "name": "Triage" }, "priority": 0, "labels": [], "assignee": null, "team": { "key": "OPS", "name": "Operations" } } The list_issues duplicate search for "settings crash Android" returned: { "issues": [] } All the Linear data you need is provided above. Proceed according to your instructions: propose a triage outcome (type, priority, labels, next step) backed only by the evidence above, and ask for approval before any change. Do not call any Linear tools in this run, and do not apply the proposal with save_issue — a proposal is not an executed action. `); t.succeeded(); t.noFailedActions(); t.notCalledTool("save_issue").gate(); t.notCalledTool("linear__save_issue").gate(); t.notCalledTool("save_project").gate(); t.notCalledTool("linear__save_project").gate(); t.check(t.reply, includes("OPS-231").gate()); const replyLower = (t.reply ?? "").toLowerCase(); t.check(replyLower, includes("propos").gate()); t.check(replyLower, includes("approval").soft()); }, }); 5b:T453,import { defineEval } from "eve/evals"; import { includes } from "eve/evals/expect"; export default defineEval({ description: "Declines to write a weekly initiative update for an initiative that is not in the configured coverage list.", async test(t) { await t.send(` Post this week's initiative update for the "Mobile Rewrite" initiative in Linear. The configured initiative coverage (LINEAR_OPS_COVERED_INITIATIVES) contains only "Platform Reliability", and "Mobile Rewrite" is not in it. Proceed according to your instructions: weekly initiative updates may only be written for explicitly configured initiatives, so do not call save_status_update or any other Linear tool for this request. Explain that "Mobile Rewrite" is not configured for automated updates and how coverage can be extended. `); t.succeeded(); t.noFailedActions(); t.notCalledTool("save_status_update").gate(); t.notCalledTool("linear__save_status_update").gate(); t.check(t.reply, includes("Mobile Rewrite").gate()); t.check(t.reply, includes("LINEAR_OPS_COVERED_INITIATIVES").soft()); }, }); 5c:T325a,# Linear Operations Agent An Eve agent for Linear operations across Linear, Slack, and scheduled runs. Linear is the source of truth. Slack is used for intake, coordination, notification, and scheduled report delivery. Scheduled initiative updates are written directly to Linear for explicitly configured initiatives. ## What You Are Setting Up This agent has three different integration points. They are intentionally separate: | Part | File | Runtime route or server | Credentials | | --- | --- | --- | --- | | Linear channel | `agent/channels/linear.ts` | `POST /eve/v1/linear` | `LINEAR_AGENT_ACCESS_TOKEN`, `LINEAR_WEBHOOK_SECRET` | | Slack channel | `agent/channels/slack.ts` | `POST /eve/v1/slack` | Vercel Connect Slack UID in `SLACK_CONNECT_UID` | | Linear MCP connection | `agent/connections/linear.ts` | `https://mcp.linear.app/mcp` | Vercel Connect Linear OAuth UID in `LINEAR_CONNECT_UID` | The Linear channel is how users mention or delegate work to the agent inside Linear. The Slack channel is how users mention or DM the agent in Slack. The Linear MCP connection is how the agent reads and writes Linear data from any surface, including Slack and schedules. Do not replace the Linear MCP connection with custom Linear SDK tools for this agent. The connection exposes the allowed Linear MCP tools and applies the dynamic approval policy in one place. ## Capabilities - Linear issue triage, clarification, decomposition, duplicate detection, and incident support. - Slack thread intake that prepares or creates structured Linear work after approval. - Scheduled daily triage, cycle health, backlog hygiene, project summaries, P0/P1 monitoring, and weekly initiative updates. - One Linear MCP connection with dynamic approval policy. No custom Linear SDK tools are included. ## Prerequisites - Node.js 24 or newer. - An Eve deployment URL that Linear and Slack can reach over HTTPS. - Access to create or configure a Linear Agent app. - Access to Vercel Connect for the Slack channel and the Linear MCP OAuth connection. - A Slack workspace where the agent app can be installed. - A Linear workspace where the MCP-authenticated user has access to the teams, projects, issues, and initiatives the agent should operate on. For local webhook testing, expose the local Eve server through a public HTTPS tunnel and use that public URL in Linear and Slack. ## Install And Verify The Agent Install the registry item into an existing Eve app: ```bash npx shadcn@latest add @evex/linear-operations-agent pnpm install ``` Then run the equivalent Eve checks for your app. In this packaged example the scripts are: ```bash pnpm info pnpm build ``` Run these after completing the Slack and Linear connector setup below. `pnpm info` should show: - channels: `linear` at `/eve/v1/linear` and `slack` at `/eve/v1/slack`; - one MCP connection named `linear`; - the scheduled jobs and skills included with the agent; - no custom Linear SDK tools. ## Deploy Or Expose The Eve App Both inbound channels need an HTTPS URL: - Linear sends `AgentSessionEvent` webhooks to `/eve/v1/linear`. - Slack sends Connect-triggered Slack events to `/eve/v1/slack`. For production on Vercel, Eve's Slack channel docs use: ```bash VERCEL_USE_EXPERIMENTAL_FRAMEWORKS=1 vercel deploy --prod ``` For local testing, expose the Eve dev server through a public HTTPS tunnel and use that tunnel URL in Linear and Slack. Do not configure Linear or Slack with a plain `localhost` URL. ## Environment Variables Start from `.env.example`: ```bash LINEAR_AGENT_ACCESS_TOKEN= LINEAR_WEBHOOK_SECRET= LINEAR_CONNECT_UID= SLACK_CONNECT_UID= LINEAR_OPS_DEFAULT_SLACK_CHANNEL_ID= LINEAR_OPS_TRIAGE_SLACK_CHANNEL_ID= LINEAR_OPS_CYCLE_SLACK_CHANNEL_ID= LINEAR_OPS_BACKLOG_SLACK_CHANNEL_ID= LINEAR_OPS_P1_SLACK_CHANNEL_ID= ``` The top-level credentials do different jobs: - `LINEAR_AGENT_ACCESS_TOKEN` is used by the Linear channel to post Agent Activities and manage Agent Sessions. - `LINEAR_CONNECT_UID` is the `uid` returned by `vercel connect create linear`. - `SLACK_CONNECT_UID` is the `uid` returned by `vercel connect create slack`. `LINEAR_AGENT_ACCESS_TOKEN` does not authorize Linear MCP tools. Linear MCP reads and writes use the Vercel Connect Linear connector referenced by `LINEAR_CONNECT_UID`. ## 1. Configure The Linear Channel Create or configure the Linear Agent app that represents this agent inside Linear. This setup is only for the Linear channel. It does not authorize the Linear MCP connection. In Linear: 1. Configure the app authorize URL with `actor=app`. 2. Grant the app agent scopes, including `app:assignable` and `app:mentionable`. 3. Subscribe the app webhook to `AgentSessionEvent`. 4. Set the webhook URL to: ```text https:///eve/v1/linear ``` 5. Copy the Linear webhook secret into `LINEAR_WEBHOOK_SECRET`. 6. Create or copy the app access token into `LINEAR_AGENT_ACCESS_TOKEN`. The channel accepts only Linear Agent Session events with action `created` or `prompted`. It ignores other Linear webhook events. If `LINEAR_OPS_COVERED_TEAMS` or `LINEAR_OPS_COVERED_PROJECTS` is configured, the channel also filters events by the issue team or project before waking the agent. Use this surface for: - `@agent triage this issue`; - `@agent find duplicates`; - delegating a Linear issue to the agent; - continuing a Linear Agent Session after the agent asks a question. ## 2. Configure The Slack Channel The Slack channel uses Vercel Connect. You do not configure `SLACK_BOT_TOKEN` or `SLACK_SIGNING_SECRET` directly in this agent. This setup is only for Slack delivery and intake. It does not authorize Linear MCP tools. Create a Slack Connect client and attach its trigger to Eve's Slack route: ```bash npm install -g vercel@latest vercel connect create slack --name linear-operations-agent --triggers --format=json vercel connect detach --yes vercel connect attach --triggers --trigger-path /eve/v1/slack --yes ``` Then set the returned `uid`: ```bash SLACK_CONNECT_UID= ``` The `--triggers` flag is required because Slack must deliver `app_mention` and direct message events to `/eve/v1/slack`. The channel loads recent thread context on app mentions with `since: "last-agent-reply"`, then tells the model that Slack is intake and delivery while Linear remains the operational source of truth. Use this surface for: - `@agent create a Linear issue from this thread`; - `@agent link this discussion to ENG-123`; - `@agent show me P1 issues without updates`; - scheduled digest delivery into configured Slack channels. ## 3. Configure The Linear MCP Connection This setup is for reading and writing Linear data through MCP tools. It is separate from the Linear Agent app webhook and separate from the Slack Connect client. The MCP connection is defined in `agent/connections/linear.ts`: ```ts defineMcpClientConnection({ url: "https://mcp.linear.app/mcp", auth: connect(getRequiredEnv("LINEAR_CONNECT_UID")), }); ``` Create a Vercel Connect connector of type `linear`: ```bash vercel connect create linear --name linear-operations-agent --format=json ``` Then set the returned `uid`: ```bash LINEAR_CONNECT_UID= ``` The first tool call that needs the Linear MCP connection can trigger an Eve authorization challenge. The user follows the sign-in URL, Vercel Connect stores and refreshes the Linear OAuth credential, and Eve retries the tool call. The token is not shown to the model or serialized into conversation history. The connection allow-list is: - read tools: `list_issues`, `get_issue`, `list_comments`, `list_projects`, `get_status_updates`, `list_cycles`, `list_issue_labels`, `list_issue_statuses`, `get_issue_status`, `extract_images`, `search_documentation`; - write tools: `save_issue`, `save_comment`, `save_project`, `save_document`, `save_status_update`, `delete_status_update`. ## 4. Configure Scope, Slack Delivery, And Schedules Team and project filters are comma-separated. Empty values mean all teams or all projects: ```bash LINEAR_OPS_COVERED_TEAMS=ENG,Web LINEAR_OPS_COVERED_PROJECTS=Payments Revamp,Mobile Foundations LINEAR_OPS_READ_ONLY_TEAMS=Platform ``` Slack schedule delivery uses channel IDs: ```bash LINEAR_OPS_DEFAULT_SLACK_CHANNEL_ID=C0123DEFAULT LINEAR_OPS_TRIAGE_SLACK_CHANNEL_ID=C0123TRIAGE LINEAR_OPS_CYCLE_SLACK_CHANNEL_ID=C0123CYCLE LINEAR_OPS_BACKLOG_SLACK_CHANNEL_ID=C0123BACKLOG LINEAR_OPS_P1_SLACK_CHANNEL_ID=C0123P1 ``` Project-specific Slack delivery uses `project-or-id:channel-id` pairs: ```bash LINEAR_OPS_PROJECT_CHANNELS=Payments Revamp:C0123PAY,Mobile Foundations:C0456MOB ``` Explicit initiative configuration uses: ```text initiative-id-or-name|optional-slack-channel-id|optional-enabled-flag ``` Example: ```bash LINEAR_OPS_COVERED_INITIATIVES="Payments Revamp|C0123PAY|true,Mobile Foundations||false" ``` Weekly initiative updates are automatic only when: - `LINEAR_OPS_AUTO_INITIATIVE_UPDATES` is not `false`; - the initiative is listed in `LINEAR_OPS_COVERED_INITIATIVES`; - that initiative's enabled flag is omitted or set to `true`; - Linear MCP supports initiative status updates in the workspace. The default cron values are UTC: ```bash LINEAR_OPS_DAILY_TRIAGE_CRON="0 7 * * 1-5" LINEAR_OPS_CYCLE_HEALTH_CRON="30 7 * * 1-5" LINEAR_OPS_WEEKLY_BACKLOG_CRON="0 8 * * 1" LINEAR_OPS_WEEKLY_PROJECT_CRON="30 8 * * 1" LINEAR_OPS_WEEKLY_INITIATIVE_CRON="0 9 * * 1" LINEAR_OPS_P1_MONITORING_CRON="0 13 * * 1-5" ``` Scheduled operational digests are delivered to Slack. Weekly initiative updates are created directly in Linear with `save_status_update({ type: "initiative" })`; Slack is used only for delivery errors or configured notification context. ## Approval Policy The approval policy is implemented on the single Linear MCP connection. No approval is required for: - read tools; - `save_comment` for non-destructive summaries or proposals; - `save_status_update` only when `type === "initiative"` and the initiative is explicitly configured for weekly updates. Approval is required for: - issue creation; - issue changes to state, priority, assignee, delegate, project, cycle, duplicate, parent, blocker, or related relationships; - high-priority issue writes where priority is `1` or `2`; - project writes; - document writes; - status update deletes; - bulk or irreversible actions. The approval predicate is synchronous and input-based. If deciding safely requires the current Linear state, the agent must first read with MCP, then ask for approval before the sensitive write. ## Smoke Tests After deployment and env setup: 1. In Linear, mention or delegate an issue: ```text @agent triage this issue ``` Expected: the agent replies in the Linear Agent Session and attaches proposals to the Linear context. 2. In Slack, mention the agent in a thread: ```text @agent summarize the thread and propose a Linear issue ``` Expected: the agent reads recent thread context, proposes Linear work, and asks for approval before sensitive changes. 3. From Slack or Linear, ask for a read-only Linear query: ```text @agent show me P1 issues without updates ``` Expected: if the caller has not authorized the Linear MCP connection yet, Eve surfaces a Linear Connect authorization challenge. After authorization, the agent can call the allowed Linear MCP read tools. 4. Trigger a development schedule: ```bash curl -X POST http://localhost:3000/eve/v1/dev/schedules/daily-triage-digest ``` Other schedule ids are `cycle-health`, `weekly-backlog-hygiene`, `weekly-project-summary`, `weekly-initiative-updates`, and `p1-monitoring`. ## Troubleshooting If Linear mentions do nothing, check that the Linear app webhook points to `/eve/v1/linear`, subscribes to `AgentSessionEvent`, and sends a valid `Linear-Signature` matching `LINEAR_WEBHOOK_SECRET`. If Linear Agent Session replies fail, check `LINEAR_AGENT_ACCESS_TOKEN`. This token lets the channel post Agent Activities and manage Agent Sessions; it is not used for Linear MCP reads or writes. If Slack mentions do nothing, check that the Slack Connect client is attached with `--triggers` and `--trigger-path /eve/v1/slack`, and that `SLACK_CONNECT_UID` matches the created connector UID. If Slack-triggered Linear reads or writes fail with authorization required, complete the Linear MCP Connect sign-in flow for the caller. `LINEAR_CONNECT_UID` must match the Linear Connect OAuth connector, not the Slack connector. If scheduled jobs do not post, set the relevant Slack channel ID env var. The schedule handlers return without posting when no target channel ID is configured. If weekly initiative updates do not write to Linear, confirm the initiative is explicitly listed in `LINEAR_OPS_COVERED_INITIATIVES` and that the workspace supports Linear initiatives or roadmaps. 4e:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[["$","div",null,{"className":"flex shrink-0 items-start gap-3","children":[["$","div",null,{"className":"flex max-h-28 min-w-0 flex-1 flex-wrap items-center gap-2 overflow-y-auto","children":[["$","ul",null,{"className":"flex min-w-0 flex-wrap gap-2","aria-label":"Package dependencies","children":[["$","li","@vercel/connect@^0.2.6",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/%40vercel%2Fconnect","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"@vercel/connect@^0.2.6"}]]}]}],["$","li","ai@^7.0.38",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/ai","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"ai@^7.0.38"}]]}]}],["$","li","eve@^0.47.5",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/eve","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"eve@^0.47.5"}]]}]}]]}],["$","$L4f",null,{"namespace":"@evex","registryDependencies":[]}]]}],null]}],["$","$L50",null,{"files":[{"path":"agent/agent.ts","content":"import { defineAgent } from \"eve\";\n\nexport default defineAgent({\n model: \"openai/gpt-5.4-mini\",\n});\n","type":"registry:file","target":"~/agent/agent.ts"},{"path":"agent/channels/linear.ts","content":"$51","type":"registry:file","target":"~/agent/channels/linear.ts"},{"path":"agent/channels/slack.ts","content":"$52","type":"registry:file","target":"~/agent/channels/slack.ts"},{"path":"agent/connections/linear.ts","content":"$53","type":"registry:file","target":"~/agent/connections/linear.ts"},{"path":"agent/instructions.md","content":"$54","type":"registry:file","target":"~/agent/instructions.md"},{"path":"agent/lib/linear-operations-config.ts","content":"$55","type":"registry:file","target":"~/agent/lib/linear-operations-config.ts"},{"path":"agent/schedules/cycle-health.ts","content":"import { defineSchedule } from \"eve/schedules\";\n\nimport slack from \"../channels/slack.js\";\nimport { getSlackChannelId, linearOperationsConfig } from \"../lib/linear-operations-config.js\";\n\nexport default defineSchedule({\n cron: linearOperationsConfig.schedules.cycleHealth,\n async run({ to, waitUntil, appAuth }) {\n const channelId = getSlackChannelId(\"cycle\");\n if (!channelId) return;\n\n waitUntil(\n to(slack, { channelId }).send(\n \"Run the Linear cycle health report for configured teams and current cycles. Check blocked issues, stale P0/P1 issues, owner overload, work added after the cycle started, scope creep, and completed work not closed. Deliver the operational report to Slack. Do not apply Linear updates automatically.\",\n { auth: appAuth }\n ),\n );\n },\n});\n","type":"registry:file","target":"~/agent/schedules/cycle-health.ts"},{"path":"agent/schedules/daily-triage-digest.ts","content":"import { defineSchedule } from \"eve/schedules\";\n\nimport slack from \"../channels/slack.js\";\nimport { getSlackChannelId, linearOperationsConfig } from \"../lib/linear-operations-config.js\";\n\nexport default defineSchedule({\n cron: linearOperationsConfig.schedules.dailyTriageDigest,\n async run({ to, waitUntil, appAuth }) {\n const channelId = getSlackChannelId(\"triage\");\n if (!channelId) return;\n\n waitUntil(\n to(slack, { channelId }).send(\n \"Run the daily Linear triage digest in read-only mode. Highlight only issues that need attention: in triage too long, missing owner, missing priority, stale updates, likely duplicates, or blocked work. Deliver a concise Slack digest with concrete next steps. Do not modify Linear objects.\",\n { auth: appAuth }\n ),\n );\n },\n});\n","type":"registry:file","target":"~/agent/schedules/daily-triage-digest.ts"},{"path":"agent/schedules/p1-monitoring.ts","content":"import { defineSchedule } from \"eve/schedules\";\n\nimport slack from \"../channels/slack.js\";\nimport { getSlackChannelId, linearOperationsConfig } from \"../lib/linear-operations-config.js\";\n\nexport default defineSchedule({\n cron: linearOperationsConfig.schedules.p1Monitoring,\n async run({ to, waitUntil, appAuth }) {\n const channelId = getSlackChannelId(\"p1Monitoring\");\n if (!channelId) return;\n\n waitUntil(\n to(slack, { channelId }).send(\n \"Monitor Linear P0/P1 issues in read-only mode. Alert only on critical issues without recent updates, missing owner, unresolved blockers, or unclear next action. Do not change state or priority.\",\n { auth: appAuth }\n ),\n );\n },\n});\n","type":"registry:file","target":"~/agent/schedules/p1-monitoring.ts"},{"path":"agent/schedules/weekly-backlog-hygiene.ts","content":"import { defineSchedule } from \"eve/schedules\";\n\nimport slack from \"../channels/slack.js\";\nimport { getSlackChannelId, linearOperationsConfig } from \"../lib/linear-operations-config.js\";\n\nexport default defineSchedule({\n cron: linearOperationsConfig.schedules.weeklyBacklogHygiene,\n async run({ to, waitUntil, appAuth }) {\n const channelId = getSlackChannelId(\"backlog\");\n if (!channelId) return;\n\n waitUntil(\n to(slack, { channelId }).send(\n \"Run weekly Linear backlog hygiene in proposal-only mode. Find stale, probably obsolete, duplicate, ownerless, priorityless, and under-specified issues. Group findings and propose concrete cleanup actions. Do not close, archive, reprioritize, or bulk update issues without approval.\",\n { auth: appAuth }\n ),\n );\n },\n});\n","type":"registry:file","target":"~/agent/schedules/weekly-backlog-hygiene.ts"},{"path":"agent/schedules/weekly-initiative-updates.ts","content":"$56","type":"registry:file","target":"~/agent/schedules/weekly-initiative-updates.ts"},{"path":"agent/schedules/weekly-project-summary.ts","content":"import { defineSchedule } from \"eve/schedules\";\n\nimport slack from \"../channels/slack.js\";\nimport { getSlackChannelId, linearOperationsConfig } from \"../lib/linear-operations-config.js\";\n\nexport default defineSchedule({\n cron: linearOperationsConfig.schedules.weeklyProjectSummary,\n async run({ to, waitUntil, appAuth }) {\n const channelId = getSlackChannelId(\"default\");\n if (!channelId) return;\n\n waitUntil(\n to(slack, { channelId }).send(\n \"Run the weekly Linear project summary for configured projects. Summarize state, recent progress, completed issues, open work, blockers, risks, pending decisions, next steps, and scope changes. Deliver the report to Slack. Use Linear project/status update writes only when explicitly requested and approved.\",\n { auth: appAuth }\n ),\n );\n },\n});\n","type":"registry:file","target":"~/agent/schedules/weekly-project-summary.ts"},{"path":"agent/skills/backlog-hygiene/SKILL.md","content":"---\nname: backlog-hygiene\ndescription: Find stale, obsolete, duplicate, under-specified, ownerless, and priorityless Linear backlog issues.\n---\n\n# Backlog hygiene\n\nUse for backlog cleanup requests or weekly backlog hygiene schedules.\n\n## Process\n\n1. Read configured team and project backlogs. **Done when** each configured\n backlog has been scanned.\n2. Identify stale, obsolete, duplicate, ownerless, priorityless, and unclear\n issues.\n3. Group findings by recommended action.\n4. Keep bulk recommendations under the configured max bulk issue count unless\n asked otherwise.\n5. Propose cleanup actions instead of applying them automatically.\n\n## Output\n\nUse the agent default response shape, plus backlog findings, suggested cleanup\nactions, duplicates or obsolete issues, and clarification candidates.\n","type":"registry:file","target":"~/agent/skills/backlog-hygiene/SKILL.md"},{"path":"agent/skills/clarification/SKILL.md","content":"---\nname: clarification\ndescription: Rewrite a vague Linear request into a clear problem statement with context, acceptance criteria, out of scope, and open questions.\n---\n\n# Clarification\n\nUse when a Linear issue or Slack intake is vague, incomplete, or not ready for\nimplementation.\n\n## Process\n\n1. Read the source issue, comments, and relevant Slack thread context if\n available. **Done when** problem, user impact, current behavior, expected\n behavior, and constraints are extracted.\n2. Draft a clearer description without inventing facts.\n3. Add acceptance criteria that can be verified.\n4. Mark out-of-scope items to prevent scope creep.\n5. List open questions and missing evidence.\n\n## Output\n\nUse the agent default response shape, plus problem, context, acceptance\ncriteria, out of scope, open questions, and proposed Linear update.\n","type":"registry:file","target":"~/agent/skills/clarification/SKILL.md"},{"path":"agent/skills/cycle-health/SKILL.md","content":"---\nname: cycle-health\ndescription: Analyze Linear cycle health, including blocked work, stale updates, scope creep, owner overload, and risky current-cycle issues.\n---\n\n# Cycle health\n\nUse for current-cycle reports or schedule-driven cycle health checks.\n\n## Process\n\n1. Identify configured teams and their current cycle. **Done when** each\n configured team's active cycle is known.\n2. Read open and recently completed cycle issues.\n3. Flag blocked issues, stale P0/P1 work, ownerless work, work added after cycle\n start, and completed work not closed. **Done when** each flag category is\n checked.\n4. Look for owner overload and unresolved dependencies.\n5. Keep the Slack report concise and action-oriented.\n6. Do not update Linear automatically during scheduled cycle reports.\n\n## Output\n\nUse the agent default response shape, plus health status, key risks, issues\nneeding attention, scope changes, and recommended standup topics.\n","type":"registry:file","target":"~/agent/skills/cycle-health/SKILL.md"},{"path":"agent/skills/decomposition/SKILL.md","content":"---\nname: decomposition\ndescription: Break a complex Linear issue into implementable sub-issues, dependencies, risks, and an approval-gated creation plan.\n---\n\n# Decomposition\n\nUse when a user asks to split an issue into tasks, sub-issues, milestones, or\nimplementation steps.\n\n## Process\n\n1. Read the parent issue and relevant comments. **Done when** scope and\n constraints are captured.\n2. Identify independent work units that can be implemented and reviewed\n separately. **Done when** each unit has a clear deliverable.\n3. Order tasks by dependency and risk.\n4. Propose ownership where there is enough evidence; otherwise mark owner as\n unknown.\n5. Include qualitative complexity and risk notes.\n\n## Output\n\nUse the agent default response shape, plus proposed sub-issues, dependency\norder, risks, and ownership suggestions.\n","type":"registry:file","target":"~/agent/skills/decomposition/SKILL.md"},{"path":"agent/skills/duplicate-detection/SKILL.md","content":"---\nname: duplicate-detection\ndescription: Find likely duplicate Linear issues, compare evidence, and propose link, merge, or closure actions.\n---\n\n# Duplicate detection\n\nUse when a user asks whether an issue is duplicated or related.\n\n## Process\n\n1. Extract search terms from title, description, error messages, product area,\n labels, and comments.\n2. Use `list_issues` with targeted queries. **Done when** at least one search\n has run.\n3. Use `get_issue` on the strongest candidates before recommending. **Done when**\n each candidate's scope, symptoms, environment, impacted user flow, and status\n are compared.\n4. Recommend the canonical issue to keep open.\n5. Propose duplicate links, status changes, or closures only after comparison is\n complete.\n\n## Output\n\nUse the agent default response shape, plus candidate duplicates, why they match\nor do not match, recommended canonical issue, and proposed Linear action.\n","type":"registry:file","target":"~/agent/skills/duplicate-detection/SKILL.md"},{"path":"agent/skills/incident-support/SKILL.md","content":"$57","type":"registry:file","target":"~/agent/skills/incident-support/SKILL.md"},{"path":"agent/skills/initiative-reporting/SKILL.md","content":"$58","type":"registry:file","target":"~/agent/skills/initiative-reporting/SKILL.md"},{"path":"agent/skills/project-reporting/SKILL.md","content":"---\nname: project-reporting\ndescription: Produce Linear project reports covering status, progress, open work, blockers, risks, decisions, next steps, and scope changes.\n---\n\n# Project reporting\n\nUse for project summaries, weekly project reports, and project decision support.\n\n## Process\n\n1. Read project metadata, status updates, linked issues, labels, and comments.\n **Done when** current state and recent progress are captured.\n2. List completed work and open work that matters.\n3. Highlight blockers, risks, pending decisions, and scope changes.\n4. Recommend next steps. Every recommendation must be evidence-backed.\n5. Deliver scheduled summaries to Slack. Write Linear project or status updates\n only when requested and approved.\n\n## Output\n\nUse the agent default response shape, plus project status, recent progress,\nblockers, risks, pending decisions, and next steps.\n","type":"registry:file","target":"~/agent/skills/project-reporting/SKILL.md"},{"path":"agent/skills/slack-intake/SKILL.md","content":"---\nname: slack-intake\ndescription: Turn a Slack thread into structured Linear work while preserving decisions, action items, and missing context.\n---\n\n# Slack intake\n\nUse when a Slack mention asks to summarize a thread, create a Linear issue, link\ndiscussion to an issue, or identify what is missing before ticket creation.\n\n## Process\n\n1. Read the provided thread context. **Done when** discussion, decisions, action\n items, evidence, and unresolved questions are separated.\n2. Draft a Linear issue title and body from that structure.\n3. Suggest team, priority, labels, and project only when evidence supports them.\n4. After approval, create or modify the Linear issue and respond in Slack with\n the Linear link and what was included.\n\n## Output\n\nUse the agent default response shape, plus thread summary, decision or action,\nand proposed Linear issue.\n","type":"registry:file","target":"~/agent/skills/slack-intake/SKILL.md"},{"path":"agent/skills/triage/SKILL.md","content":"$59","type":"registry:file","target":"~/agent/skills/triage/SKILL.md"},{"path":"evals/evals.config.ts","content":"import { defineEvalConfig } from \"eve/evals\";\n\nexport default defineEvalConfig({\n timeoutMs: 120_000,\n});\n","type":"registry:file","target":"~/evals/evals.config.ts"},{"path":"evals/triage-proposes-without-writing.eval.ts","content":"$5a","type":"registry:file","target":"~/evals/triage-proposes-without-writing.eval.ts"},{"path":"evals/unconfigured-initiative-no-update.eval.ts","content":"$5b","type":"registry:file","target":"~/evals/unconfigured-initiative-no-update.eval.ts"},{"path":"README.md","content":"$5c","type":"registry:file","target":"~/agent/README.md"},{"path":".env.example","content":"LINEAR_AGENT_ACCESS_TOKEN=\nLINEAR_WEBHOOK_SECRET=\nLINEAR_CONNECT_UID=\nSLACK_CONNECT_UID=\n\nLINEAR_OPS_COVERED_TEAMS=\nLINEAR_OPS_COVERED_PROJECTS=\nLINEAR_OPS_COVERED_INITIATIVES=\nLINEAR_OPS_READ_ONLY_TEAMS=\nLINEAR_OPS_MAX_BULK_ISSUE_COUNT=10\nLINEAR_OPS_AUTO_INITIATIVE_UPDATES=true\n\nLINEAR_OPS_DEFAULT_SLACK_CHANNEL_ID=\nLINEAR_OPS_TRIAGE_SLACK_CHANNEL_ID=\nLINEAR_OPS_CYCLE_SLACK_CHANNEL_ID=\nLINEAR_OPS_BACKLOG_SLACK_CHANNEL_ID=\nLINEAR_OPS_P1_SLACK_CHANNEL_ID=\nLINEAR_OPS_PROJECT_CHANNELS=\n\nLINEAR_OPS_DAILY_TRIAGE_CRON=\"0 7 * * 1-5\"\nLINEAR_OPS_CYCLE_HEALTH_CRON=\"30 7 * * 1-5\"\nLINEAR_OPS_WEEKLY_BACKLOG_CRON=\"0 8 * * 1\"\nLINEAR_OPS_WEEKLY_PROJECT_CRON=\"30 8 * * 1\"\nLINEAR_OPS_WEEKLY_INITIATIVE_CRON=\"0 9 * * 1\"\nLINEAR_OPS_P1_MONITORING_CRON=\"0 13 * * 1-5\"\n","type":"registry:file","target":"~/.env.example"}],"className":"h-[70svh] min-h-80"}]]}]