@calltelemetry/openclaw-linear 0.7.0 → 0.8.0

package/src/pipeline/tier-assess.test.ts

@@ -0,0 +1,264 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { TIER_MODELS, assessTier, type IssueContext } from "./tier-assess.js";
+
+// ---------------------------------------------------------------------------
+// Mock runAgent
+// ---------------------------------------------------------------------------
+
+const mockRunAgent = vi.fn();
+
+vi.mock("../agent/agent.js", () => ({
+  runAgent: (...args: unknown[]) => mockRunAgent(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeApi(overrides?: { defaultAgentId?: string }) {
+  return {
+    logger: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    },
+    pluginConfig: {
+      defaultAgentId: overrides?.defaultAgentId,
+    },
+  } as any;
+}
+
+function makeIssue(overrides?: Partial<IssueContext>): IssueContext {
+  return {
+    identifier: "CT-123",
+    title: "Fix login bug",
+    description: "Users cannot log in when using SSO",
+    labels: ["bug"],
+    commentCount: 2,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("TIER_MODELS", () => {
+  it("maps junior to haiku, medior to sonnet, senior to opus", () => {
+    expect(TIER_MODELS.junior).toBe("anthropic/claude-haiku-4-5");
+    expect(TIER_MODELS.medior).toBe("anthropic/claude-sonnet-4-6");
+    expect(TIER_MODELS.senior).toBe("anthropic/claude-opus-4-6");
+  });
+});
+
+describe("assessTier", () => {
+  beforeEach(() => {
+    mockRunAgent.mockReset();
+  });
+
+  it("returns parsed tier from agent response", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"senior","reasoning":"Multi-service architecture change"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("senior");
+    expect(result.model).toBe(TIER_MODELS.senior);
+    expect(result.reasoning).toBe("Multi-service architecture change");
+    expect(api.logger.info).toHaveBeenCalled();
+  });
+
+  it("falls back to medior when agent fails (success: false) with no parseable JSON", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: false,
+      output: "Agent process exited with code 1",
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("medior");
+    expect(result.model).toBe(TIER_MODELS.medior);
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+    expect(api.logger.warn).toHaveBeenCalled();
+  });
+
+  it("falls back to medior when output has no JSON", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: "I think this is a medium complexity issue because it involves multiple files.",
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("medior");
+    expect(result.model).toBe(TIER_MODELS.medior);
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+  });
+
+  it("falls back to medior when JSON has invalid tier", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"expert","reasoning":"Very hard problem"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("medior");
+    expect(result.model).toBe(TIER_MODELS.medior);
+  });
+
+  it("handles agent throwing an error", async () => {
+    mockRunAgent.mockRejectedValue(new Error("Connection refused"));
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("medior");
+    expect(result.model).toBe(TIER_MODELS.medior);
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+    expect(api.logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining("Tier assessment error for CT-123"),
+    );
+  });
+
+  it("truncates long descriptions to 1500 chars", async () => {
+    const longDescription = "A".repeat(3000);
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"junior","reasoning":"Simple copy change"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    await assessTier(api, makeIssue({ description: longDescription }));
+
+    // Verify the message sent to runAgent has the description truncated
+    const callArgs = mockRunAgent.mock.calls[0][0];
+    const message: string = callArgs.message;
+    // The description in the prompt should be at most 1500 chars of the original
+    // "Description: " prefix + 1500 chars = the truncated form
+    expect(message).toContain("Description: " + "A".repeat(1500));
+    expect(message).not.toContain("A".repeat(1501));
+  });
+
+  it("uses configured agentId when provided", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"junior","reasoning":"Typo fix"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    await assessTier(api, makeIssue(), "kaylee");
+
+    const callArgs = mockRunAgent.mock.calls[0][0];
+    expect(callArgs.agentId).toBe("kaylee");
+  });
+
+  it("parses JSON even when wrapped in markdown fences", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '```json\n{"tier":"junior","reasoning":"Config tweak"}\n```',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("junior");
+    expect(result.model).toBe(TIER_MODELS.junior);
+    expect(result.reasoning).toBe("Config tweak");
+  });
+
+  it("handles null description gracefully", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"junior","reasoning":"Trivial"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue({ description: null }));
+
+    expect(result.tier).toBe("junior");
+  });
+
+  it("handles empty labels and no comments", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"medior","reasoning":"Standard feature"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue({ labels: [], commentCount: undefined }));
+
+    expect(result.tier).toBe("medior");
+  });
+
+  it("falls back to medior on malformed JSON (half JSON)", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"seni',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("medior");
+    expect(result.reasoning).toBe("Assessment failed — defaulting to medior");
+  });
+
+  it("provides default reasoning when missing from response", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"senior"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("senior");
+    expect(result.reasoning).toBe("no reasoning provided");
+  });
+
+  it("extracts JSON from output with success=false but valid JSON", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: false,
+      output: 'Agent exited early but: {"tier":"junior","reasoning":"Simple fix"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    const result = await assessTier(api, makeIssue());
+
+    expect(result.tier).toBe("junior");
+    expect(result.reasoning).toBe("Simple fix");
+  });
+
+  it("defaults agentId from pluginConfig when not passed", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"medior","reasoning":"Normal"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "zoe" });
+    await assessTier(api, makeIssue());
+
+    const callArgs = mockRunAgent.mock.calls[0][0];
+    expect(callArgs.agentId).toBe("zoe");
+  });
+
+  it("uses 30s timeout for assessment", async () => {
+    mockRunAgent.mockResolvedValue({
+      success: true,
+      output: '{"tier":"medior","reasoning":"Normal"}',
+    });
+
+    const api = makeApi({ defaultAgentId: "mal" });
+    await assessTier(api, makeIssue());
+
+    const callArgs = mockRunAgent.mock.calls[0][0];
+    expect(callArgs.timeoutMs).toBe(30_000);
+  });
+});

package/src/pipeline/webhook.ts

@@ -8,10 +8,13 @@ import { setActiveSession, clearActiveSession } from "./active-session.js";
 import { readDispatchState, getActiveDispatch, registerDispatch, updateDispatchStatus, completeDispatch, removeActiveDispatch } from "./dispatch-state.js";
 import { createNotifierFromConfig, type NotifyFn } from "../infra/notify.js";
 import { assessTier } from "./tier-assess.js";
-import { createWorktree, prepareWorkspace } from "../infra/codex-worktree.js";
-import { ensureClawDir, writeManifest } from "./artifacts.js";
+import { createWorktree, createMultiWorktree, prepareWorkspace } from "../infra/codex-worktree.js";
+import { resolveRepos, isMultiRepo } from "../infra/multi-repo.js";
+import { ensureClawDir, writeManifest, writeDispatchMemory, resolveOrchestratorWorkspace } from "./artifacts.js";
 import { readPlanningState, isInPlanningMode, getPlanningSession } from "./planning-state.js";
 import { initiatePlanningSession, handlePlannerTurn } from "./planner.js";
+import { startProjectDispatch } from "./dag-dispatch.js";
+import { emitDiagnostic } from "../infra/observability.js";
 
 // ── Agent profiles (loaded from config, no hardcoded names) ───────
 interface AgentProfile {
@@ -148,6 +151,7 @@ export async function handleLinearWebhook(
   // Debug: log full payload structure for diagnosing webhook types
   const payloadKeys = Object.keys(payload).join(", ");
   api.logger.info(`Linear webhook received: type=${payload.type} action=${payload.action} keys=[${payloadKeys}]`);
+  emitDiagnostic(api, { event: "webhook_received", webhookType: payload.type, webhookAction: payload.action });
 
 
   // ── AppUserNotification — OAuth app webhook for agent mentions/assignments
@@ -259,7 +263,7 @@ export async function handleLinearWebhook(
 
         const responseBody = result.success
           ? result.output
-          : `I encountered an error processing this request. Please try again.`;
+          : `Something went wrong while processing this. The system will retry automatically if possible. If this keeps happening, run \`openclaw openclaw-linear doctor\` to check for issues.`;
 
         // 5. Post branded comment (fallback to prefix)
         const brandingOpts = avatarUrl
@@ -435,7 +439,7 @@ export async function handleLinearWebhook(
 
         const responseBody = result.success
           ? result.output
-          : `I encountered an error processing this request. Please try again.`;
+          : `Something went wrong while processing this. The system will retry automatically if possible. If this keeps happening, run \`openclaw openclaw-linear doctor\` to check for issues.`;
 
         // Post as comment
         const avatarUrl = defaultProfile?.[1]?.avatarUrl ?? profiles[agentId]?.avatarUrl;
@@ -613,7 +617,7 @@ export async function handleLinearWebhook(
 
         const responseBody = result.success
           ? result.output
-          : `I encountered an error processing this request. Please try again.`;
+          : `Something went wrong while processing this. The system will retry automatically if possible. If this keeps happening, run \`openclaw openclaw-linear doctor\` to check for issues.`;
 
         const avatarUrl = defaultProfile?.[1]?.avatarUrl ?? profiles[agentId]?.avatarUrl;
         const brandingOpts = avatarUrl
@@ -666,6 +670,8 @@ export async function handleLinearWebhook(
     const issue = comment?.issue ?? payload.issue;
 
     // ── Planning mode intercept ──────────────────────────────────
+    const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+
     if (issue?.id) {
       const linearApiForPlanning = createLinearApi(api);
       if (linearApiForPlanning) {
@@ -678,7 +684,7 @@ export async function handleLinearWebhook(
             const planState = await readPlanningState(planStatePath);
 
             // Check if this is a plan initiation request
-            const isPlanRequest = /\b(plan|planning)\s+(this\s+)?(project|out)\b/i.test(commentBody);
+            const isPlanRequest = /\b(plan|planning)\s+(this\s+)(project|out)\b/i.test(commentBody) || /\bplan\s+this\s+out\b/i.test(commentBody);
             if (isPlanRequest && !isInPlanningMode(planState, projectId)) {
               api.logger.info(`Planning: initiation requested on ${issue.identifier ?? issue.id}`);
               void initiatePlanningSession(
@@ -692,12 +698,34 @@ export async function handleLinearWebhook(
             // Route to planner if project is in planning mode
             if (isInPlanningMode(planState, projectId)) {
               const session = getPlanningSession(planState, projectId);
-              if (session && comment?.id && !wasRecentlyProcessed(`plan-comment:${comment.id}`)) {
+              if (!session) {
+                api.logger.error(`Planning: project ${projectId} in planning mode but no session found — state may be corrupted`);
+                await linearApiForPlanning.createComment(
+                  issue.id,
+                  `**Planning mode is active** for this project, but the session state appears corrupted.\n\n**To fix:** Say **"abandon planning"** to exit planning mode, then start fresh with **"plan this project"**.`,
+                ).catch(() => {});
+                return true;
+              }
+              if (comment?.id && !wasRecentlyProcessed(`plan-comment:${comment.id}`)) {
                 api.logger.info(`Planning: routing comment to planner for ${session.projectName}`);
                 void handlePlannerTurn(
                   { api, linearApi: linearApiForPlanning, pluginConfig },
                   session,
                   { issueId: issue.id, commentBody, commentorName: commentor },
+                  {
+                    onApproved: (approvedProjectId) => {
+                      const notify = createNotifierFromConfig(pluginConfig, api.runtime, api);
+                      const hookCtx: HookContext = {
+                        api,
+                        linearApi: linearApiForPlanning,
+                        notify,
+                        pluginConfig,
+                        configPath: pluginConfig?.dispatchStatePath as string | undefined,
+                      };
+                      void startProjectDispatch(hookCtx, approvedProjectId)
+                        .catch((err) => api.logger.error(`Project dispatch start error: ${err}`));
+                    },
+                  },
                 ).catch((err) => api.logger.error(`Planner turn error: ${err}`));
               }
               return true;
@@ -856,7 +884,7 @@ export async function handleLinearWebhook(
 
         const responseBody = result.success
           ? result.output
-          : `I encountered an error processing this request. Please try again or check the logs.`;
+          : `Something went wrong while processing this. If this keeps happening, run \`openclaw openclaw-linear doctor\` to check for issues.`;
 
         // 5. Post branded comment (fall back to [Label] prefix if branding fails)
         const brandingOpts = profile?.avatarUrl
@@ -1010,6 +1038,27 @@ export async function handleLinearWebhook(
           api.logger.warn(`Could not fetch issue details for triage: ${err}`);
         }
 
+        // Skip triage for issues in projects that are actively being planned —
+        // the planner creates issues and triage would overwrite its estimates/labels.
+        const triageProjectId = enrichedIssue?.project?.id;
+        if (triageProjectId) {
+          const planStatePath = pluginConfig?.planningStatePath as string | undefined;
+          try {
+            const planState = await readPlanningState(planStatePath);
+            if (isInPlanningMode(planState, triageProjectId)) {
+              api.logger.info(`Issue.create: ${issue.identifier ?? issue.id} belongs to project in planning mode — skipping triage`);
+              return;
+            }
+          } catch { /* proceed with triage if planning state check fails */ }
+        }
+
+        // Skip triage for issues created by our own bot user
+        const viewerId = await linearApi.getViewerId();
+        if (viewerId && issue.creatorId === viewerId) {
+          api.logger.info(`Issue.create: ${issue.identifier ?? issue.id} created by our bot — skipping triage`);
+          return;
+        }
+
         const description = enrichedIssue?.description ?? issue?.description ?? "(no description)";
         const estimationType = enrichedIssue?.team?.issueEstimationType ?? "fibonacci";
         const currentLabels = enrichedIssue?.labels?.nodes ?? [];
@@ -1094,7 +1143,7 @@ export async function handleLinearWebhook(
 
         const responseBody = result.success
           ? result.output
-          : `I encountered an error triaging this issue. Please triage manually.`;
+          : `Something went wrong while triaging this issue. You may need to set the estimate and labels manually.`;
 
         // Parse triage JSON and apply to issue
         let commentBody = responseBody;
@@ -1218,7 +1267,7 @@ async function handleDispatch(
         api.logger.info(`dispatch: ${identifier} is in planning-mode project — skipping`);
         await linearApi.createComment(
           issue.id,
-          "This project is in planning mode. Finalize the plan before dispatching implementation.",
+          `**Can't dispatch yet** — this project is in planning mode.\n\n**To continue:** Comment on the planning issue with your requirements, then say **"finalize plan"** when ready.\n\n**To cancel planning:** Comment **"abandon"** on the planning issue.`,
         );
         return;
       }
@@ -1241,7 +1290,7 @@ async function handleDispatch(
       api.logger.info(`dispatch: ${identifier} actively running (status: ${existing.status}, age: ${Math.round(ageMs / 1000)}s) — skipping`);
       await linearApi.createComment(
         issue.id,
-        `Already running as **${existing.tier}** (status: ${existing.status}, started ${Math.round(ageMs / 60_000)}m ago). Worktree: \`${existing.worktreePath}\``,
+        `**Already running** as **${existing.tier}** — status: **${existing.status}**, started ${Math.round(ageMs / 60_000)}m ago.\n\nWorktree: \`${existing.worktreePath}\`\n\n**Options:**\n- Check progress: \`/dispatch status ${identifier}\`\n- Force restart: \`/dispatch retry ${identifier}\` (only works when stuck)\n- Escalate: \`/dispatch escalate ${identifier} "reason"\``,
       );
       return;
     }
@@ -1273,6 +1322,9 @@ async function handleDispatch(
   const labels = enrichedIssue.labels?.nodes?.map((l: any) => l.name) ?? [];
   const commentCount = enrichedIssue.comments?.nodes?.length ?? 0;
 
+  // Resolve repos for this dispatch (issue body markers, labels, or config default)
+  const repoResolution = resolveRepos(enrichedIssue.description, labels, pluginConfig);
+
   // 4. Assess complexity tier
   const assessment = await assessTier(api, {
     identifier,
@@ -1283,29 +1335,53 @@ async function handleDispatch(
   });
 
   api.logger.info(`@dispatch: ${identifier} assessed as ${assessment.tier} (${assessment.model}) — ${assessment.reasoning}`);
+  emitDiagnostic(api, { event: "dispatch_started", identifier, tier: assessment.tier, issueId: issue.id });
+
+  // 5. Create persistent worktree(s)
+  let worktreePath: string;
+  let worktreeBranch: string;
+  let worktreeResumed: boolean;
+  let worktrees: Array<{ repoName: string; path: string; branch: string }> | undefined;
 
-  // 5. Create persistent worktree
-  let worktree;
   try {
-    worktree = createWorktree(identifier, { baseRepo, baseDir: worktreeBaseDir });
-    api.logger.info(`@dispatch: worktree ${worktree.resumed ? "resumed" : "created"} at ${worktree.path}`);
+    if (isMultiRepo(repoResolution)) {
+      const multi = createMultiWorktree(identifier, repoResolution.repos, { baseDir: worktreeBaseDir });
+      worktreePath = multi.parentPath;
+      worktreeBranch = `codex/${identifier}`;
+      worktreeResumed = multi.worktrees.some(w => w.resumed);
+      worktrees = multi.worktrees.map(w => ({ repoName: w.repoName, path: w.path, branch: w.branch }));
+      api.logger.info(`@dispatch: multi-repo worktrees ${worktreeResumed ? "resumed" : "created"} at ${worktreePath} (${repoResolution.repos.map(r => r.name).join(", ")})`);
+    } else {
+      const single = createWorktree(identifier, { baseRepo, baseDir: worktreeBaseDir });
+      worktreePath = single.path;
+      worktreeBranch = single.branch;
+      worktreeResumed = single.resumed;
+      api.logger.info(`@dispatch: worktree ${worktreeResumed ? "resumed" : "created"} at ${worktreePath}`);
+    }
   } catch (err) {
     api.logger.error(`@dispatch: worktree creation failed: ${err}`);
     await linearApi.createComment(
       issue.id,
-      `Dispatch failed — could not create worktree: ${String(err).slice(0, 200)}`,
+      `**Dispatch failed** — couldn't create the worktree.\n\n> ${String(err).slice(0, 200)}\n\n**What to try:**\n- Check that the base repo exists\n- Re-assign this issue to try again\n- Check logs: \`journalctl --user -u openclaw-gateway --since "5 min ago"\``,
     );
     return;
   }
 
-  // 5b. Prepare workspace: pull latest from origin + init submodules
-  const prep = prepareWorkspace(worktree.path, worktree.branch);
-  if (prep.errors.length > 0) {
-    api.logger.warn(`@dispatch: workspace prep had errors: ${prep.errors.join("; ")}`);
+  // 5b. Prepare workspace(s)
+  if (worktrees) {
+    for (const wt of worktrees) {
+      const prep = prepareWorkspace(wt.path, wt.branch);
+      if (prep.errors.length > 0) {
+        api.logger.warn(`@dispatch: workspace prep for ${wt.repoName} had errors: ${prep.errors.join("; ")}`);
+      }
+    }
   } else {
-    api.logger.info(
-      `@dispatch: workspace prepared — pulled=${prep.pulled}, submodules=${prep.submodulesInitialized}`,
-    );
+    const prep = prepareWorkspace(worktreePath, worktreeBranch);
+    if (prep.errors.length > 0) {
+      api.logger.warn(`@dispatch: workspace prep had errors: ${prep.errors.join("; ")}`);
+    } else {
+      api.logger.info(`@dispatch: workspace prepared — pulled=${prep.pulled}, submodules=${prep.submodulesInitialized}`);
+    }
   }
 
   // 6. Create agent session on Linear
@@ -1319,16 +1395,16 @@ async function handleDispatch(
 
   // 6b. Initialize .claw/ artifact directory
   try {
-    ensureClawDir(worktree.path);
-    writeManifest(worktree.path, {
+    ensureClawDir(worktreePath);
+    writeManifest(worktreePath, {
       issueIdentifier: identifier,
       issueTitle: enrichedIssue.title ?? "(untitled)",
       issueId: issue.id,
       tier: assessment.tier,
       model: assessment.model,
       dispatchedAt: new Date().toISOString(),
-      worktreePath: worktree.path,
-      branch: worktree.branch,
+      worktreePath,
+      branch: worktreeBranch,
       attempts: 0,
       status: "dispatched",
       plugin: "openclaw-linear",
@@ -1343,14 +1419,16 @@ async function handleDispatch(
     issueId: issue.id,
     issueIdentifier: identifier,
     issueTitle: enrichedIssue.title ?? "(untitled)",
-    worktreePath: worktree.path,
-    branch: worktree.branch,
+    worktreePath,
+    branch: worktreeBranch,
     tier: assessment.tier,
     model: assessment.model,
     status: "dispatched",
     dispatchedAt: now,
     agentSessionId,
     attempt: 0,
+    project: enrichedIssue?.project?.id,
+    worktrees,
   }, statePath);
 
   // 8. Register active session for tool resolution
@@ -1363,16 +1441,24 @@ async function handleDispatch(
   });
 
   // 9. Post dispatch confirmation comment
-  const prepStatus = prep.errors.length > 0
-    ? `Workspace prep: partial (${prep.errors.join("; ")})`
-    : `Workspace prep: OK (pulled=${prep.pulled}, submodules=${prep.submodulesInitialized})`;
+  const worktreeDesc = worktrees
+    ? worktrees.map(wt => `\`${wt.repoName}\`: \`${wt.path}\``).join("\n")
+    : `\`${worktreePath}\``;
   const statusComment = [
     `**Dispatched** as **${assessment.tier}** (${assessment.model})`,
     `> ${assessment.reasoning}`,
     ``,
-    `Worktree: \`${worktree.path}\` ${worktree.resumed ? "(resumed)" : "(fresh)"}`,
-    `Branch: \`${worktree.branch}\``,
-    prepStatus,
+    worktrees
+      ? `Worktrees ${worktreeResumed ? "(resumed)" : "(fresh)"}:\n${worktreeDesc}`
+      : `Worktree: ${worktreeDesc} ${worktreeResumed ? "(resumed)" : "(fresh)"}`,
+    `Branch: \`${worktreeBranch}\``,
+    ``,
+    `**Status:** Worker is starting now. An independent audit runs automatically after implementation.`,
+    ``,
+    `**While you wait:**`,
+    `- Check progress: \`/dispatch status ${identifier}\``,
+    `- Cancel: \`/dispatch escalate ${identifier} "reason"\``,
+    `- All dispatches: \`/dispatch list\``,
   ].join("\n");
 
   await linearApi.createComment(issue.id, statusComment);
@@ -1404,7 +1490,7 @@ async function handleDispatch(
   activeRuns.add(issue.id);
 
   // Instantiate notifier (Discord, Slack, or both — config-driven)
-  const notify: NotifyFn = createNotifierFromConfig(pluginConfig, api.runtime);
+  const notify: NotifyFn = createNotifierFromConfig(pluginConfig, api.runtime, api);
 
   const hookCtx: HookContext = {
     api,
@@ -1429,6 +1515,18 @@ async function handleDispatch(
     .catch(async (err) => {
       api.logger.error(`@dispatch: pipeline v2 failed for ${identifier}: ${err}`);
       await updateDispatchStatus(identifier, "failed", statePath);
+      // Write memory for failed dispatches so they're searchable in dispatch history
+      try {
+        const wsDir = resolveOrchestratorWorkspace(api, pluginConfig);
+        writeDispatchMemory(identifier, `Pipeline failed: ${String(err).slice(0, 500)}`, wsDir, {
+          title: enrichedIssue.title ?? identifier,
+          tier: assessment.tier,
+          status: "failed",
+          project: enrichedIssue?.project?.id,
+          attempts: 1,
+          model: assessment.model,
+        });
+      } catch { /* best effort */ }
     })
     .finally(() => {
       activeRuns.delete(issue.id);