@calltelemetry/openclaw-linear 0.4.0 → 0.5.0

package/src/tier-assess.ts

@@ -0,0 +1,157 @@
+/**
+ * tier-assess.ts — LLM-based complexity assessment for Linear issues.
+ *
+ * Uses runAgent() with the agent's configured model (e.g. kimi-k2.5)
+ * to assess issue complexity. The agent model handles orchestration —
+ * it never calls coding CLIs directly.
+ *
+ * Cost: one short agent turn (~500 tokens). Latency: ~2-5s.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { Tier } from "./dispatch-state.js";
+
+// ---------------------------------------------------------------------------
+// Tier → Model mapping
+// ---------------------------------------------------------------------------
+
+export const TIER_MODELS: Record<Tier, string> = {
+  junior: "anthropic/claude-haiku-4-5",
+  medior: "anthropic/claude-sonnet-4-6",
+  senior: "anthropic/claude-opus-4-6",
+};
+
+export interface TierAssessment {
+  tier: Tier;
+  model: string;
+  reasoning: string;
+}
+
+export interface IssueContext {
+  identifier: string;
+  title: string;
+  description?: string | null;
+  labels?: string[];
+  commentCount?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Assessment
+// ---------------------------------------------------------------------------
+
+const ASSESS_PROMPT = `You are a complexity assessor. Assess this issue and respond ONLY with JSON.
+
+Tiers:
+- junior: typos, copy changes, config tweaks, simple CSS, env var additions
+- medior: features, bugfixes, moderate refactoring, adding tests, API changes
+- senior: architecture changes, database migrations, security fixes, multi-service coordination
+
+Consider:
+1. How many files/services are likely affected?
+2. Does it touch auth, data, or external APIs? (higher risk → higher tier)
+3. Is the description clear and actionable?
+4. Are there dependencies or unknowns?
+
+Respond ONLY with: {"tier":"junior|medior|senior","reasoning":"one sentence"}`;
+
+/**
+ * Assess issue complexity using the agent's configured model.
+ *
+ * Falls back to "medior" if the agent call fails or returns invalid JSON.
+ */
+export async function assessTier(
+  api: OpenClawPluginApi,
+  issue: IssueContext,
+  agentId?: string,
+): Promise<TierAssessment> {
+  const issueText = [
+    `Issue: ${issue.identifier} — ${issue.title}`,
+    issue.description ? `Description: ${issue.description.slice(0, 1500)}` : "",
+    issue.labels?.length ? `Labels: ${issue.labels.join(", ")}` : "",
+    issue.commentCount != null ? `Comments: ${issue.commentCount}` : "",
+  ].filter(Boolean).join("\n");
+
+  const message = `${ASSESS_PROMPT}\n\n${issueText}`;
+
+  try {
+    const { runAgent } = await import("./agent.js");
+    const result = await runAgent({
+      api,
+      agentId: agentId ?? resolveDefaultAgent(api),
+      sessionId: `tier-assess-${issue.identifier}-${Date.now()}`,
+      message,
+      timeoutMs: 30_000, // 30s — this should be fast
+    });
+
+    // Try to parse assessment from output regardless of success flag.
+    // runAgent may report success:false (non-zero exit code) even when
+    // the agent produced valid JSON output — e.g. agent exited with
+    // signal but wrote the response before terminating.
+    if (result.output) {
+      const parsed = parseAssessment(result.output);
+      if (parsed) {
+        api.logger.info(`Tier assessment for ${issue.identifier}: ${parsed.tier} — ${parsed.reasoning} (agent success=${result.success})`);
+        return parsed;
+      }
+    }
+
+    if (!result.success) {
+      api.logger.warn(`Tier assessment agent failed for ${issue.identifier}: ${result.output.slice(0, 200)}`);
+    } else {
+      api.logger.warn(`Tier assessment for ${issue.identifier}: could not parse response: ${result.output.slice(0, 200)}`);
+    }
+  } catch (err) {
+    api.logger.warn(`Tier assessment error for ${issue.identifier}: ${err}`);
+  }
+
+  // Fallback: medior is the safest default
+  const fallback: TierAssessment = {
+    tier: "medior",
+    model: TIER_MODELS.medior,
+    reasoning: "Assessment failed — defaulting to medior",
+  };
+  api.logger.info(`Tier assessment fallback for ${issue.identifier}: medior`);
+  return fallback;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function resolveDefaultAgent(api: OpenClawPluginApi): string {
+  // Use the plugin's configured default agent (same one that runs the pipeline)
+  const fromConfig = (api as any).pluginConfig?.defaultAgentId;
+  if (typeof fromConfig === "string" && fromConfig) return fromConfig;
+
+  // Fall back to isDefault in agent profiles
+  try {
+    const profilesPath = join(process.env.HOME ?? "/home/claw", ".openclaw", "agent-profiles.json");
+    const raw = readFileSync(profilesPath, "utf8");
+    const profiles = JSON.parse(raw).agents ?? {};
+    const defaultAgent = Object.entries(profiles).find(([, p]: [string, any]) => p.isDefault);
+    if (defaultAgent) return defaultAgent[0];
+  } catch { /* fall through */ }
+
+  return "default";
+}
+
+function parseAssessment(raw: string): TierAssessment | null {
+  // Extract JSON from the response (may have markdown wrapping)
+  const jsonMatch = raw.match(/\{[^}]+\}/);
+  if (!jsonMatch) return null;
+
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    const tier = parsed.tier as string;
+    if (tier !== "junior" && tier !== "medior" && tier !== "senior") return null;
+
+    return {
+      tier: tier as Tier,
+      model: TIER_MODELS[tier as Tier],
+      reasoning: parsed.reasoning ?? "no reasoning provided",
+    };
+  } catch {
+    return null;
+  }
+}

package/src/webhook.ts

@@ -3,9 +3,12 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { LinearAgentApi, resolveLinearToken } from "./linear-api.js";
-// Pipeline is used from Issue.update delegation handler (not from agent session chat)
-// import { runFullPipeline, resumePipeline, type PipelineContext } from "./pipeline.js";
+import { spawnWorker, type HookContext } from "./pipeline.js";
 import { setActiveSession, clearActiveSession } from "./active-session.js";
+import { readDispatchState, getActiveDispatch, registerDispatch, updateDispatchStatus, completeDispatch, removeActiveDispatch } from "./dispatch-state.js";
+import { createDiscordNotifier, createNoopNotifier, type NotifyFn } from "./notify.js";
+import { assessTier } from "./tier-assess.js";
+import { createWorktree, prepareWorkspace } from "./codex-worktree.js";
 
 // ── Agent profiles (loaded from config, no hardcoded names) ───────
 interface AgentProfile {
@@ -858,7 +861,7 @@ export async function handleLinearWebhook(
     }
 
     const trigger = isDelegatedToUs ? "delegated" : "assigned";
-    api.logger.info(`Issue ${trigger} to our app user (${viewerId}), processing`);
+    api.logger.info(`Issue ${trigger} to our app user (${viewerId}), executing pipeline`);
 
     // Dedup on assignment/delegation
     const dedupKey = `${trigger}:${issue.id}:${viewerId}`;
@@ -867,200 +870,11 @@ export async function handleLinearWebhook(
       return true;
     }
 
-    const agentId = resolveAgentId(api);
-
-    // Fetch full issue details + team labels for triage
-    let enrichedIssue: any = issue;
-    let teamLabels: Array<{ id: string; name: string }> = [];
-    try {
-      enrichedIssue = await linearApi.getIssueDetails(issue.id);
-      if (enrichedIssue?.team?.id) {
-        teamLabels = await linearApi.getTeamLabels(enrichedIssue.team.id);
-      }
-    } catch (err) {
-      api.logger.warn(`Could not fetch issue details: ${err}`);
-    }
-
-    const description = enrichedIssue?.description ?? issue?.description ?? "(no description)";
-    const comments = enrichedIssue?.comments?.nodes ?? [];
-    const commentSummary = comments
-      .slice(-5)
-      .map((c: any) => `  - **${c.user?.name ?? "Unknown"}**: ${c.body?.slice(0, 200)}`)
-      .join("\n");
-
-    const estimationType = enrichedIssue?.team?.issueEstimationType ?? "fibonacci";
-    const currentLabels = enrichedIssue?.labels?.nodes ?? [];
-    const currentLabelNames = currentLabels.map((l: any) => l.name).join(", ") || "None";
-    const availableLabelList = teamLabels.map((l) => `  - "${l.name}" (id: ${l.id})`).join("\n");
-
-    const message = [
-      `IMPORTANT: You are triaging a delegated Linear issue. You MUST respond with a JSON block containing your triage decisions, followed by your assessment as plain text.`,
-      ``,
-      `## Issue: ${enrichedIssue?.identifier ?? issue.identifier ?? issue.id} — ${enrichedIssue?.title ?? issue.title ?? "(untitled)"}`,
-      `**Status:** ${enrichedIssue?.state?.name ?? "Unknown"} | **Current Estimate:** ${enrichedIssue?.estimate ?? "None"} | **Current Labels:** ${currentLabelNames}`,
-      ``,
-      `**Description:**`,
-      description,
-      commentSummary ? `\n**Recent comments:**\n${commentSummary}` : "",
-      ``,
-      `## Your Triage Tasks`,
-      ``,
-      `1. **Story Points** — Estimate complexity using ${estimationType} scale (1=trivial, 2=small, 3=medium, 5=large, 8=very large, 13=epic)`,
-      `2. **Labels** — Select appropriate labels from the team's available labels`,
-      `3. **Assessment** — Brief analysis of what this issue needs`,
-      ``,
-      `## Available Labels`,
-      availableLabelList || "  (no labels configured)",
-      ``,
-      `## Response Format`,
-      ``,
-      `You MUST start your response with a JSON block, then follow with your assessment:`,
-      ``,
-      '```json',
-      `{`,
-      `  "estimate": <number>,`,
-      `  "labelIds": ["<id1>", "<id2>"],`,
-      `  "assessment": "<one-line summary of your sizing rationale>"`,
-      `}`,
-      '```',
-      ``,
-      `Then write your full assessment as markdown below the JSON block.`,
-    ].filter(Boolean).join("\n");
-
-    // Dispatch agent with session lifecycle (non-blocking)
-    void (async () => {
-      const profiles = loadAgentProfiles();
-      const defaultProfile = Object.entries(profiles).find(([, p]) => p.isDefault);
-      const label = defaultProfile?.[1]?.label ?? profiles[agentId]?.label ?? agentId;
-      const avatarUrl = defaultProfile?.[1]?.avatarUrl ?? profiles[agentId]?.avatarUrl;
-      let agentSessionId: string | null = null;
-
-      try {
-        const sessionResult = await linearApi.createSessionOnIssue(issue.id);
-        agentSessionId = sessionResult.sessionId;
-        if (agentSessionId) {
-          wasRecentlyProcessed(`session:${agentSessionId}`);
-          api.logger.info(`Created agent session ${agentSessionId} for ${trigger}`);
-          setActiveSession({
-            agentSessionId,
-            issueIdentifier: enrichedIssue?.identifier ?? issue.identifier ?? issue.id,
-            issueId: issue.id,
-            agentId,
-            startedAt: Date.now(),
-          });
-        } else {
-          api.logger.warn(`Could not create agent session for assignment: ${sessionResult.error ?? "unknown"}`);
-        }
-
-        if (agentSessionId) {
-          await linearApi.emitActivity(agentSessionId, {
-            type: "thought",
-            body: `Reviewing assigned issue ${enrichedIssue?.identifier ?? issue.id}...`,
-          }).catch(() => {});
-        }
-
-        if (agentSessionId) {
-          await linearApi.emitActivity(agentSessionId, {
-            type: "action",
-            action: "Triaging",
-            parameter: `${enrichedIssue?.identifier ?? issue.id} — estimating, labeling, sizing`,
-          }).catch(() => {});
-        }
-
-        const sessionId = `linear-assign-${issue.id}-${Date.now()}`;
-        const { runAgent } = await import("./agent.js");
-        const result = await runAgent({
-          api,
-          agentId,
-          sessionId,
-          message,
-          timeoutMs: 3 * 60_000,
-          streaming: agentSessionId ? { linearApi, agentSessionId } : undefined,
-        });
-
-        const responseBody = result.success
-          ? result.output
-          : `I encountered an error reviewing this assignment. Please try again.`;
-
-        // Parse triage JSON from agent response and apply to issue
-        let commentBody = responseBody;
-        if (result.success) {
-          const jsonMatch = responseBody.match(/```json\s*\n?([\s\S]*?)\n?```/);
-          if (jsonMatch) {
-            try {
-              const triage = JSON.parse(jsonMatch[1]);
-              const updateInput: Record<string, unknown> = {};
-
-              if (typeof triage.estimate === "number") {
-                updateInput.estimate = triage.estimate;
-              }
-              if (Array.isArray(triage.labelIds) && triage.labelIds.length > 0) {
-                // Merge with existing labels
-                const existingIds = currentLabels.map((l: any) => l.id);
-                const allIds = [...new Set([...existingIds, ...triage.labelIds])];
-                updateInput.labelIds = allIds;
-              }
-
-              if (Object.keys(updateInput).length > 0) {
-                await linearApi.updateIssue(issue.id, updateInput);
-                api.logger.info(`Applied triage to ${enrichedIssue?.identifier ?? issue.id}: ${JSON.stringify(updateInput)}`);
-
-                if (agentSessionId) {
-                  await linearApi.emitActivity(agentSessionId, {
-                    type: "action",
-                    action: "Applied triage",
-                    result: `estimate=${triage.estimate ?? "unchanged"}, labels=${triage.labelIds?.length ?? 0} added`,
-                  }).catch(() => {});
-                }
-              }
-
-              // Strip the JSON block from the comment — post only the assessment
-              commentBody = responseBody.replace(/```json\s*\n?[\s\S]*?\n?```\s*\n?/, "").trim();
-            } catch (parseErr) {
-              api.logger.warn(`Could not parse triage JSON: ${parseErr}`);
-            }
-          }
-        }
-
-        // Post comment with assessment
-        const brandingOpts = avatarUrl
-          ? { createAsUser: label, displayIconUrl: avatarUrl }
-          : undefined;
-
-        try {
-          if (brandingOpts) {
-            await linearApi.createComment(issue.id, commentBody, brandingOpts);
-          } else {
-            await linearApi.createComment(issue.id, `**[${label}]** ${commentBody}`);
-          }
-        } catch (brandErr) {
-          api.logger.warn(`Branded comment failed, falling back to prefix: ${brandErr}`);
-          await linearApi.createComment(issue.id, `**[${label}]** ${commentBody}`);
-        }
-
-        if (agentSessionId) {
-          const truncated = commentBody.length > 2000
-            ? commentBody.slice(0, 2000) + "…"
-            : commentBody;
-          await linearApi.emitActivity(agentSessionId, {
-            type: "response",
-            body: truncated,
-          }).catch(() => {});
-        }
-
-        api.logger.info(`Posted assignment response to ${enrichedIssue?.identifier ?? issue.id}`);
-      } catch (err) {
-        api.logger.error(`Issue assignment handler error: ${err}`);
-        if (agentSessionId) {
-          await linearApi.emitActivity(agentSessionId, {
-            type: "error",
-            body: `Failed to process assignment: ${String(err).slice(0, 500)}`,
-          }).catch(() => {});
-        }
-      } finally {
-        clearActiveSession(issue.id);
-      }
-    })();
+    // Assignment triggers the full dispatch pipeline:
+    // tier assessment → worktree → plan → implement → audit
+    void handleDispatch(api, linearApi, issue).catch((err) => {
+      api.logger.error(`Dispatch pipeline error for ${issue.identifier ?? issue.id}: ${err}`);
+    });
 
     return true;
   }
@@ -1290,3 +1104,224 @@ export async function handleLinearWebhook(
   res.end("ok");
   return true;
 }
+
+// ── @dispatch handler ─────────────────────────────────────────────
+//
+// Triggered by `@dispatch` in a Linear comment. Assesses issue complexity,
+// creates a persistent worktree, registers the dispatch in state, and
+// launches the pipeline (plan → implement → audit).
+
+async function handleDispatch(
+  api: OpenClawPluginApi,
+  linearApi: LinearAgentApi,
+  issue: any,
+): Promise<void> {
+  const pluginConfig = (api as any).pluginConfig as Record<string, unknown> | undefined;
+  const statePath = pluginConfig?.dispatchStatePath as string | undefined;
+  const worktreeBaseDir = pluginConfig?.worktreeBaseDir as string | undefined;
+  const baseRepo = (pluginConfig?.codexBaseRepo as string) ?? "/home/claw/ai-workspace";
+  const identifier = issue.identifier ?? issue.id;
+
+  api.logger.info(`@dispatch: processing ${identifier}`);
+
+  // 1. Check for existing active dispatch — reclaim if stale
+  const STALE_DISPATCH_MS = 30 * 60_000; // 30 min without a gateway holding it = stale
+  const state = await readDispatchState(statePath);
+  const existing = getActiveDispatch(state, identifier);
+  if (existing) {
+    const ageMs = Date.now() - new Date(existing.dispatchedAt).getTime();
+    const isStale = ageMs > STALE_DISPATCH_MS;
+    const inMemory = activeRuns.has(issue.id);
+
+    if (!isStale && inMemory) {
+      // Truly still running in this gateway process
+      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}\``,
+      );
+      return;
+    }
+
+    // Stale or not in memory (gateway restarted) — reclaim
+    api.logger.info(
+      `dispatch: ${identifier} reclaiming stale dispatch (status: ${existing.status}, ` +
+      `age: ${Math.round(ageMs / 1000)}s, inMemory: ${inMemory}, stale: ${isStale})`,
+    );
+    await removeActiveDispatch(identifier, statePath);
+    activeRuns.delete(issue.id);
+  }
+
+  // 2. Prevent concurrent runs on same issue
+  if (activeRuns.has(issue.id)) {
+    api.logger.info(`@dispatch: ${identifier} has active agent run — skipping`);
+    return;
+  }
+
+  // 3. Fetch full issue details for tier assessment
+  let enrichedIssue: any;
+  try {
+    enrichedIssue = await linearApi.getIssueDetails(issue.id);
+  } catch (err) {
+    api.logger.error(`@dispatch: failed to fetch issue details: ${err}`);
+    enrichedIssue = issue;
+  }
+
+  const labels = enrichedIssue.labels?.nodes?.map((l: any) => l.name) ?? [];
+  const commentCount = enrichedIssue.comments?.nodes?.length ?? 0;
+
+  // 4. Assess complexity tier
+  const assessment = await assessTier(api, {
+    identifier,
+    title: enrichedIssue.title ?? "(untitled)",
+    description: enrichedIssue.description,
+    labels,
+    commentCount,
+  });
+
+  api.logger.info(`@dispatch: ${identifier} assessed as ${assessment.tier} (${assessment.model}) — ${assessment.reasoning}`);
+
+  // 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}`);
+  } 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)}`,
+    );
+    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("; ")}`);
+  } else {
+    api.logger.info(
+      `@dispatch: workspace prepared — pulled=${prep.pulled}, submodules=${prep.submodulesInitialized}`,
+    );
+  }
+
+  // 6. Create agent session on Linear
+  let agentSessionId: string | undefined;
+  try {
+    const sessionResult = await linearApi.createSessionOnIssue(issue.id);
+    agentSessionId = sessionResult.sessionId ?? undefined;
+  } catch (err) {
+    api.logger.warn(`@dispatch: could not create agent session: ${err}`);
+  }
+
+  // 7. Register dispatch in persistent state
+  const now = new Date().toISOString();
+  await registerDispatch(identifier, {
+    issueId: issue.id,
+    issueIdentifier: identifier,
+    worktreePath: worktree.path,
+    branch: worktree.branch,
+    tier: assessment.tier,
+    model: assessment.model,
+    status: "dispatched",
+    dispatchedAt: now,
+    agentSessionId,
+    attempt: 0,
+  }, statePath);
+
+  // 8. Register active session for tool resolution
+  setActiveSession({
+    agentSessionId: agentSessionId ?? "",
+    issueIdentifier: identifier,
+    issueId: issue.id,
+    agentId: resolveAgentId(api),
+    startedAt: Date.now(),
+  });
+
+  // 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 statusComment = [
+    `**Dispatched** as **${assessment.tier}** (${assessment.model})`,
+    `> ${assessment.reasoning}`,
+    ``,
+    `Worktree: \`${worktree.path}\` ${worktree.resumed ? "(resumed)" : "(fresh)"}`,
+    `Branch: \`${worktree.branch}\``,
+    prepStatus,
+  ].join("\n");
+
+  await linearApi.createComment(issue.id, statusComment);
+
+  if (agentSessionId) {
+    await linearApi.emitActivity(agentSessionId, {
+      type: "thought",
+      body: `Dispatching ${identifier} as ${assessment.tier}...`,
+    }).catch(() => {});
+  }
+
+  // 10. Apply tier label (best effort)
+  try {
+    if (enrichedIssue.team?.id) {
+      const teamLabels = await linearApi.getTeamLabels(enrichedIssue.team.id);
+      const tierLabel = teamLabels.find((l: any) => l.name === `developer:${assessment.tier}`);
+      if (tierLabel) {
+        const currentLabelIds = enrichedIssue.labels?.nodes?.map((l: any) => l.id) ?? [];
+        await linearApi.updateIssue(issue.id, {
+          labelIds: [...currentLabelIds, tierLabel.id],
+        });
+      }
+    }
+  } catch (err) {
+    api.logger.warn(`@dispatch: could not apply tier label: ${err}`);
+  }
+
+  // 11. Run v2 pipeline: worker → audit → verdict (non-blocking)
+  activeRuns.add(issue.id);
+
+  // Instantiate notifier
+  const discordBotToken = (() => {
+    try {
+      const config = JSON.parse(
+        require("node:fs").readFileSync(
+          require("node:path").join(process.env.HOME ?? "/home/claw", ".openclaw", "openclaw.json"),
+          "utf8",
+        ),
+      );
+      return config?.channels?.discord?.token as string | undefined;
+    } catch { return undefined; }
+  })();
+  const flowDiscordChannel = pluginConfig?.flowDiscordChannel as string | undefined;
+  const notify: NotifyFn = (discordBotToken && flowDiscordChannel)
+    ? createDiscordNotifier(discordBotToken, flowDiscordChannel)
+    : createNoopNotifier();
+
+  const hookCtx: HookContext = {
+    api,
+    linearApi,
+    notify,
+    pluginConfig,
+    configPath: statePath,
+  };
+
+  // Re-read dispatch to get fresh state after registration
+  const freshState = await readDispatchState(statePath);
+  const dispatch = getActiveDispatch(freshState, identifier)!;
+
+  await notify("dispatch", {
+    identifier,
+    title: enrichedIssue.title ?? "(untitled)",
+    status: "dispatched",
+  });
+
+  // spawnWorker handles: dispatched→working→auditing→done/rework/stuck
+  spawnWorker(hookCtx, dispatch)
+    .catch(async (err) => {
+      api.logger.error(`@dispatch: pipeline v2 failed for ${identifier}: ${err}`);
+      await updateDispatchStatus(identifier, "failed", statePath);
+    })
+    .finally(() => {
+      activeRuns.delete(issue.id);
+      clearActiveSession(issue.id);
+    });
+}