gsd-pi 2.80.0 → 2.81.0

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -17,6 +17,8 @@ import { isAutoActive, checkRemoteAutoSession } from "./auto.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { currentDirectoryRoot, projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { buildDoctorHealIssuePayload, buildDoctorHealSummary, buildWorkflowDispatchContent, } from "./workflow-protocol.js";
+import { restoreGsdWorkflowTools, scopeGsdWorkflowToolsForDispatch, } from "./bootstrap/register-hooks.js";
 const UPDATE_REGISTRY_URL = "https://registry.npmjs.org/gsd-pi/latest";
 const UPDATE_FETCH_TIMEOUT_MS = 5000;
 // Detects a bun-installed gsd via `process.argv[1]`. Mirrors isBunInstall in
@@ -64,13 +66,19 @@ export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(gsdHome(), "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     const prompt = loadPrompt("doctor-heal", {
-        doctorSummary: reportText,
-        structuredIssues,
+        doctorSummary: buildDoctorHealSummary(reportText),
+        structuredIssues: buildDoctorHealIssuePayload(structuredIssues),
         scopeLabel: scope ?? "active milestone / blocking scope",
         doctorCommandSuffix: scope ? ` ${scope}` : "",
     });
-    const content = `Read the following GSD workflow protocol and execute exactly.\n\n${workflow}\n\n## Your Task\n\n${prompt}`;
-    pi.sendMessage({ customType: "gsd-doctor-heal", content, display: false }, { triggerTurn: true });
+    const content = buildWorkflowDispatchContent({ workflow, workflowPath, task: prompt });
+    const savedTools = scopeGsdWorkflowToolsForDispatch(pi);
+    try {
+        pi.sendMessage({ customType: "gsd-doctor-heal", content, display: false }, { triggerTurn: true });
+    }
+    finally {
+        restoreGsdWorkflowTools(pi, savedTools);
+    }
 }
 /** Parse doctor command args into structured flags and positionals (pure, no I/O). */
 export function parseDoctorArgs(args) {
@@ -213,11 +221,17 @@ export async function handleTriage(ctx, pi, basePath) {
     });
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(gsdHome(), "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
-    pi.sendMessage({
-        customType: "gsd-triage",
-        content: `Read the following GSD workflow protocol and execute exactly.\n\n${workflow}\n\n## Your Task\n\n${prompt}`,
-        display: false,
-    }, { triggerTurn: true });
+    const savedTools = scopeGsdWorkflowToolsForDispatch(pi);
+    try {
+        pi.sendMessage({
+            customType: "gsd-triage",
+            content: buildWorkflowDispatchContent({ workflow, workflowPath, task: prompt }),
+            display: false,
+        }, { triggerTurn: true });
+    }
+    finally {
+        restoreGsdWorkflowTools(pi, savedTools);
+    }
 }
 export async function handleSteer(change, ctx, pi) {
     const basePath = currentDirectoryRoot();

package/dist/resources/extensions/gsd/commands-ship.js

@@ -1,9 +1,5 @@
-/**
- * GSD Command — /gsd ship
- *
- * Creates a PR from milestone artifacts: generates title + body from
- * roadmap, slice summaries, and metrics, then opens via `gh pr create`.
- */
+// Project/App: GSD-2
+// File Purpose: Ship command for creating pull requests from GSD milestone evidence.
 import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { readFile } from "node:fs/promises";
@@ -14,6 +10,7 @@ import { nativeGetCurrentBranch, nativeDetectMainBranch } from "./native-git-bri
 import { formatDuration } from "../shared/format-utils.js";
 import { parseEvalReviewFrontmatter } from "./eval-review-schema.js";
 import { currentDirectoryRoot } from "./commands/context.js";
+import { buildPrEvidence } from "./pr-evidence.js";
 function git(basePath, args) {
     return execFileSync("git", args, { cwd: basePath, encoding: "utf-8" }).trim();
 }
@@ -114,66 +111,46 @@ export async function checkSliceEvalReview(basePath, milestoneId, sliceId) {
     };
 }
 function generatePRContent(basePath, milestoneId, milestoneTitle) {
-    const title = `feat: ${milestoneTitle || milestoneId}`;
-    const sections = [];
-    // TL;DR
-    sections.push("## TL;DR\n");
-    sections.push(`**What:** Ship milestone ${milestoneId} — ${milestoneTitle || "(untitled)"}`);
-    sections.push(`**Why:** Milestone work complete, ready for review.`);
-    sections.push(`**How:** See slice summaries below.\n`);
-    // What — slice summaries
     const summaries = collectSliceSummaries(basePath, milestoneId);
-    if (summaries.length > 0) {
-        sections.push("## What\n");
-        sections.push(summaries.join("\n\n"));
-        sections.push("");
-    }
-    // Roadmap status
+    const roadmapItems = [];
     const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
     if (roadmapPath && existsSync(roadmapPath)) {
         try {
             const roadmap = readFileSync(roadmapPath, "utf-8");
             const checkboxLines = roadmap.split("\n").filter((l) => /^\s*-\s*\[[ x]\]/.test(l));
-            if (checkboxLines.length > 0) {
-                sections.push("## Roadmap\n");
-                sections.push(checkboxLines.join("\n"));
-                sections.push("");
-            }
+            roadmapItems.push(...checkboxLines);
         }
         catch {
             // non-fatal
         }
     }
-    // Metrics
+    const metrics = [];
     const ledger = getLedger();
     const units = ledger?.units ?? loadLedgerFromDisk(basePath)?.units ?? [];
     if (units.length > 0) {
         const totals = getProjectTotals(units);
         const byModel = aggregateByModel(units);
-        sections.push("## Metrics\n");
-        sections.push(`- **Units executed:** ${units.length}`);
-        sections.push(`- **Total cost:** ${formatCost(totals.cost)}`);
-        sections.push(`- **Tokens:** ${formatTokenCount(totals.tokens.input)} input / ${formatTokenCount(totals.tokens.output)} output`);
+        metrics.push(`**Units executed:** ${units.length}`);
+        metrics.push(`**Total cost:** ${formatCost(totals.cost)}`);
+        metrics.push(`**Tokens:** ${formatTokenCount(totals.tokens.input)} input / ${formatTokenCount(totals.tokens.output)} output`);
         if (totals.duration > 0) {
-            sections.push(`- **Duration:** ${formatDuration(totals.duration)}`);
+            metrics.push(`**Duration:** ${formatDuration(totals.duration)}`);
         }
         if (byModel.length > 0) {
-            sections.push(`- **Models:** ${byModel.map((m) => `${m.model} (${m.units} units)`).join(", ")}`);
+            metrics.push(`**Models:** ${byModel.map((m) => `${m.model} (${m.units} units)`).join(", ")}`);
         }
-        sections.push("");
-    }
-    // Change type checklist
-    sections.push("## Change type\n");
-    sections.push("- [x] `feat` — New feature or capability");
-    sections.push("- [ ] `fix` — Bug fix");
-    sections.push("- [ ] `refactor` — Code restructuring");
-    sections.push("- [ ] `test` — Adding or updating tests");
-    sections.push("- [ ] `docs` — Documentation only");
-    sections.push("- [ ] `chore` — Build, CI, or tooling changes\n");
-    // AI disclosure
-    sections.push("---\n");
-    sections.push("*This PR was prepared with AI assistance (GSD auto-mode).*");
-    return { title, body: sections.join("\n") };
+    }
+    return buildPrEvidence({
+        milestoneId,
+        milestoneTitle,
+        changeType: "feat",
+        summaries,
+        roadmapItems,
+        metrics,
+        testsRun: ["Run `npm run verify:pr` before marking this PR ready."],
+        rollbackNotes: ["Revert the merge commit or close the PR before merge if review finds a regression."],
+        how: "Generated from GSD milestone slice summaries, roadmap status, and local metrics.",
+    });
 }
 export async function handleShip(args, ctx, _pi) {
     const basePath = currentDirectoryRoot();

package/dist/resources/extensions/gsd/commands-workflow-templates.js

@@ -1,12 +1,8 @@
-/**
- * GSD Workflow Template Commands — /gsd start, /gsd templates
- *
- * Handles the `/gsd start [template] [description]` and `/gsd templates` commands.
- * Resolves templates by name or auto-detection, then dispatches the workflow prompt.
- */
+// Project/App: GSD-2
+// File Purpose: Workflow template commands for starting, listing, and dispatching workflows.
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { resolveByName, autoDetect, listTemplates, getTemplateInfo, loadWorkflowTemplate, loadRegistry, } from "./workflow-templates.js";
+import { resolveByName, autoDetect, listTemplates, getTemplateInfo, loadWorkflowTemplate, loadRegistry, isLegacyWorkflowMode, } from "./workflow-templates.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
 import { createGitService, runGit } from "./git-service.js";
@@ -14,6 +10,8 @@ import { isAutoActive, isAutoPaused } from "./auto.js";
 import { getErrorMessage } from "./error-utils.js";
 import { resolvePlugin } from "./workflow-plugins.js";
 import { currentDirectoryRoot } from "./commands/context.js";
+import { formatRecommendedProcessPaths } from "./process-task-path.js";
+import { incrementLegacyTelemetry } from "./legacy-telemetry.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 /**
  * Generate a URL-friendly slug from text.
@@ -244,6 +242,9 @@ export async function handleStart(args, ctx, pi) {
                 "  /gsd start bugfix fix login button not responding\n" +
                 "  /gsd start spike evaluate auth libraries\n" +
                 "  /gsd start hotfix critical: API returns 500\n\n" +
+                "Recommended task paths:\n" +
+                formatRecommendedProcessPaths() +
+                "\n\n" +
                 "Flags:\n" +
                 "  --dry-run       Preview what would happen without executing\n" +
                 "  --issue <ref>   Link to a GitHub issue\n\n" +
@@ -364,6 +365,9 @@ export async function handleStart(args, ctx, pi) {
         infoLines.push(`Artifacts: ${artifactDir}`);
     infoLines.push(`Branch: ${actualBranch}`);
     ctx.ui.notify(infoLines.join("\n"), "info");
+    if (isLegacyWorkflowMode(template.mode)) {
+        incrementLegacyTelemetry("legacy.workflowEngineUsed");
+    }
     const prompt = loadPrompt("workflow-start", {
         templateId,
         templateName: template.name,
@@ -491,6 +495,7 @@ export function dispatchMarkdownPhasePlugin(plugin, description, ctx, pi) {
         infoLines.push(`Artifacts: ${artifactDir}`);
     infoLines.push(`Branch: ${actualBranch}`);
     ctx.ui.notify(infoLines.join("\n"), "info");
+    incrementLegacyTelemetry("legacy.workflowEngineUsed");
     const prompt = loadPrompt("workflow-start", {
         templateId,
         templateName: plugin.meta.displayName,

package/dist/resources/extensions/gsd/component-loader.js

@@ -1,18 +1,10 @@
-/**
- * Component Loader
- *
- * Multi-format loader that handles:
- * 1. New format: component.yaml + SKILL.md/AGENT.md
- * 2. Legacy skill format: SKILL.md with YAML frontmatter
- * 3. Legacy agent format: .md with YAML frontmatter (name, description, tools, model)
- *
- * Auto-detects format by checking for component.yaml first, then falling back
- * to legacy formats based on file naming conventions.
- */
+// Project/App: GSD-2
+// File Purpose: Loads modern component.yaml definitions and legacy skill/agent formats.
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { parseFrontmatter } from '@gsd/pi-coding-agent';
+import { incrementLegacyTelemetry } from './legacy-telemetry.js';
 import { validateComponentName, validateComponentDescription, computeComponentId, } from './component-types.js';
 const SUPPORTED_COMPONENT_KINDS = ['skill', 'agent'];
 const SUPPORTED_API_VERSIONS = ['gsd/v1'];
@@ -183,6 +175,7 @@ function loadFromLegacySkill(filePath, dir, source) {
         format: 'skill-md',
         enabled: true,
     };
+    incrementLegacyTelemetry('legacy.componentFormatUsed');
     return { component, diagnostics };
 }
 function loadFromLegacyAgent(filePath, source) {
@@ -235,6 +228,7 @@ function loadFromLegacyAgent(filePath, source) {
         format: 'agent-md',
         enabled: true,
     };
+    incrementLegacyTelemetry('legacy.componentFormatUsed');
     return { component, diagnostics };
 }
 // ============================================================================

package/dist/resources/extensions/gsd/context-budget.js

@@ -7,7 +7,7 @@
  *
  * @see D001 (module location), D002 (200K fallback), D003 (section-boundary truncation)
  */
-import { getCharsPerToken } from "./token-counter.js";
+import { getCharsPerToken, isAccurateCountingAvailable, countTokensSync, } from "./token-counter.js";
 // ─── Budget ratio constants ──────────────────────────────────────────────────
 // Percentages of total context window allocated to each budget category.
 // These are applied after tokens→chars conversion.
@@ -23,6 +23,22 @@ const CHARS_PER_TOKEN = 4;
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 /** Conservative effective context for Claude Code subscription routing (#4676) */
 const CLAUDE_CODE_EFFECTIVE_CONTEXT_WINDOW = 200_000;
+/**
+ * Cached empirical chars-per-token from a tiktoken probe, keyed by provider.
+ * countTokensSync's fallback path is provider-aware, so we cache per-provider
+ * to preserve that distinction once the encoder warms. The cl100k_base encoder
+ * itself gives a stable ratio for ASCII English so a single probe per provider
+ * key is sufficient. Empty map means "not yet probed" or "encoder unavailable".
+ */
+const _empiricalCharsPerTokenByProvider = new Map();
+/**
+ * Test hook — clears the empirical chars-per-token cache so test cases that
+ * assert against the static char-ratio fallback aren't polluted by a prior
+ * tiktoken-warmed run in the same process. Production code must not call this.
+ */
+export function _resetEmpiricalCacheForTest() {
+    _empiricalCharsPerTokenByProvider.clear();
+}
 /** Percentage of context consumed before suggesting a continue-here checkpoint */
 const CONTINUE_THRESHOLD_PERCENT = 70;
 // ─── Task count bounds ───────────────────────────────────────────────────────
@@ -46,7 +62,26 @@ const TASK_COUNT_TIERS = [
 export function computeBudgets(contextWindow, provider) {
     const effectiveWindow = contextWindow > 0 ? contextWindow : DEFAULT_CONTEXT_WINDOW;
     const charsPerToken = provider ? getCharsPerToken(provider) : CHARS_PER_TOKEN;
-    const totalChars = effectiveWindow * charsPerToken;
+    // Prefer the tiktoken encoder for total-char estimation when it has been
+    // warmed (initTokenCounter resolved). The cl100k_base ratio is stable for
+    // ASCII English, so probe once per provider and cache — computeBudgets is
+    // called multiple times per prompt build and the probe encode is otherwise
+    // wasted work.
+    let totalChars;
+    if (isAccurateCountingAvailable()) {
+        const providerKey = provider ?? "__default__";
+        let empirical = _empiricalCharsPerTokenByProvider.get(providerKey);
+        if (empirical === undefined) {
+            const probe = "the quick brown fox jumps over the lazy dog ".repeat(64);
+            const probeTokens = countTokensSync(probe, provider);
+            empirical = probeTokens > 0 ? probe.length / probeTokens : charsPerToken;
+            _empiricalCharsPerTokenByProvider.set(providerKey, empirical);
+        }
+        totalChars = effectiveWindow * empirical;
+    }
+    else {
+        totalChars = effectiveWindow * charsPerToken;
+    }
     return {
         summaryBudgetChars: Math.floor(totalChars * SUMMARY_RATIO),
         inlineContextBudgetChars: Math.floor(totalChars * INLINE_CONTEXT_RATIO),

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -29,6 +29,7 @@ import { _getAdapter, isDbAvailable } from "./gsd-db.js";
 import { gsdRoot, normalizeRealPath } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { effectiveLockFile } from "./session-lock.js";
+import { isInFlightRuntimePhase, listUnitRuntimeRecords } from "./unit-runtime.js";
 const SESSION_FILE_KV_KEY = "session_file";
 function lockPath(basePath) {
     return join(gsdRoot(basePath), effectiveLockFile());
@@ -72,9 +73,37 @@ function getLatestDispatchForWorker(workerId) {
      LIMIT 1`).get({ ":worker_id": workerId });
     return row ?? null;
 }
-function workerToLockData(worker) {
+function latestInFlightRuntimeRecord(basePath) {
+    const records = listUnitRuntimeRecords(basePath).filter((record) => isInFlightRuntimePhase(record.phase));
+    if (records.length === 0)
+        return null;
+    return records.sort((a, b) => {
+        const bTime = b.updatedAt || b.startedAt || 0;
+        const aTime = a.updatedAt || a.startedAt || 0;
+        return bTime - aTime;
+    })[0] ?? null;
+}
+function runtimeRecordToLockData(worker, record, sessionFile) {
+    const startedAt = Number.isFinite(record.startedAt)
+        ? new Date(record.startedAt).toISOString()
+        : worker.started_at;
+    return {
+        pid: worker.pid,
+        startedAt: worker.started_at,
+        unitType: record.unitType,
+        unitId: record.unitId,
+        unitStartedAt: startedAt,
+        sessionFile,
+    };
+}
+function workerToLockData(basePath, worker) {
     const dispatch = getLatestDispatchForWorker(worker.worker_id);
     const sessionFile = getRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY) ?? undefined;
+    if (!dispatch) {
+        const runtimeRecord = latestInFlightRuntimeRecord(basePath);
+        if (runtimeRecord)
+            return runtimeRecordToLockData(worker, runtimeRecord, sessionFile);
+    }
     return {
         pid: worker.pid,
         startedAt: worker.started_at,
@@ -172,7 +201,7 @@ export function readCrashLock(basePath) {
             const projectRoot = normalizeRealPath(basePath);
             const stale = findStaleWorkerForProject(projectRoot);
             if (stale)
-                return workerToLockData(stale);
+                return workerToLockData(basePath, stale);
         }
         catch {
             // Fall through to the legacy lock-file compatibility path.
@@ -232,18 +261,32 @@ export function formatCrashInfo(lock) {
 export function emitCrashRecoveredUnitEnd(basePath, lock) {
     if (!lock.unitType || !lock.unitId || lock.unitType === "starting")
         return;
+    emitOpenUnitEndForUnit(basePath, lock.unitType, lock.unitId, "crash-recovered");
+}
+export function emitOpenUnitEndForUnit(basePath, unitType, unitId, status, errorContext) {
     try {
         const all = queryJournal(basePath);
-        const starts = all.filter((e) => e.eventType === "unit-start" && e.data?.unitId === lock.unitId);
+        const starts = all.filter((e) => e.eventType === "unit-start" &&
+            e.data?.unitType === unitType &&
+            e.data?.unitId === unitId);
         if (starts.length === 0)
-            return;
-        const lastStart = starts[starts.length - 1];
+            return false;
+        const lastStart = [...starts].reverse().find((start) => {
+            return !all.some((e) => e.eventType === "unit-end" &&
+                e.data?.unitType === unitType &&
+                e.data?.unitId === unitId &&
+                e.causedBy?.flowId === start.flowId &&
+                e.causedBy?.seq === start.seq);
+        });
+        if (!lastStart)
+            return false;
         const alreadyClosed = all.some((e) => e.eventType === "unit-end" &&
-            e.data?.unitId === lock.unitId &&
+            e.data?.unitType === unitType &&
+            e.data?.unitId === unitId &&
             e.causedBy?.flowId === lastStart.flowId &&
             e.causedBy?.seq === lastStart.seq);
         if (alreadyClosed)
-            return;
+            return false;
         const maxSeq = all
             .filter((e) => e.flowId === lastStart.flowId)
             .reduce((max, e) => Math.max(max, e.seq), lastStart.seq);
@@ -253,16 +296,19 @@ export function emitCrashRecoveredUnitEnd(basePath, lock) {
             seq: maxSeq + 1,
             eventType: "unit-end",
             data: {
-                unitType: lock.unitType,
-                unitId: lock.unitId,
-                status: "crash-recovered",
+                unitType,
+                unitId,
+                status,
                 artifactVerified: false,
+                ...(errorContext ? { errorContext } : {}),
             },
             causedBy: { flowId: lastStart.flowId, seq: lastStart.seq },
         });
+        return true;
     }
     catch {
         // Never throw from crash recovery path.
+        return false;
     }
 }
 /**

package/dist/resources/extensions/gsd/custom-workflow-engine.js

@@ -13,13 +13,29 @@
  */
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { readGraph, writeGraph, getNextPendingStep, markStepActive, markStepComplete, expandIteration, } from "./graph.js";
+import { readGraph, writeGraph, getNextPendingStep, markStepActive, markStepComplete, expandIteration, isTerminalStepStatus, } from "./graph.js";
 import { injectContext } from "./context-injector.js";
 import { readFrozenDefinition } from "./definition-io.js";
 import { parseUnitId } from "./unit-id.js";
 import { withFileLock } from "./file-lock.js";
 // Re-export for downstream consumers
 export { readFrozenDefinition } from "./definition-io.js";
+function formatBlockedWorkflowReason(graph) {
+    const statusById = new Map(graph.steps.map((step) => [step.id, step.status]));
+    const blockedSteps = graph.steps
+        .filter((step) => step.status === "pending")
+        .map((step) => {
+        const blockers = step.dependsOn
+            .filter((depId) => !isTerminalStepStatus(statusById.get(depId)))
+            .map((depId) => `${depId} (${statusById.get(depId) ?? "missing"})`);
+        return blockers.length > 0
+            ? `${step.id} waiting on ${blockers.join(", ")}`
+            : `${step.id} has no runnable dependency path`;
+    });
+    return blockedSteps.length > 0
+        ? `Workflow blocked: no pending steps are ready. Blocked steps: ${blockedSteps.join("; ")}`
+        : "Workflow blocked: no pending steps are ready.";
+}
 export class CustomWorkflowEngine {
     engineId = "custom";
     runDir;
@@ -78,6 +94,14 @@ export class CustomWorkflowEngine {
             }
             let next = getNextPendingStep(graph);
             if (!next) {
+                const allDone = graph.steps.every((step) => step.status === "complete" || step.status === "expanded");
+                if (!allDone) {
+                    return {
+                        action: "stop",
+                        reason: formatBlockedWorkflowReason(graph),
+                        level: "error",
+                    };
+                }
                 return {
                     action: "stop",
                     reason: "All steps complete",

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -21,7 +21,7 @@ import { estimateTimeRemaining } from "./auto-dashboard.js";
 import { computeProgressScore } from "./progress-score.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
-function unitLabel(type) {
+export function unitLabel(type) {
     switch (type) {
         case "discuss-milestone":
         case "discuss-slice": return "Discuss";

package/dist/resources/extensions/gsd/db/unit-dispatches.js

@@ -26,6 +26,58 @@ function isAlreadyActiveConstraintError(err) {
     }
     return /\bUNIQUE\b|\bconstraint failed\b/i.test(msg);
 }
+function settleStaleActiveDispatchForUnit(input, now) {
+    const db = _getAdapter();
+    const active = db.prepare(`SELECT id, status, worker_id, milestone_lease_token
+     FROM unit_dispatches
+     WHERE unit_id = :unit_id
+       AND status IN ('claimed','running')
+     ORDER BY id DESC
+     LIMIT 1`).get({ ":unit_id": input.unitId });
+    if (!active)
+        return;
+    if (active.worker_id === input.workerId &&
+        active.milestone_lease_token === input.milestoneLeaseToken) {
+        return;
+    }
+    const reason = "stale-dispatch-lease-takeover";
+    const result = db.prepare(`UPDATE unit_dispatches
+     SET status = 'canceled',
+         ended_at = :ended_at,
+         exit_reason = :reason
+     WHERE id = :id
+       AND status IN ('claimed','running')
+       AND (worker_id != :worker_id OR milestone_lease_token != :token)`).run({
+        ":id": active.id,
+        ":ended_at": now,
+        ":reason": reason,
+        ":worker_id": input.workerId,
+        ":token": input.milestoneLeaseToken,
+    });
+    const changes = typeof result.changes === "number"
+        ? result.changes
+        : 0;
+    if (changes < 1)
+        return;
+    insertAuditEvent({
+        eventId: randomUUID(),
+        traceId: input.traceId,
+        turnId: input.turnId ?? undefined,
+        category: "orchestration",
+        type: "dispatch-stale-canceled",
+        ts: now,
+        payload: {
+            dispatchId: active.id,
+            unitId: input.unitId,
+            priorStatus: active.status,
+            priorWorkerId: active.worker_id,
+            priorMilestoneLeaseToken: active.milestone_lease_token,
+            takeoverWorkerId: input.workerId,
+            takeoverMilestoneLeaseToken: input.milestoneLeaseToken,
+            reason,
+        },
+    });
+}
 /**
  * Insert a new dispatch row in `claimed` state. Atomic guard against
  * double-claim (B2): the partial unique index
@@ -58,6 +110,7 @@ export function recordDispatchClaim(input) {
                 milestoneLeaseToken: input.milestoneLeaseToken,
             };
         }
+        settleStaleActiveDispatchForUnit(input, now);
         try {
             const result = db.prepare(`INSERT INTO unit_dispatches (
           trace_id, turn_id, worker_id, milestone_lease_token,
@@ -253,6 +306,45 @@ export function markCanceled(dispatchId, reason) {
      SET status = 'canceled', ended_at = :ended_at, exit_reason = :reason
      WHERE id = :id AND status IN ('pending','claimed','running')`).run({ ":id": dispatchId, ":ended_at": now, ":reason": reason });
 }
+/**
+ * Best-effort signal/crash cleanup: cancel the latest active dispatch owned by
+ * a worker when the process is exiting before the normal loop can settle it.
+ */
+export function markLatestActiveForWorkerCanceled(workerId, reason) {
+    if (!isDbAvailable())
+        return false;
+    const now = new Date().toISOString();
+    const db = _getAdapter();
+    const result = transaction(() => {
+        return db.prepare(`UPDATE unit_dispatches
+       SET status = 'canceled', ended_at = :ended_at, exit_reason = :reason
+       WHERE id = (
+         SELECT id FROM unit_dispatches
+         WHERE worker_id = :worker_id
+           AND status IN ('pending','claimed','running')
+         ORDER BY id DESC
+         LIMIT 1
+       )`).run({
+            ":ended_at": now,
+            ":reason": reason,
+            ":worker_id": workerId,
+        });
+    });
+    const changes = typeof result.changes === "number"
+        ? result.changes
+        : 0;
+    if (changes <= 0)
+        return false;
+    insertAuditEvent({
+        eventId: randomUUID(),
+        traceId: workerId,
+        category: "orchestration",
+        type: "dispatch-canceled",
+        ts: now,
+        payload: { workerId, reason },
+    });
+    return true;
+}
 /**
  * Fetch the most recent N dispatches for a unit. Used by recordDispatchClaim
  * callers to compute attempt_n and by detect-stuck.ts (B3) to consult

package/dist/resources/extensions/gsd/db-adapter.js

@@ -0,0 +1,47 @@
+// Project/App: GSD-2
+// File Purpose: Normalized SQLite adapter wrapper used by the GSD database facade.
+export function normalizeDbRow(row) {
+    if (row == null)
+        return undefined;
+    if (Object.getPrototypeOf(row) === null) {
+        return { ...row };
+    }
+    return row;
+}
+export function normalizeDbRows(rows) {
+    return rows.map((row) => normalizeDbRow(row));
+}
+export function createDbAdapter(rawDb) {
+    const db = rawDb;
+    const stmtCache = new Map();
+    function wrapStmt(raw) {
+        return {
+            run(...params) {
+                return raw.run(...params);
+            },
+            get(...params) {
+                return normalizeDbRow(raw.get(...params));
+            },
+            all(...params) {
+                return normalizeDbRows(raw.all(...params));
+            },
+        };
+    }
+    return {
+        exec(sql) {
+            db.exec(sql);
+        },
+        prepare(sql) {
+            let cached = stmtCache.get(sql);
+            if (cached)
+                return cached;
+            cached = wrapStmt(db.prepare(sql));
+            stmtCache.set(sql, cached);
+            return cached;
+        },
+        close() {
+            stmtCache.clear();
+            db.close();
+        },
+    };
+}