@calltelemetry/openclaw-linear 0.9.3 → 0.9.4

package/src/pipeline/webhook.test.ts

@@ -24,6 +24,9 @@ const {
   resetGuidanceCacheMock,
   setActiveSessionMock,
   clearActiveSessionMock,
+  getIssueAffinityMock,
+  configureAffinityTtlMock,
+  resetAffinityForTestingMock,
   readDispatchStateMock,
   getActiveDispatchMock,
   registerDispatchMock,
@@ -97,6 +100,9 @@ const {
   resetGuidanceCacheMock: vi.fn(),
   setActiveSessionMock: vi.fn(),
   clearActiveSessionMock: vi.fn(),
+  getIssueAffinityMock: vi.fn().mockReturnValue(null),
+  configureAffinityTtlMock: vi.fn(),
+  resetAffinityForTestingMock: vi.fn(),
   readDispatchStateMock: vi.fn().mockResolvedValue({ activeDispatches: {} }),
   getActiveDispatchMock: vi.fn().mockReturnValue(null),
   registerDispatchMock: vi.fn().mockResolvedValue(undefined),
@@ -107,7 +113,7 @@ const {
   createWorktreeMock: vi.fn().mockReturnValue({ path: "/tmp/worktree", branch: "codex/ENG-123", resumed: false }),
   createMultiWorktreeMock: vi.fn().mockReturnValue({ parentPath: "/tmp/multi", worktrees: [] }),
   prepareWorkspaceMock: vi.fn().mockReturnValue({ pulled: true, submodulesInitialized: false, errors: [] }),
-  resolveReposMock: vi.fn().mockReturnValue({ repos: [{ name: "main", path: "/home/claw/ai-workspace" }], source: "config_default" }),
+  resolveReposMock: vi.fn().mockReturnValue({ repos: [{ name: "main", path: "/tmp/test/workspace" }], source: "config_default" }),
   isMultiRepoMock: vi.fn().mockReturnValue(false),
   ensureClawDirMock: vi.fn(),
   writeManifestMock: vi.fn(),
@@ -167,6 +173,9 @@ vi.mock("./guidance.js", () => ({
 vi.mock("./active-session.js", () => ({
   setActiveSession: setActiveSessionMock,
   clearActiveSession: clearActiveSessionMock,
+  getIssueAffinity: getIssueAffinityMock,
+  _configureAffinityTtl: configureAffinityTtlMock,
+  _resetAffinityForTesting: resetAffinityForTestingMock,
 }));
 
 vi.mock("./dispatch-state.js", () => ({
@@ -355,6 +364,9 @@ afterEach(() => {
   isGuidanceEnabledMock.mockReset().mockReturnValue(false);
   setActiveSessionMock.mockReset();
   clearActiveSessionMock.mockReset();
+  getIssueAffinityMock.mockReset().mockReturnValue(null);
+  configureAffinityTtlMock.mockReset();
+  resetAffinityMock.mockReset();
   readDispatchStateMock.mockReset().mockResolvedValue({ activeDispatches: {} });
   getActiveDispatchMock.mockReset().mockReturnValue(null);
   registerDispatchMock.mockReset().mockResolvedValue(undefined);
@@ -363,7 +375,7 @@ afterEach(() => {
   assessTierMock.mockReset().mockResolvedValue({ tier: "medium", model: "anthropic/claude-sonnet-4-6", reasoning: "moderate complexity" });
   createWorktreeMock.mockReset().mockReturnValue({ path: "/tmp/worktree", branch: "codex/ENG-123", resumed: false });
   prepareWorkspaceMock.mockReset().mockReturnValue({ pulled: true, submodulesInitialized: false, errors: [] });
-  resolveReposMock.mockReset().mockReturnValue({ repos: [{ name: "main", path: "/home/claw/ai-workspace" }], source: "config_default" });
+  resolveReposMock.mockReset().mockReturnValue({ repos: [{ name: "main", path: "/tmp/test/workspace" }], source: "config_default" });
   isMultiRepoMock.mockReset().mockReturnValue(false);
   ensureClawDirMock.mockReset();
   writeManifestMock.mockReset();
@@ -2756,3 +2768,2077 @@ describe("Unhandled webhook types", () => {
     expect(body).toBe("Invalid payload");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Coverage push: .catch(() => {}) callbacks in AgentSession.created
+// ---------------------------------------------------------------------------
+
+describe("AgentSession.created .catch callbacks", () => {
+  it("covers initial thought emitActivity .catch when it rejects", async () => {
+    // Make emitActivity reject for "thought" type so .catch(() => {}) runs
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "thought") return Promise.reject(new Error("thought emit fail"));
+      if (content.type === "response") return Promise.resolve(undefined);
+      return Promise.resolve(undefined);
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "created",
+      agentSession: {
+        id: "sess-catch-thought",
+        issue: { id: "issue-catch-thought", identifier: "ENG-CT" },
+      },
+      previousComments: [{ body: "Do this", user: { name: "Dev" } }],
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    // Agent should still run despite thought emission failure
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+
+  it("covers error handler emitActivity .catch when it also rejects", async () => {
+    // Make runAgent throw to enter catch block, then make error emitActivity also reject
+    runAgentMock.mockRejectedValue(new Error("agent crashed hard"));
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "thought") return Promise.resolve(undefined);
+      if (content.type === "error") return Promise.reject(new Error("error emit also fails"));
+      return Promise.resolve(undefined);
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "created",
+      agentSession: {
+        id: "sess-catch-err",
+        issue: { id: "issue-catch-err", identifier: "ENG-CE" },
+      },
+      previousComments: [],
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    // Error should be logged
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("AgentSession handler error"))).toBe(true);
+    // Active session should still be cleared in finally
+    expect(clearActiveSessionMock).toHaveBeenCalledWith("issue-catch-err");
+  });
+
+  it("covers isTriaged=true tool access lines for started state", async () => {
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-triaged",
+      identifier: "ENG-TRIAGED",
+      title: "Triaged Issue",
+      description: "Already triaged",
+      state: { name: "In Progress", type: "started" },
+      assignee: { name: "Dev" },
+      team: { id: "team-triaged" },
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "created",
+      agentSession: {
+        id: "sess-triaged",
+        issue: { id: "issue-triaged", identifier: "ENG-TRIAGED" },
+      },
+      previousComments: [{ body: "Fix this bug", user: { name: "PM" } }],
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 100));
+    expect(runAgentMock).toHaveBeenCalled();
+    const agentCall = runAgentMock.mock.calls[0][0];
+    expect(agentCall.message).toContain("Full access");
+  });
+
+  it("covers no avatarUrl fallback when emitActivity fails for response", async () => {
+    // Set profiles with no avatarUrl
+    loadAgentProfilesMock.mockReturnValue({
+      mal: { label: "Mal", mission: "captain", mentionAliases: ["mal"], isDefault: true },
+    });
+    // emitActivity fails for response
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "response") return Promise.reject(new Error("fail"));
+      return Promise.resolve(undefined);
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "created",
+      agentSession: {
+        id: "sess-no-avatar",
+        issue: { id: "issue-no-avatar", identifier: "ENG-NA" },
+      },
+      previousComments: [],
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    // Should fall back to comment without agentOpts (no avatar)
+    expect(mockLinearApiInstance.createComment).toHaveBeenCalled();
+  });
+
+  it("covers getIssueDetails failure in created handler", async () => {
+    mockLinearApiInstance.getIssueDetails.mockRejectedValue(new Error("fetch fail"));
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "created",
+      agentSession: {
+        id: "sess-fetch-fail",
+        issue: { id: "issue-fetch-fail", identifier: "ENG-FF", title: "Original Title", description: "Original desc" },
+      },
+      previousComments: [{ body: "Check this", user: { name: "Dev" } }],
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 100));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("Could not fetch issue details"))).toBe(true);
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Coverage push: .catch callbacks in AgentSession.prompted
+// ---------------------------------------------------------------------------
+
+describe("AgentSession.prompted .catch callbacks and branches", () => {
+  it("covers thought emitActivity .catch when it rejects in prompted", async () => {
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "thought") return Promise.reject(new Error("thought fail"));
+      if (content.type === "response") return Promise.resolve(undefined);
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-p-catch",
+      identifier: "ENG-PC",
+      title: "Prompted Catch",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-pc" },
+      comments: { nodes: [{ user: { name: "User" }, body: "Some context" }] },
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "prompted",
+      agentSession: {
+        id: "sess-p-catch",
+        issue: { id: "issue-p-catch", identifier: "ENG-PC" },
+      },
+      agentActivity: { content: { body: "Follow up please" } },
+      webhookId: "wh-p-catch",
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+
+  it("covers error handler emitActivity .catch in prompted when it rejects", async () => {
+    runAgentMock.mockRejectedValue(new Error("prompted agent crash"));
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "error") return Promise.reject(new Error("error emit fail too"));
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-p-err-catch",
+      identifier: "ENG-PEC",
+      title: "Prompted Error Catch",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-pec" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "prompted",
+      agentSession: {
+        id: "sess-p-err-catch",
+        issue: { id: "issue-p-err-catch", identifier: "ENG-PEC" },
+      },
+      agentActivity: { content: { body: "Try again" } },
+      webhookId: "wh-pec",
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("prompted handler error"))).toBe(true);
+    expect(clearActiveSessionMock).toHaveBeenCalledWith("issue-p-err-catch");
+  });
+
+  it("covers response emitActivity .then/.catch path in prompted (reject path)", async () => {
+    // emitActivity succeeds for thought, rejects for response
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "response") return Promise.reject(new Error("response fail"));
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-p-resp-fail",
+      identifier: "ENG-PRF",
+      title: "Prompted Response Fail",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-prf" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "prompted",
+      agentSession: {
+        id: "sess-p-resp-fail",
+        issue: { id: "issue-p-resp-fail", identifier: "ENG-PRF" },
+      },
+      agentActivity: { content: { body: "What about this?" } },
+      webhookId: "wh-prf",
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    // Should fall back to comment
+    expect(mockLinearApiInstance.createComment).toHaveBeenCalled();
+  });
+
+  it("covers prompted with agent returning success=false", async () => {
+    runAgentMock.mockResolvedValue({ success: false, output: "Prompted failure" });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-p-fail",
+      identifier: "ENG-PFL",
+      title: "Prompted Fail Result",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-pfl" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "prompted",
+      agentSession: {
+        id: "sess-p-fail",
+        issue: { id: "issue-p-fail", identifier: "ENG-PFL" },
+      },
+      agentActivity: { content: { body: "Anything new?" } },
+      webhookId: "wh-pfl",
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    const emitCalls = mockLinearApiInstance.emitActivity.mock.calls;
+    const responseCall = emitCalls.find((c: any[]) => c[1]?.type === "response");
+    if (responseCall) {
+      expect(responseCall[1].body).toContain("Something went wrong");
+    }
+  });
+
+  it("covers getIssueDetails failure in prompted handler", async () => {
+    mockLinearApiInstance.getIssueDetails.mockRejectedValue(new Error("fetch fail"));
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "prompted",
+      agentSession: {
+        id: "sess-p-fetch-fail",
+        issue: { id: "issue-p-fetch-fail", identifier: "ENG-PFF", title: "Title", description: "Desc" },
+      },
+      agentActivity: { content: { body: "Follow up" } },
+      webhookId: "wh-pff",
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("Could not fetch issue details"))).toBe(true);
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+
+  it("covers prompted with no avatarUrl when response emitActivity fails", async () => {
+    loadAgentProfilesMock.mockReturnValue({
+      mal: { label: "Mal", mission: "captain", mentionAliases: ["mal"], isDefault: true },
+    });
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "response") return Promise.reject(new Error("fail"));
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-p-no-av",
+      identifier: "ENG-PNA",
+      title: "No Avatar Prompted",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-pna" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "prompted",
+      agentSession: {
+        id: "sess-p-no-av",
+        issue: { id: "issue-p-no-av", identifier: "ENG-PNA" },
+      },
+      agentActivity: { content: { body: "Hello" } },
+      webhookId: "wh-pna",
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    expect(mockLinearApiInstance.createComment).toHaveBeenCalled();
+  });
+
+  it("covers prompted guidance caching and formatting", async () => {
+    extractGuidanceMock.mockReturnValue({ guidance: "Follow standards", source: "webhook" });
+    isGuidanceEnabledMock.mockReturnValue(true);
+    formatGuidanceAppendixMock.mockReturnValue("\n## Guidance\nFollow standards");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-p-guid",
+      identifier: "ENG-PG",
+      title: "Prompted Guidance",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-pg" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "prompted",
+      agentSession: {
+        id: "sess-p-guid",
+        issue: { id: "issue-p-guid", identifier: "ENG-PG" },
+      },
+      agentActivity: { content: { body: "Continue" } },
+      webhookId: "wh-pg",
+      guidance: "Follow standards",
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    expect(cacheGuidanceForTeamMock).toHaveBeenCalledWith("team-pg", "Follow standards");
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Coverage push: Comment.create .catch callbacks on intent dispatches
+// ---------------------------------------------------------------------------
+
+describe("Comment.create .catch callbacks on fire-and-forget dispatches", () => {
+  it("covers @mention fast path dispatchCommentToAgent .catch", async () => {
+    resolveAgentFromAliasMock.mockReturnValue({ agentId: "kaylee", profile: { label: "Kaylee" } });
+    // Make the whole dispatch fail — runAgent throws
+    runAgentMock.mockRejectedValue(new Error("mention dispatch fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-mention-catch",
+      identifier: "ENG-MC",
+      title: "Mention Catch",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-mc" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-mention-catch",
+        body: "@kaylee do this now",
+        user: { id: "human-mc", name: "Human" },
+        issue: { id: "issue-mention-catch", identifier: "ENG-MC" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    // The .catch on dispatchCommentToAgent should log
+    expect(errorCalls.some((msg: string) =>
+      msg.includes("dispatch error") || msg.includes("dispatchCommentToAgent error")
+    )).toBe(true);
+  });
+
+  it("covers plan_start initiatePlanningSession .catch when it rejects", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "plan_start",
+      reasoning: "Start planning",
+      fromFallback: false,
+    });
+    initiatePlanningSessionMock.mockRejectedValue(new Error("planning init fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-ps-catch",
+      identifier: "ENG-PSC",
+      title: "Plan Start Catch",
+      state: { name: "Backlog" },
+      project: { id: "proj-ps-catch" },
+      team: { id: "team-psc" },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-ps-catch",
+        body: "Start planning",
+        user: { id: "human-psc", name: "Human" },
+        issue: { id: "issue-ps-catch", identifier: "ENG-PSC", project: { id: "proj-ps-catch" } },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 100));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("Planning initiation error"))).toBe(true);
+  });
+
+  it("covers plan_start already-planning handlePlannerTurn .catch when it rejects", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "plan_start",
+      reasoning: "Start planning",
+      fromFallback: false,
+    });
+    isInPlanningModeMock.mockReturnValue(true);
+    getPlanningSessionMock.mockReturnValue({
+      projectId: "proj-hpt-catch",
+      projectName: "HPT Catch",
+      rootIssueId: "root-hpt",
+      status: "interviewing",
+    });
+    handlePlannerTurnMock.mockRejectedValue(new Error("planner turn fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-hpt-catch",
+      identifier: "ENG-HPC",
+      title: "HPT Catch",
+      state: { name: "Backlog" },
+      project: { id: "proj-hpt-catch" },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-hpt-catch",
+        body: "Start again",
+        user: { id: "human-hpc", name: "Human" },
+        issue: { id: "issue-hpt-catch", identifier: "ENG-HPC", project: { id: "proj-hpt-catch" } },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 100));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("Planner turn error"))).toBe(true);
+  });
+
+  it("covers plan_finalize audit runPlanAudit .catch when it rejects", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "plan_finalize",
+      reasoning: "Finalize",
+      fromFallback: false,
+    });
+    isInPlanningModeMock.mockReturnValue(true);
+    getPlanningSessionMock.mockReturnValue({
+      projectId: "proj-aud-catch",
+      projectName: "Audit Catch",
+      rootIssueId: "root-aud-catch",
+      status: "interviewing",
+    });
+    runPlanAuditMock.mockRejectedValue(new Error("audit fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-aud-catch",
+      identifier: "ENG-AC",
+      title: "Audit Catch",
+      state: { name: "Backlog" },
+      project: { id: "proj-aud-catch" },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-aud-catch",
+        body: "Finalize",
+        user: { id: "human-ac", name: "Human" },
+        issue: { id: "issue-aud-catch", identifier: "ENG-AC", project: { id: "proj-aud-catch" } },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 100));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("Plan audit error"))).toBe(true);
+  });
+
+  it("covers plan_continue handlePlannerTurn .catch when it rejects", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "plan_continue",
+      reasoning: "Continue",
+      fromFallback: false,
+    });
+    isInPlanningModeMock.mockReturnValue(true);
+    getPlanningSessionMock.mockReturnValue({
+      projectId: "proj-cont-catch",
+      projectName: "Continue Catch",
+      rootIssueId: "root-cont-catch",
+      status: "interviewing",
+    });
+    handlePlannerTurnMock.mockRejectedValue(new Error("planner continue fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-cont-catch",
+      identifier: "ENG-CC",
+      title: "Continue Catch",
+      state: { name: "Backlog" },
+      project: { id: "proj-cont-catch" },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-cont-catch",
+        body: "Add more",
+        user: { id: "human-cc", name: "Human" },
+        issue: { id: "issue-cont-catch", identifier: "ENG-CC", project: { id: "proj-cont-catch" } },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 100));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("Planner turn error"))).toBe(true);
+  });
+
+  it("covers plan_continue dispatchCommentToAgent .catch when not planning", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "plan_continue",
+      reasoning: "Continue",
+      fromFallback: false,
+    });
+    runAgentMock.mockRejectedValue(new Error("dispatch fail in plan_continue"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-cont-noplan-catch",
+      identifier: "ENG-CNC",
+      title: "Continue No Plan Catch",
+      state: { name: "Backlog", type: "backlog" },
+      project: null,
+      team: { id: "team-cnc" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-cont-noplan-catch",
+        body: "Continue",
+        user: { id: "human-cnc", name: "Human" },
+        issue: { id: "issue-cont-noplan-catch", identifier: "ENG-CNC" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) =>
+      msg.includes("Comment dispatch error") || msg.includes("dispatchCommentToAgent error")
+    )).toBe(true);
+  });
+
+  it("covers ask_agent dispatchCommentToAgent .catch", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "ask_agent",
+      agentId: "kaylee",
+      reasoning: "Ask",
+      fromFallback: false,
+    });
+    runAgentMock.mockRejectedValue(new Error("ask agent fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-aa-catch",
+      identifier: "ENG-AAC",
+      title: "Ask Agent Catch",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-aac" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-aa-catch",
+        body: "Ask kaylee",
+        user: { id: "human-aac", name: "Human" },
+        issue: { id: "issue-aa-catch", identifier: "ENG-AAC" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) =>
+      msg.includes("Comment dispatch error") || msg.includes("dispatchCommentToAgent error")
+    )).toBe(true);
+  });
+
+  it("covers request_work/question dispatchCommentToAgent .catch", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "request_work",
+      reasoning: "Work",
+      fromFallback: false,
+    });
+    runAgentMock.mockRejectedValue(new Error("request work fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-rw-catch",
+      identifier: "ENG-RWC",
+      title: "Request Work Catch",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-rwc" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-rw-catch",
+        body: "Do work",
+        user: { id: "human-rwc", name: "Human" },
+        issue: { id: "issue-rw-catch", identifier: "ENG-RWC" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) =>
+      msg.includes("Comment dispatch error") || msg.includes("dispatchCommentToAgent error")
+    )).toBe(true);
+  });
+
+  it("covers close_issue handleCloseIssue .catch", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "Close",
+      fromFallback: false,
+    });
+    runAgentMock.mockRejectedValue(new Error("close issue fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-ci-catch",
+      identifier: "ENG-CIC",
+      title: "Close Catch",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-cic" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-ci-catch",
+        body: "Close it",
+        user: { id: "human-cic", name: "Human" },
+        issue: { id: "issue-ci-catch", identifier: "ENG-CIC" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) =>
+      msg.includes("Close issue error") || msg.includes("handleCloseIssue error")
+    )).toBe(true);
+  });
+
+  it("covers getViewerId .catch path when it fails", async () => {
+    mockLinearApiInstance.getViewerId.mockRejectedValue(new Error("viewer fail"));
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-viewer-fail",
+        body: "Hello",
+        user: { id: "human-vf", name: "Human" },
+        issue: { id: "issue-viewer-fail", identifier: "ENG-VF" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    // Should proceed to intent classification despite getViewerId failure
+    expect(classifyIntentMock).toHaveBeenCalled();
+  });
+
+  it("covers getIssueDetails failure in Comment.create intent classification", async () => {
+    mockLinearApiInstance.getIssueDetails.mockRejectedValue(new Error("fetch details fail"));
+    classifyIntentMock.mockResolvedValue({
+      intent: "general",
+      reasoning: "Just a general comment",
+      fromFallback: false,
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-details-fail",
+        body: "Just a note",
+        user: { id: "human-df", name: "Human" },
+        issue: { id: "issue-details-fail", identifier: "ENG-DFL" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("Could not fetch issue details"))).toBe(true);
+  });
+
+  it("covers readPlanningState failure in Comment.create", async () => {
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-plan-fail",
+      identifier: "ENG-PLF",
+      title: "Planning Fail",
+      state: { name: "Backlog" },
+      project: { id: "proj-plan-fail" },
+      team: { id: "team-plf" },
+    });
+    readPlanningStateMock.mockRejectedValue(new Error("planning state read fail"));
+    classifyIntentMock.mockResolvedValue({
+      intent: "general",
+      reasoning: "Just general",
+      fromFallback: false,
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-plan-fail",
+        body: "Some comment",
+        user: { id: "human-plf", name: "Human" },
+        issue: { id: "issue-plan-fail", identifier: "ENG-PLF", project: { id: "proj-plan-fail" } },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    // Should proceed despite planning state read failure
+    expect(classifyIntentMock).toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Coverage push: dispatchCommentToAgent internal .catch callbacks
+// ---------------------------------------------------------------------------
+
+describe("dispatchCommentToAgent internal .catch callbacks", () => {
+  it("covers thought emitActivity .catch in dispatchCommentToAgent", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "request_work",
+      reasoning: "Work request",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "thought") return Promise.reject(new Error("thought fail"));
+      if (content.type === "response") return Promise.resolve(undefined);
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-dca-thought",
+      identifier: "ENG-DCT",
+      title: "DCA Thought",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-dct" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-dca-thought",
+        body: "Do this work",
+        user: { id: "human-dct", name: "Human" },
+        issue: { id: "issue-dca-thought", identifier: "ENG-DCT" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+
+  it("covers error emitActivity .catch in dispatchCommentToAgent", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "request_work",
+      reasoning: "Work request",
+      fromFallback: false,
+    });
+    runAgentMock.mockRejectedValue(new Error("agent exploded in dispatch"));
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "error") return Promise.reject(new Error("error emit also fails"));
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-dca-err",
+      identifier: "ENG-DCE",
+      title: "DCA Error",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-dce" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-dca-err",
+        body: "Do work",
+        user: { id: "human-dce", name: "Human" },
+        issue: { id: "issue-dca-err", identifier: "ENG-DCE" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("dispatchCommentToAgent error"))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Coverage push: handleCloseIssue .catch callbacks
+// ---------------------------------------------------------------------------
+
+describe("handleCloseIssue .catch callbacks", () => {
+  it("covers thought emitActivity .catch in handleCloseIssue", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "Close it",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "thought") return Promise.reject(new Error("thought fail close"));
+      if (content.type === "response") return Promise.resolve(undefined);
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-close-thought",
+      identifier: "ENG-CLT",
+      title: "Close Thought Catch",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-clt" },
+      comments: { nodes: [] },
+      creator: { name: "Creator" },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-close-thought",
+        body: "Close this issue",
+        user: { id: "human-clt", name: "Human" },
+        issue: { id: "issue-close-thought", identifier: "ENG-CLT" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+
+  it("covers response emitActivity .then/.catch in handleCloseIssue", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "Close",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "response") return Promise.reject(new Error("response fail close"));
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-close-resp",
+      identifier: "ENG-CLR",
+      title: "Close Resp Catch",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-clr" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-close-resp",
+        body: "Close now",
+        user: { id: "human-clr", name: "Human" },
+        issue: { id: "issue-close-resp", identifier: "ENG-CLR" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    // Should fall back to comment
+    expect(mockLinearApiInstance.createComment).toHaveBeenCalled();
+  });
+
+  it("covers error emitActivity .catch in handleCloseIssue", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "Close",
+      fromFallback: false,
+    });
+    runAgentMock.mockRejectedValue(new Error("close agent crash"));
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "error") return Promise.reject(new Error("error emit fail close"));
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-close-err-catch",
+      identifier: "ENG-CLEC",
+      title: "Close Error Catch",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-clec" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-close-err-catch",
+        body: "Close",
+        user: { id: "human-clec", name: "Human" },
+        issue: { id: "issue-close-err-catch", identifier: "ENG-CLEC" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("handleCloseIssue error"))).toBe(true);
+  });
+
+  it("covers handleCloseIssue with no session available", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "Close",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.createSessionOnIssue.mockResolvedValue({ sessionId: null });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-close-nosess",
+      identifier: "ENG-CLNS",
+      title: "Close No Sess",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-clns" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-close-nosess",
+        body: "Close this",
+        user: { id: "human-clns", name: "Human" },
+        issue: { id: "issue-close-nosess", identifier: "ENG-CLNS" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    expect(mockLinearApiInstance.createComment).toHaveBeenCalled();
+  });
+
+  it("covers handleCloseIssue with no team (no completed state lookup)", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "Close",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-close-noteam",
+      identifier: "ENG-CLNT",
+      title: "Close No Team",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-close-noteam",
+        body: "Close this",
+        user: { id: "human-clnt", name: "Human" },
+        issue: { id: "issue-close-noteam", identifier: "ENG-CLNT" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("No completed state found"))).toBe(true);
+  });
+
+  it("covers handleCloseIssue getTeamStates failure", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "Close",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.getTeamStates.mockRejectedValue(new Error("states fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-close-states-fail",
+      identifier: "ENG-CLSF",
+      title: "Close States Fail",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-clsf" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-close-states-fail",
+        body: "Close",
+        user: { id: "human-clsf", name: "Human" },
+        issue: { id: "issue-close-states-fail", identifier: "ENG-CLSF" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("Could not fetch team states"))).toBe(true);
+  });
+
+  it("covers handleCloseIssue updateIssue failure for state transition", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "Close",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.updateIssue.mockRejectedValue(new Error("update fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-close-update-fail",
+      identifier: "ENG-CLUF",
+      title: "Close Update Fail",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-cluf" },
+      comments: { nodes: [] },
+    });
+    mockLinearApiInstance.getTeamStates.mockResolvedValue([
+      { id: "st-done", name: "Done", type: "completed" },
+    ]);
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-close-update-fail",
+        body: "Close",
+        user: { id: "human-cluf", name: "Human" },
+        issue: { id: "issue-close-update-fail", identifier: "ENG-CLUF" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("Failed to transition issue"))).toBe(true);
+  });
+
+  it("covers handleCloseIssue with no avatarUrl and no session", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "Close",
+      fromFallback: false,
+    });
+    loadAgentProfilesMock.mockReturnValue({
+      mal: { label: "Mal", mission: "captain", mentionAliases: ["mal"], isDefault: true },
+    });
+    mockLinearApiInstance.createSessionOnIssue.mockResolvedValue({ sessionId: null });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-close-no-av",
+      identifier: "ENG-CLNAV",
+      title: "Close No Avatar",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-clnav" },
+      comments: { nodes: [] },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-close-no-av",
+        body: "Close",
+        user: { id: "human-clnav", name: "Human" },
+        issue: { id: "issue-close-no-av", identifier: "ENG-CLNAV" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    expect(mockLinearApiInstance.createComment).toHaveBeenCalled();
+  });
+
+  it("covers handleCloseIssue getIssueDetails failure", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "close_issue",
+      reasoning: "Close",
+      fromFallback: false,
+    });
+    let callCount = 0;
+    mockLinearApiInstance.getIssueDetails.mockImplementation(() => {
+      callCount++;
+      if (callCount === 1) {
+        return Promise.resolve({
+          id: "issue-close-details-fail",
+          identifier: "ENG-CLDF",
+          title: "Close Details Fail",
+          state: { name: "In Progress", type: "started" },
+          team: { id: "team-cldf" },
+          comments: { nodes: [] },
+        });
+      }
+      return Promise.reject(new Error("second fetch fail"));
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-close-details-fail",
+        body: "Close this",
+        user: { id: "human-cldf", name: "Human" },
+        issue: { id: "issue-close-details-fail", identifier: "ENG-CLDF" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("Could not fetch issue details"))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Coverage push: Issue.create triage .catch callbacks
+// ---------------------------------------------------------------------------
+
+describe("Issue.create triage .catch callbacks", () => {
+  it("covers emitActivity thought .catch during triage", async () => {
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "thought") return Promise.reject(new Error("thought fail triage"));
+      if (content.type === "response") return Promise.resolve(undefined);
+      if (content.type === "action") return Promise.reject(new Error("action fail"));
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-triage-thought",
+      identifier: "ENG-TT",
+      title: "Triage Thought",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-1", issueEstimationType: "fibonacci" },
+      labels: { nodes: [] },
+      creatorId: "creator-1",
+      creator: { name: "Dev" },
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    runAgentMock.mockResolvedValue({
+      success: true,
+      output: '```json\n{"estimate": 3, "labelIds": [], "priority": 2, "assessment": "Medium"}\n```\nAssessment here.',
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "create",
+      data: { id: "issue-triage-thought", identifier: "ENG-TT", title: "Triage Thought", creatorId: "creator-1" },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 200));
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+
+  it("covers emitActivity response .then/.catch during triage", async () => {
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "response") return Promise.reject(new Error("response fail triage"));
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-triage-resp",
+      identifier: "ENG-TR2",
+      title: "Triage Resp",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-1" },
+      labels: { nodes: [] },
+      creatorId: "creator-1",
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    runAgentMock.mockResolvedValue({
+      success: true,
+      output: "Simple triage without JSON block",
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "create",
+      data: { id: "issue-triage-resp", identifier: "ENG-TR2", title: "Triage Resp", creatorId: "creator-1" },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 200));
+    expect(mockLinearApiInstance.createComment).toHaveBeenCalled();
+  });
+
+  it("covers error emitActivity .catch during triage exception", async () => {
+    runAgentMock.mockRejectedValue(new Error("triage agent crash"));
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "error") return Promise.reject(new Error("error emit fail triage"));
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-triage-err-catch",
+      identifier: "ENG-TEC",
+      title: "Triage Error Catch",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-1" },
+      labels: { nodes: [] },
+      creatorId: "creator-1",
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "create",
+      data: { id: "issue-triage-err-catch", identifier: "ENG-TEC", title: "Triage Error Catch", creatorId: "creator-1" },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 200));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("triage error"))).toBe(true);
+  });
+
+  it("covers triage with JSON containing priority, labels, and estimate", async () => {
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-triage-json",
+      identifier: "ENG-TJ",
+      title: "Triage JSON",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-1", issueEstimationType: "fibonacci" },
+      labels: { nodes: [{ id: "existing-label", name: "existing" }] },
+      creatorId: "creator-1",
+      creator: { name: "Dev", email: "dev@test.com" },
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getTeamLabels.mockResolvedValue([
+      { id: "label-bug", name: "bug" },
+      { id: "label-feature", name: "feature" },
+    ]);
+    runAgentMock.mockResolvedValue({
+      success: true,
+      output: '```json\n{"estimate": 5, "labelIds": ["label-bug"], "priority": 1, "assessment": "High priority bug"}\n```\n\nThis is a high priority bug.',
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "create",
+      data: { id: "issue-triage-json", identifier: "ENG-TJ", title: "Triage JSON", creatorId: "creator-1" },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 200));
+    expect(mockLinearApiInstance.updateIssue).toHaveBeenCalled();
+    const updateCall = mockLinearApiInstance.updateIssue.mock.calls[0];
+    expect(updateCall[1]).toEqual(expect.objectContaining({
+      estimate: 5,
+      priority: 1,
+      labelIds: expect.arrayContaining(["existing-label", "label-bug"]),
+    }));
+  });
+
+  it("covers triage JSON parse failure", async () => {
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-triage-bad-json",
+      identifier: "ENG-TBJ",
+      title: "Triage Bad JSON",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-1" },
+      labels: { nodes: [] },
+      creatorId: "creator-1",
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    runAgentMock.mockResolvedValue({
+      success: true,
+      output: '```json\n{invalid json here}\n```\n\nAssessment text.',
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "create",
+      data: { id: "issue-triage-bad-json", identifier: "ENG-TBJ", title: "Triage Bad JSON", creatorId: "creator-1" },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 200));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("Could not parse triage JSON"))).toBe(true);
+  });
+
+  it("covers triage with no session and no avatar", async () => {
+    loadAgentProfilesMock.mockReturnValue({
+      mal: { label: "Mal", mission: "captain", mentionAliases: ["mal"], isDefault: true },
+    });
+    mockLinearApiInstance.createSessionOnIssue.mockResolvedValue({ sessionId: null });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-triage-no-av",
+      identifier: "ENG-TNA",
+      title: "Triage No Avatar",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-1" },
+      labels: { nodes: [] },
+      creatorId: "creator-1",
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    runAgentMock.mockResolvedValue({
+      success: true,
+      output: "Simple triage text",
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "create",
+      data: { id: "issue-triage-no-av", identifier: "ENG-TNA", title: "Triage No Avatar", creatorId: "creator-1" },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 200));
+    expect(mockLinearApiInstance.createComment).toHaveBeenCalled();
+  });
+
+  it("covers triage getIssueDetails failure", async () => {
+    mockLinearApiInstance.getIssueDetails.mockRejectedValue(new Error("triage fetch fail"));
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    runAgentMock.mockResolvedValue({
+      success: true,
+      output: "Triage without details",
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "create",
+      data: { id: "issue-triage-fetch-fail", identifier: "ENG-TFF", title: "Triage Fetch Fail", creatorId: "creator-1" },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 200));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("Could not fetch issue details for triage"))).toBe(true);
+  });
+
+  it("covers triage emitActivity action .catch for applied triage", async () => {
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "action" && content.action === "Applied triage") {
+        return Promise.reject(new Error("action emit fail"));
+      }
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-triage-action",
+      identifier: "ENG-TA",
+      title: "Triage Action",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-1", issueEstimationType: "fibonacci" },
+      labels: { nodes: [] },
+      creatorId: "creator-1",
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    runAgentMock.mockResolvedValue({
+      success: true,
+      output: '```json\n{"estimate": 2, "labelIds": [], "priority": 3, "assessment": "Small"}\n```\nSmall task.',
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "create",
+      data: { id: "issue-triage-action", identifier: "ENG-TA", title: "Triage Action", creatorId: "creator-1" },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 200));
+    expect(mockLinearApiInstance.updateIssue).toHaveBeenCalled();
+  });
+
+  it("covers triage planning state check failure", async () => {
+    readPlanningStateMock.mockRejectedValue(new Error("planning check fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-triage-plan-fail",
+      identifier: "ENG-TPF",
+      title: "Triage Plan Fail",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-1" },
+      labels: { nodes: [] },
+      project: { id: "proj-triage-fail" },
+      creatorId: "creator-1",
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    runAgentMock.mockResolvedValue({ success: true, output: "Triage result" });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "create",
+      data: { id: "issue-triage-plan-fail", identifier: "ENG-TPF", title: "Triage Plan Fail", creatorId: "creator-1" },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 200));
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+
+  it("covers triage guidance cache lookup", async () => {
+    getCachedGuidanceForTeamMock.mockReturnValue("Cached guidance text");
+    isGuidanceEnabledMock.mockReturnValue(true);
+    formatGuidanceAppendixMock.mockReturnValue("\n## Guidance\nCached guidance text");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-triage-guid",
+      identifier: "ENG-TG",
+      title: "Triage Guidance",
+      description: "desc",
+      state: { name: "Backlog", type: "backlog" },
+      team: { id: "team-tg" },
+      labels: { nodes: [] },
+      creatorId: "creator-1",
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    runAgentMock.mockResolvedValue({ success: true, output: "Triage with guidance" });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "create",
+      data: { id: "issue-triage-guid", identifier: "ENG-TG", title: "Triage Guidance", creatorId: "creator-1" },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 200));
+    expect(getCachedGuidanceForTeamMock).toHaveBeenCalledWith("team-tg");
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Coverage push: handleDispatch multi-repo, .catch, .finally
+// ---------------------------------------------------------------------------
+
+describe("handleDispatch multi-repo and .catch/.finally", () => {
+  it("covers multi-repo worktree creation path", async () => {
+    isMultiRepoMock.mockReturnValue(true);
+    createMultiWorktreeMock.mockReturnValue({
+      parentPath: "/tmp/multi-wt",
+      worktrees: [
+        { repoName: "api", path: "/tmp/multi-wt/api", branch: "codex/ENG-MULTI", resumed: false },
+        { repoName: "spa", path: "/tmp/multi-wt/spa", branch: "codex/ENG-MULTI", resumed: true },
+      ],
+    });
+    resolveReposMock.mockReturnValue({
+      repos: [
+        { name: "api", path: "/tmp/test/api" },
+        { name: "spa", path: "/tmp/test/spa" },
+      ],
+      source: "issue_markers",
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-multi",
+      identifier: "ENG-MULTI",
+      title: "Multi Repo",
+      description: "Multi repo dispatch",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-multi" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: null,
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-multi",
+        identifier: "ENG-MULTI",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 500));
+    expect(createMultiWorktreeMock).toHaveBeenCalled();
+    expect(prepareWorkspaceMock).toHaveBeenCalledTimes(2);
+    expect(registerDispatchMock).toHaveBeenCalled();
+  });
+
+  it("covers spawnWorker .catch and .finally when worker fails", async () => {
+    spawnWorkerMock.mockRejectedValue(new Error("pipeline v2 crash"));
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-spawn-fail",
+      identifier: "ENG-SF",
+      title: "Spawn Fail",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-sf" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: null,
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-spawn-fail",
+        identifier: "ENG-SF",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 500));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("pipeline v2 failed"))).toBe(true);
+    expect(updateDispatchStatusMock).toHaveBeenCalledWith("ENG-SF", "failed", undefined);
+    expect(clearActiveSessionMock).toHaveBeenCalledWith("issue-spawn-fail");
+  });
+
+  it("covers dispatch emitActivity thought .catch on session", async () => {
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "thought") return Promise.reject(new Error("thought fail dispatch"));
+      return Promise.resolve(undefined);
+    });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-disp-thought",
+      identifier: "ENG-DT",
+      title: "Dispatch Thought",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-dt" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: null,
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-disp-thought",
+        identifier: "ENG-DT",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 500));
+    expect(spawnWorkerMock).toHaveBeenCalled();
+  });
+
+  it("covers dispatch tier label application with matching label", async () => {
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-tier-label",
+      identifier: "ENG-TL",
+      title: "Tier Label",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-tl" },
+      labels: { nodes: [{ id: "existing-l1", name: "feature" }] },
+      comments: { nodes: [] },
+      project: null,
+    });
+    mockLinearApiInstance.getTeamLabels.mockResolvedValue([
+      { id: "tier-label-id", name: "developer:medium" },
+    ]);
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-tier-label",
+        identifier: "ENG-TL",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 500));
+    const updateCalls = mockLinearApiInstance.updateIssue.mock.calls;
+    const tierLabelCall = updateCalls.find((c: any[]) =>
+      c[1]?.labelIds?.includes("tier-label-id")
+    );
+    expect(tierLabelCall).toBeDefined();
+  });
+
+  it("covers dispatch tier label failure (best effort)", async () => {
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-tier-fail",
+      identifier: "ENG-TLFAIL",
+      title: "Tier Fail",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-tlfail" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: null,
+    });
+    mockLinearApiInstance.getTeamLabels.mockRejectedValue(new Error("team labels fail"));
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-tier-fail",
+        identifier: "ENG-TLFAIL",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 500));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("could not apply tier label"))).toBe(true);
+  });
+
+  it("covers handleDispatch planning mode check preventing dispatch", async () => {
+    isInPlanningModeMock.mockReturnValue(true);
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-plan-block",
+      identifier: "ENG-PB",
+      title: "Plan Block",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-pb" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: { id: "proj-plan-block" },
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-plan-block",
+        identifier: "ENG-PB",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const infoCalls = (result.api.logger.info as any).mock.calls.map((c: any[]) => c[0]);
+    expect(infoCalls.some((msg: string) => msg.includes("planning-mode project"))).toBe(true);
+    expect(mockLinearApiInstance.createComment).toHaveBeenCalled();
+  });
+
+  it("covers handleDispatch planning mode check failure", async () => {
+    readPlanningStateMock.mockRejectedValue(new Error("plan state fail"));
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-plan-check-fail",
+      identifier: "ENG-PCF",
+      title: "Plan Check Fail",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-pcf" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: { id: "proj-plan-check-fail" },
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-plan-check-fail",
+        identifier: "ENG-PCF",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 500));
+    expect(assessTierMock).toHaveBeenCalled();
+  });
+
+  it("covers handleDispatch .claw dir init failure", async () => {
+    ensureClawDirMock.mockImplementation(() => { throw new Error("claw dir fail"); });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-claw-fail",
+      identifier: "ENG-CDF",
+      title: "Claw Dir Fail",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-cdf" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: null,
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-claw-fail",
+        identifier: "ENG-CDF",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 500));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes(".claw/ init failed"))).toBe(true);
+    expect(registerDispatchMock).toHaveBeenCalled();
+  });
+
+  it("covers handleDispatch session creation failure", async () => {
+    mockLinearApiInstance.createSessionOnIssue.mockRejectedValue(new Error("session create fail"));
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-sess-fail",
+      identifier: "ENG-SSF",
+      title: "Sess Fail",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-ssf" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: null,
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-sess-fail",
+        identifier: "ENG-SSF",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 500));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("could not create agent session"))).toBe(true);
+    expect(registerDispatchMock).toHaveBeenCalled();
+  });
+
+  it("covers handleDispatch workspace prep errors", async () => {
+    prepareWorkspaceMock.mockReturnValue({ pulled: false, submodulesInitialized: false, errors: ["git pull failed"] });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-prep-err",
+      identifier: "ENG-PE",
+      title: "Prep Error",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-pe" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: null,
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-prep-err",
+        identifier: "ENG-PE",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 500));
+    const warnCalls = (result.api.logger.warn as any).mock.calls.map((c: any[]) => c[0]);
+    expect(warnCalls.some((msg: string) => msg.includes("workspace prep had errors"))).toBe(true);
+  });
+
+  it("covers spawnWorker .catch with writeDispatchMemory failure (best effort)", async () => {
+    spawnWorkerMock.mockRejectedValue(new Error("pipeline crash"));
+    resolveOrchestratorWorkspaceMock.mockImplementation(() => { throw new Error("workspace resolve fail"); });
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-mem-fail",
+      identifier: "ENG-MF2",
+      title: "Memory Fail",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-mf2" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: null,
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-mem-fail",
+        identifier: "ENG-MF2",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 500));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("pipeline v2 failed"))).toBe(true);
+    expect(clearActiveSessionMock).toHaveBeenCalledWith("issue-mem-fail");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Coverage push: plan_finalize approval error path
+// ---------------------------------------------------------------------------
+
+describe("plan_finalize approval error paths", () => {
+  it("covers plan_finalize approval error in async block", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "plan_finalize",
+      reasoning: "Finalize",
+      fromFallback: false,
+    });
+    isInPlanningModeMock.mockReturnValue(true);
+    getPlanningSessionMock.mockReturnValue({
+      projectId: "proj-fin-err",
+      projectName: "Finalize Error",
+      rootIssueId: "root-fin-err",
+      status: "plan_review",
+    });
+    endPlanningSessionMock.mockRejectedValue(new Error("end session fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-fin-err",
+      identifier: "ENG-FE",
+      title: "Finalize Error",
+      state: { name: "Backlog" },
+      project: { id: "proj-fin-err" },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-fin-err",
+        body: "Approve the plan",
+        user: { id: "human-fe", name: "Human" },
+        issue: { id: "issue-fin-err", identifier: "ENG-FE", project: { id: "proj-fin-err" } },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("Plan approval error"))).toBe(true);
+  });
+
+  it("covers plan_abandon error in async block", async () => {
+    classifyIntentMock.mockResolvedValue({
+      intent: "plan_abandon",
+      reasoning: "Abandon",
+      fromFallback: false,
+    });
+    isInPlanningModeMock.mockReturnValue(true);
+    getPlanningSessionMock.mockReturnValue({
+      projectId: "proj-ab-err",
+      projectName: "Abandon Error",
+      rootIssueId: "root-ab-err",
+      status: "interviewing",
+    });
+    endPlanningSessionMock.mockRejectedValue(new Error("abandon fail"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-ab-err",
+      identifier: "ENG-ABE",
+      title: "Abandon Error",
+      state: { name: "Backlog" },
+      project: { id: "proj-ab-err" },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-ab-err",
+        body: "Abandon plan",
+        user: { id: "human-abe", name: "Human" },
+        issue: { id: "issue-ab-err", identifier: "ENG-ABE", project: { id: "proj-ab-err" } },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("Plan abandon error"))).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Coverage push: postAgentComment without opts (no agentOpts branch)
+// ---------------------------------------------------------------------------
+
+describe("postAgentComment without agentOpts", () => {
+  it("covers postAgentComment code path when no agentOpts is passed", async () => {
+    loadAgentProfilesMock.mockReturnValue({
+      mal: { label: "Mal", mission: "captain", mentionAliases: ["mal"], isDefault: true },
+    });
+    mockLinearApiInstance.emitActivity.mockImplementation((_sid: string, content: any) => {
+      if (content.type === "response") return Promise.reject(new Error("fail"));
+      return Promise.resolve(undefined);
+    });
+
+    const result = await postWebhook({
+      type: "AgentSessionEvent",
+      action: "created",
+      agentSession: {
+        id: "sess-no-opts",
+        issue: { id: "issue-no-opts", identifier: "ENG-NO" },
+      },
+      previousComments: [{ body: "Test", user: { name: "Dev" } }],
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 150));
+    expect(mockLinearApiInstance.createComment).toHaveBeenCalled();
+    const commentCall = mockLinearApiInstance.createComment.mock.calls[0];
+    expect(commentCall[1]).toContain("**[Mal]**");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Coverage push: Comment.create guidance-enabled branch
+// ---------------------------------------------------------------------------
+
+describe("Comment.create guidance paths", () => {
+  it("covers guidance enabled path in dispatchCommentToAgent", async () => {
+    isGuidanceEnabledMock.mockReturnValue(true);
+    getCachedGuidanceForTeamMock.mockReturnValue("Cached comment guidance");
+    formatGuidanceAppendixMock.mockReturnValue("\n## Guidance\nCached comment guidance");
+    classifyIntentMock.mockResolvedValue({
+      intent: "request_work",
+      reasoning: "Work",
+      fromFallback: false,
+    });
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-guid-comment",
+      identifier: "ENG-GC",
+      title: "Guidance Comment",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-gc" },
+      comments: { nodes: [{ user: { name: "Dev" }, body: "context" }] },
+      creator: { name: "Creator", email: "c@test.com" },
+    });
+
+    const result = await postWebhook({
+      type: "Comment",
+      action: "create",
+      data: {
+        id: "comment-guid",
+        body: "Do the work",
+        user: { id: "human-gc", name: "Human" },
+        issue: { id: "issue-guid-comment", identifier: "ENG-GC" },
+      },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    expect(getCachedGuidanceForTeamMock).toHaveBeenCalledWith("team-gc");
+    expect(runAgentMock).toHaveBeenCalled();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Coverage push: handleDispatch .catch wrapper (L999)
+// ---------------------------------------------------------------------------
+
+describe("handleDispatch error via Issue.update .catch wrapper", () => {
+  it("covers handleDispatch .catch wrapper when whole dispatch throws", async () => {
+    mockLinearApiInstance.getViewerId.mockResolvedValue("viewer-1");
+    assessTierMock.mockRejectedValue(new Error("tier assessment crash"));
+    mockLinearApiInstance.getIssueDetails.mockResolvedValue({
+      id: "issue-hdl-catch",
+      identifier: "ENG-HC",
+      title: "Handle Catch",
+      description: "desc",
+      state: { name: "In Progress", type: "started" },
+      team: { id: "team-hc" },
+      labels: { nodes: [] },
+      comments: { nodes: [] },
+      project: null,
+    });
+
+    const result = await postWebhook({
+      type: "Issue",
+      action: "update",
+      data: {
+        id: "issue-hdl-catch",
+        identifier: "ENG-HC",
+        assigneeId: "viewer-1",
+      },
+      updatedFrom: { assigneeId: null },
+    });
+
+    expect(result.status).toBe(200);
+    await new Promise((r) => setTimeout(r, 300));
+    const errorCalls = (result.api.logger.error as any).mock.calls.map((c: any[]) => c[0]);
+    expect(errorCalls.some((msg: string) => msg.includes("Dispatch pipeline error"))).toBe(true);
+  });
+});