@calltelemetry/openclaw-linear 0.8.3 → 0.8.4

package/README.md

@@ -12,6 +12,7 @@ Connect Linear to AI agents. Issues get triaged, implemented, and audited — au
 - **New issue?** Agent estimates story points, adds labels, sets priority.
 - **Assign to agent?** A worker implements it, an independent auditor verifies it, done.
 - **Comment anything?** The bot understands natural language — no magic commands needed.
+- **Say "close this" or "mark as done"?** Agent writes a closure report and transitions the issue to completed.
 - **Say "let's plan the features"?** A planner interviews you, writes user stories, and builds your full issue hierarchy.
 - **Plan looks good?** A different AI model automatically audits the plan before dispatch.
 - **Agent goes silent?** A watchdog kills it and retries automatically.
@@ -118,7 +119,7 @@ Every issue moves through a clear pipeline. Here's exactly what happens at each
 
 **Trigger:** You create a new issue.
 
-The agent reads your issue, estimates story points, adds labels, sets priority, and posts an assessment comment — all within seconds.
+The agent reads your issue, estimates story points, adds labels, sets priority, and posts an assessment comment — all within seconds. Triage runs in **read-only mode** (no file writes, no code execution) to prevent side effects.
 
 **What you'll see in Linear:**
 
@@ -305,6 +306,7 @@ User comment → Intent Classifier (small model, ~2s) → Route to handler
 | "hey kaylee can you look at this?" | Routes to Kaylee (no `@` needed) |
 | "what can I do here?" | Default agent responds (not silently dropped) |
 | "fix the search bug" | Default agent dispatches work |
+| "close this" / "mark as done" / "this is resolved" | Generates closure report, transitions issue to completed |
 
 `@mentions` still work as a fast path — if you write `@kaylee`, the classifier is skipped entirely for speed.
 
@@ -327,7 +329,11 @@ The webhook handler prevents double-processing through a two-tier guard system:
 | `Issue.create` | `issue-create:<issueId>` | wasRecentlyProcessed → activeRuns → planning mode → bot-created |
 | `AppUserNotification` | *(immediate discard)* | — |
 
-**Comment echo prevention:** All comments posted by the handler use `createCommentWithDedup()`, which pre-registers the comment's ID in `wasRecentlyProcessed` immediately after the API returns. When Linear echoes the `Comment.create` webhook back, it's caught before any processing.
+`AppUserNotification` events are discarded because they duplicate events already received via the workspace webhook (e.g., `Comment.create` for mentions, `Issue.update` for assignments). Processing both would cause double agent runs.
+
+**Response delivery:** When an agent session exists, responses are delivered via `emitActivity(type: "response")` — not `createComment`. This prevents duplicate visible messages on the issue. `createComment` is only used as a fallback when `emitActivity` fails or when no agent session exists.
+
+**Comment echo prevention:** Comments posted outside of sessions use `createCommentWithDedup()`, which pre-registers the comment's ID in `wasRecentlyProcessed` immediately after the API returns. When Linear echoes the `Comment.create` webhook back, it's caught before any processing.
 
 ---
 
@@ -436,6 +442,7 @@ If an issue gets stuck (all retries failed), dependent issues are blocked and yo
 | Comment anything on an issue | Intent classifier routes to the right handler |
 | Mention an agent by name (with or without `@`) | That agent responds |
 | Ask a question or request work | Default agent handles it |
+| Say "close this" / "mark as done" / "this is resolved" | Closure report posted, issue moved to completed |
 | Say "plan this project" (on a project issue) | Planning interview starts |
 | Reply during planning | Issues created/updated with user stories & AC |
 | Say "looks good" / "finalize plan" | Validates → cross-model review → approval |
@@ -899,7 +906,7 @@ Every warning and error includes a `→` line telling you what to do. Run `docto
 
 ### Unit tests
 
-454 tests covering the full pipeline — triage, dispatch, audit, planning, intent classification, cross-model review, notifications, and infrastructure:
+524 tests covering the full pipeline — triage, dispatch, audit, planning, intent classification, cross-model review, notifications, and infrastructure:
 
 ```bash
 cd ~/claw-extensions/linear

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calltelemetry/openclaw-linear",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "Linear Agent plugin for OpenClaw — webhook-driven AI pipeline with OAuth, multi-agent routing, and issue triage",
   "type": "module",
   "license": "MIT",

package/src/__test__/webhook-scenarios.test.ts

@@ -28,6 +28,7 @@ const {
   mockUpdateSession,
   mockUpdateIssue,
   mockGetTeamLabels,
+  mockGetTeamStates,
   mockCreateSessionOnIssue,
   mockClassifyIntent,
   mockSpawnWorker,
@@ -43,6 +44,7 @@ const {
   mockUpdateSession: vi.fn(),
   mockUpdateIssue: vi.fn(),
   mockGetTeamLabels: vi.fn(),
+  mockGetTeamStates: vi.fn(),
   mockCreateSessionOnIssue: vi.fn(),
   mockClassifyIntent: vi.fn(),
   mockSpawnWorker: vi.fn(),
@@ -66,6 +68,7 @@ vi.mock("../api/linear-api.js", () => ({
     getViewerId = mockGetViewerId;
     updateIssue = mockUpdateIssue;
     getTeamLabels = mockGetTeamLabels;
+    getTeamStates = mockGetTeamStates;
     createSessionOnIssue = mockCreateSessionOnIssue;
   },
   resolveLinearToken: vi.fn().mockReturnValue({
@@ -265,6 +268,12 @@ beforeEach(() => {
     { id: "label-bug", name: "Bug" },
     { id: "label-feature", name: "Feature" },
   ]);
+  mockGetTeamStates.mockResolvedValue([
+    { id: "st-backlog", name: "Backlog", type: "backlog" },
+    { id: "st-started", name: "In Progress", type: "started" },
+    { id: "st-done", name: "Done", type: "completed" },
+    { id: "st-canceled", name: "Canceled", type: "canceled" },
+  ]);
   mockRunAgent.mockResolvedValue({ success: true, output: "Agent response text" });
   mockSpawnWorker.mockResolvedValue(undefined);
   mockClassifyIntent.mockResolvedValue({
@@ -487,6 +496,58 @@ describe("webhook scenario tests — full handler flows", () => {
       expect(logs.some((l) => l.includes("no action taken"))).toBe(true);
       expect(mockRunAgent).not.toHaveBeenCalled();
     });
+
+    it("close_issue intent: generates closure report, transitions state, posts comment", async () => {
+      mockClassifyIntent.mockResolvedValue({
+        intent: "close_issue",
+        reasoning: "user wants to close the issue",
+        fromFallback: false,
+      });
+
+      mockRunAgent.mockResolvedValueOnce({
+        success: true,
+        output: "**Summary**: Fixed the authentication bug.\n**Resolution**: Updated token refresh logic.",
+      });
+
+      const api = createApi();
+      const payload = makeCommentCreate({
+        data: {
+          id: "comment-close-1",
+          body: "close this issue",
+          user: { id: "user-human", name: "Human" },
+          issue: {
+            id: "issue-close-1",
+            identifier: "ENG-400",
+            title: "Auth bug fix",
+            team: { id: "team-1" },
+            project: null,
+          },
+          createdAt: new Date().toISOString(),
+        },
+      });
+      await postWebhook(api, payload);
+
+      await waitForMock(mockClearActiveSession);
+
+      // Agent ran with readOnly for closure report
+      expect(mockRunAgent).toHaveBeenCalledOnce();
+      const runArgs = mockRunAgent.mock.calls[0][0];
+      expect(runArgs.readOnly).toBe(true);
+      expect(runArgs.message).toContain("closure report");
+
+      // Issue state transitioned to completed
+      expect(mockUpdateIssue).toHaveBeenCalledWith("issue-close-1", { stateId: "st-done" });
+
+      // Team states fetched to find completed state
+      expect(mockGetTeamStates).toHaveBeenCalledWith("team-1");
+
+      // Closure report posted via emitActivity
+      const responseCalls = activityCallsOfType("response");
+      expect(responseCalls.length).toBeGreaterThan(0);
+      const reportBody = (responseCalls[0][1] as any).body;
+      expect(reportBody).toContain("Closure Report");
+      expect(reportBody).toContain("authentication bug");
+    });
   });
 
   describe("Issue.update", () => {

package/src/pipeline/intent-classify.test.ts

@@ -195,6 +195,19 @@ describe("classifyIntent", () => {
     const call = runAgentMock.mock.calls[0][0];
     expect(call.message).not.toContain("x".repeat(501));
   });
+
+  it("parses close_issue intent from LLM response", async () => {
+    runAgentMock.mockResolvedValueOnce({
+      success: true,
+      output: '{"intent":"close_issue","reasoning":"user wants to close the issue"}',
+    });
+
+    const result = await classifyIntent(createApi(), createCtx({ commentBody: "close this" }));
+
+    expect(result.intent).toBe("close_issue");
+    expect(result.reasoning).toBe("user wants to close the issue");
+    expect(result.fromFallback).toBe(false);
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -281,5 +294,35 @@ describe("regexFallback", () => {
       expect(result.intent).toBe("general");
       expect(result.fromFallback).toBe(true);
     });
+
+    it("detects close_issue for 'close this' pattern", () => {
+      const result = regexFallback(createCtx({
+        commentBody: "close this issue",
+      }));
+      expect(result.intent).toBe("close_issue");
+      expect(result.fromFallback).toBe(true);
+    });
+
+    it("detects close_issue for 'mark as done' pattern", () => {
+      const result = regexFallback(createCtx({
+        commentBody: "mark as done",
+      }));
+      expect(result.intent).toBe("close_issue");
+    });
+
+    it("detects close_issue for 'this is resolved' pattern", () => {
+      const result = regexFallback(createCtx({
+        commentBody: "this is resolved",
+      }));
+      expect(result.intent).toBe("close_issue");
+    });
+
+    it("does NOT detect close_issue for ambiguous text", () => {
+      const result = regexFallback(createCtx({
+        commentBody: "I think this might be resolved soon",
+        agentNames: [],
+      }));
+      expect(result.intent).toBe("general");
+    });
   });
 });

package/src/pipeline/intent-classify.ts

@@ -23,6 +23,7 @@ export type Intent =
   | "ask_agent"
   | "request_work"
   | "question"
+  | "close_issue"
   | "general";
 
 export interface IntentResult {
@@ -55,6 +56,7 @@ const VALID_INTENTS: Set<string> = new Set([
   "ask_agent",
   "request_work",
   "question",
+  "close_issue",
   "general",
 ]);
 
@@ -72,12 +74,14 @@ Intents:
 - ask_agent: user is addressing a specific agent by name
 - request_work: user wants something built, fixed, or implemented
 - question: user asking for information or help
+- close_issue: user wants to close/complete/resolve the issue (e.g. "close this", "mark as done", "resolved")
 - general: none of the above, automated messages, or noise
 
 Rules:
 - plan_start ONLY if the issue belongs to a project (hasProject=true)
 - If planning mode is active and no clear finalize/abandon intent, default to plan_continue
 - For ask_agent, set agentId to the matching name from Available agents
+- close_issue only for explicit closure requests, NOT ambiguous comments about resolution
 - One sentence reasoning`;
 
 // ---------------------------------------------------------------------------
@@ -188,6 +192,7 @@ function parseIntentResponse(raw: string, ctx: IntentContext): IntentResult | nu
 const PLAN_START_PATTERN = /\b(plan|planning)\s+(this\s+)(project|out)\b|\bplan\s+this\s+out\b/i;
 const FINALIZE_PATTERN = /\b(finalize\s+(the\s+)?plan\b|done\s+planning\b(?!\s+\w)|approve\s+(the\s+)?plan\b|plan\s+looks\s+good\b|ready\s+to\s+finalize\b|let'?s\s+finalize\b)/i;
 const ABANDON_PATTERN = /\b(abandon\s+plan(ning)?|cancel\s+plan(ning)?|stop\s+planning|exit\s+planning|quit\s+planning)\b/i;
+const CLOSE_ISSUE_PATTERN = /\b(close\s+(this|the\s+issue)|mark\s+(as\s+)?(done|completed?|resolved)|this\s+is\s+(done|resolved|completed?)|resolve\s+(this|the\s+issue))\b/i;
 
 export function regexFallback(ctx: IntentContext): IntentResult {
   const text = ctx.commentBody;
@@ -209,6 +214,11 @@ export function regexFallback(ctx: IntentContext): IntentResult {
     return { intent: "plan_start", reasoning: "regex: plan start pattern matched", fromFallback: true };
   }
 
+  // Close issue detection
+  if (CLOSE_ISSUE_PATTERN.test(text)) {
+    return { intent: "close_issue", reasoning: "regex: close issue pattern matched", fromFallback: true };
+  }
+
   // Agent name detection
   if (ctx.agentNames.length > 0) {
     const lower = text.toLowerCase();

package/src/pipeline/webhook.ts

@@ -805,6 +805,14 @@ export async function handleLinearWebhook(
         break;
       }
 
+      case "close_issue": {
+        const closeAgent = resolveAgentId(api);
+        api.logger.info(`Comment intent close_issue: closing ${issue.identifier ?? issue.id} via ${closeAgent}`);
+        void handleCloseIssue(api, linearApi, profiles, closeAgent, issue, comment, commentBody, commentor, pluginConfig)
+          .catch((err) => api.logger.error(`Close issue error: ${err}`));
+        break;
+      }
+
       case "general":
       default:
         api.logger.info(`Comment intent general: no action taken for ${issue.identifier ?? issue.id}`);
@@ -1284,6 +1292,172 @@ async function dispatchCommentToAgent(
   }
 }
 
+// ── Close issue handler ──────────────────────────────────────────
+//
+// Triggered by close_issue intent. Generates a closure report via agent,
+// transitions issue to completed state, and posts the report.
+
+async function handleCloseIssue(
+  api: OpenClawPluginApi,
+  linearApi: LinearAgentApi,
+  profiles: Record<string, AgentProfile>,
+  agentId: string,
+  issue: any,
+  comment: any,
+  commentBody: string,
+  commentor: string,
+  pluginConfig?: Record<string, unknown>,
+): Promise<void> {
+  const profile = profiles[agentId];
+  const label = profile?.label ?? agentId;
+  const avatarUrl = profile?.avatarUrl;
+
+  if (activeRuns.has(issue.id)) {
+    api.logger.info(`handleCloseIssue: ${issue.identifier ?? issue.id} has active run — skipping`);
+    return;
+  }
+
+  // Fetch full issue details
+  let enrichedIssue: any = issue;
+  try {
+    enrichedIssue = await linearApi.getIssueDetails(issue.id);
+  } catch (err) {
+    api.logger.warn(`Could not fetch issue details for close: ${err}`);
+  }
+
+  const issueRef = enrichedIssue?.identifier ?? issue.identifier ?? issue.id;
+  const teamId = enrichedIssue?.team?.id ?? issue.team?.id;
+
+  // Find completed state
+  let completedStateId: string | null = null;
+  if (teamId) {
+    try {
+      const states = await linearApi.getTeamStates(teamId);
+      const completedState = states.find((s: any) => s.type === "completed");
+      if (completedState) completedStateId = completedState.id;
+    } catch (err) {
+      api.logger.warn(`Could not fetch team states for close: ${err}`);
+    }
+  }
+
+  // Build closure report prompt
+  const description = enrichedIssue?.description ?? issue?.description ?? "(no description)";
+  const comments = enrichedIssue?.comments?.nodes ?? [];
+  const commentSummary = comments
+    .slice(-10)
+    .map((c: any) => `**${c.user?.name ?? "Unknown"}**: ${(c.body ?? "").slice(0, 300)}`)
+    .join("\n");
+
+  const message = [
+    `You are writing a closure report for a Linear issue that is being marked as done.`,
+    `Your text output will be posted as the closing comment on the issue.`,
+    ``,
+    `## Issue: ${issueRef} — ${enrichedIssue?.title ?? issue.title ?? "(untitled)"}`,
+    `**Status:** ${enrichedIssue?.state?.name ?? "Unknown"} | **Assignee:** ${enrichedIssue?.assignee?.name ?? "Unassigned"}`,
+    ``,
+    `**Description:**`,
+    description,
+    commentSummary ? `\n**Comment history:**\n${commentSummary}` : "",
+    `\n**${commentor} says (closure request):**\n> ${commentBody}`,
+    ``,
+    `Write a concise closure report with:`,
+    `- **Summary**: What was done (1-2 sentences)`,
+    `- **Resolution**: How it was resolved`,
+    `- **Notes**: Any follow-up items or caveats (if applicable)`,
+    ``,
+    `Keep it brief and factual. Use markdown formatting.`,
+  ].filter(Boolean).join("\n");
+
+  // Execute with session lifecycle
+  activeRuns.add(issue.id);
+  let agentSessionId: string | null = null;
+
+  try {
+    const sessionResult = await linearApi.createSessionOnIssue(issue.id);
+    agentSessionId = sessionResult.sessionId;
+    if (agentSessionId) {
+      wasRecentlyProcessed(`session:${agentSessionId}`);
+      setActiveSession({
+        agentSessionId,
+        issueIdentifier: issueRef,
+        issueId: issue.id,
+        agentId,
+        startedAt: Date.now(),
+      });
+    }
+
+    if (agentSessionId) {
+      await linearApi.emitActivity(agentSessionId, {
+        type: "thought",
+        body: `${label} is preparing closure report for ${issueRef}...`,
+      }).catch(() => {});
+    }
+
+    // Run agent for closure report
+    const { runAgent } = await import("../agent/agent.js");
+    const result = await runAgent({
+      api,
+      agentId,
+      sessionId: `linear-close-${agentId}-${Date.now()}`,
+      message,
+      timeoutMs: 2 * 60_000,
+      readOnly: true,
+    });
+
+    const closureReport = result.success
+      ? result.output
+      : "Issue closed. (Closure report generation failed.)";
+
+    const fullReport = `## Closure Report\n\n${closureReport}`;
+
+    // Transition issue to completed state
+    if (completedStateId) {
+      try {
+        await linearApi.updateIssue(issue.id, { stateId: completedStateId });
+        api.logger.info(`Closed issue ${issueRef} (state → completed)`);
+      } catch (err) {
+        api.logger.error(`Failed to transition issue ${issueRef} to completed: ${err}`);
+      }
+    } else {
+      api.logger.warn(`No completed state found for ${issueRef} — posting report without state change`);
+    }
+
+    // Post closure report via emitActivity-first pattern
+    if (agentSessionId) {
+      const labeledReport = `**[${label}]** ${fullReport}`;
+      const emitted = await linearApi.emitActivity(agentSessionId, {
+        type: "response",
+        body: labeledReport,
+      }).then(() => true).catch(() => false);
+
+      if (!emitted) {
+        const agentOpts = avatarUrl
+          ? { createAsUser: label, displayIconUrl: avatarUrl }
+          : undefined;
+        await postAgentComment(api, linearApi, issue.id, fullReport, label, agentOpts);
+      }
+    } else {
+      const agentOpts = avatarUrl
+        ? { createAsUser: label, displayIconUrl: avatarUrl }
+        : undefined;
+      await postAgentComment(api, linearApi, issue.id, fullReport, label, agentOpts);
+    }
+
+    api.logger.info(`Posted closure report for ${issueRef}`);
+  } catch (err) {
+    api.logger.error(`handleCloseIssue error: ${err}`);
+    if (agentSessionId) {
+      await linearApi.emitActivity(agentSessionId, {
+        type: "error",
+        body: `Failed to close issue: ${String(err).slice(0, 500)}`,
+      }).catch(() => {});
+    }
+  } finally {
+    clearActiveSession(issue.id);
+    activeRuns.delete(issue.id);
+  }
+}
+
 // ── @dispatch handler ─────────────────────────────────────────────
 //
 // Triggered by `@dispatch` in a Linear comment. Assesses issue complexity,