gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

package/dist/resources/extensions/gsd/provider-switch-observer.js

@@ -0,0 +1,146 @@
+// GSD-2 — ADR-005 Phase 3b: surface ProviderSwitchReport from pi-ai.
+//
+// pi-ai builds a ProviderSwitchReport on every cross-provider transform but
+// only logs it to stderr when GSD_VERBOSE=1. This module installs a
+// single-subscriber observer that surfaces non-empty reports through GSD's
+// three usual telemetry surfaces:
+//
+//   1. UOK audit event (category model-policy, type provider-switch) — only
+//      when an auto trace is active.
+//   2. Persistent notification (.gsd/notifications.jsonl, severity warning) —
+//      whenever the GSD basePath is known, so users see the loss in the
+//      dashboard / status surface without GSD_VERBOSE.
+//   3. In-memory counter, exposed via getProviderSwitchStats() so any
+//      caller (dashboard, doctor, tests) can read the rollup.
+import { setProviderSwitchObserver } from "@gsd/pi-ai";
+import { autoSession } from "./auto-runtime-state.js";
+import { appendNotification } from "./notification-store.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+const INTERACTIVE_TRACE_KEY = "interactive";
+let installed = false;
+let totalSwitches = 0;
+const totals = {
+    thinkingBlocksDropped: 0,
+    thinkingBlocksDowngraded: 0,
+    toolCallIdsRemapped: 0,
+    syntheticToolResultsInserted: 0,
+    thoughtSignaturesDropped: 0,
+};
+const byTrace = new Map();
+let lastReport = null;
+let lastAt = null;
+/** Format a one-line summary suitable for a notification message. */
+function summarize(report) {
+    const parts = [];
+    if (report.thinkingBlocksDropped > 0)
+        parts.push(`${report.thinkingBlocksDropped} thinking dropped`);
+    if (report.thinkingBlocksDowngraded > 0)
+        parts.push(`${report.thinkingBlocksDowngraded} thinking downgraded`);
+    if (report.toolCallIdsRemapped > 0)
+        parts.push(`${report.toolCallIdsRemapped} tool ids remapped`);
+    if (report.syntheticToolResultsInserted > 0)
+        parts.push(`${report.syntheticToolResultsInserted} synthetic tool results`);
+    if (report.thoughtSignaturesDropped > 0)
+        parts.push(`${report.thoughtSignaturesDropped} thought signatures dropped`);
+    return `Provider switch ${report.fromApi} → ${report.toApi}: ${parts.join(", ")}`;
+}
+function recordReport(report) {
+    const now = new Date().toISOString();
+    totalSwitches += 1;
+    totals.thinkingBlocksDropped += report.thinkingBlocksDropped;
+    totals.thinkingBlocksDowngraded += report.thinkingBlocksDowngraded;
+    totals.toolCallIdsRemapped += report.toolCallIdsRemapped;
+    totals.syntheticToolResultsInserted += report.syntheticToolResultsInserted;
+    totals.thoughtSignaturesDropped += report.thoughtSignaturesDropped;
+    lastReport = report;
+    lastAt = now;
+    const traceKey = autoSession.currentTraceId ?? INTERACTIVE_TRACE_KEY;
+    const existing = byTrace.get(traceKey);
+    if (existing) {
+        existing.switches += 1;
+        existing.lastReport = report;
+        existing.lastAt = now;
+    }
+    else {
+        byTrace.set(traceKey, { switches: 1, lastReport: report, lastAt: now });
+    }
+}
+function emitAudit(report) {
+    const traceId = autoSession.currentTraceId;
+    const basePath = autoSession.basePath;
+    if (!traceId || !basePath)
+        return;
+    try {
+        emitUokAuditEvent(basePath, buildAuditEnvelope({
+            traceId,
+            category: "model-policy",
+            type: "provider-switch",
+            payload: {
+                fromApi: report.fromApi,
+                toApi: report.toApi,
+                thinkingBlocksDropped: report.thinkingBlocksDropped,
+                thinkingBlocksDowngraded: report.thinkingBlocksDowngraded,
+                toolCallIdsRemapped: report.toolCallIdsRemapped,
+                syntheticToolResultsInserted: report.syntheticToolResultsInserted,
+                thoughtSignaturesDropped: report.thoughtSignaturesDropped,
+            },
+        }));
+    }
+    catch {
+        // Audit emission is best-effort. Counter + notification still fire.
+    }
+}
+function emitNotification(report) {
+    try {
+        appendNotification(summarize(report), "warning", "workflow-logger");
+    }
+    catch {
+        // Notification persistence is best-effort.
+    }
+}
+function handleReport(report) {
+    recordReport(report);
+    emitAudit(report);
+    emitNotification(report);
+}
+/**
+ * Install the pi-ai observer. Idempotent — calling more than once is a no-op
+ * after the first install.
+ */
+export function installProviderSwitchObserver() {
+    if (installed)
+        return;
+    setProviderSwitchObserver(handleReport);
+    installed = true;
+}
+/** Uninstall the observer. Intended for tests. */
+export function uninstallProviderSwitchObserver() {
+    setProviderSwitchObserver(undefined);
+    installed = false;
+}
+/** Read-only snapshot of the in-memory rollup. */
+export function getProviderSwitchStats() {
+    const trace = {};
+    for (const [key, value] of byTrace) {
+        trace[key] = { switches: value.switches, lastReport: { ...value.lastReport }, lastAt: value.lastAt };
+    }
+    return {
+        totalSwitches,
+        totals: { ...totals },
+        byTrace: trace,
+        lastReport: lastReport ? { ...lastReport } : null,
+        lastAt,
+    };
+}
+/** Reset the in-memory rollup. Intended for tests. */
+export function _resetProviderSwitchStats() {
+    totalSwitches = 0;
+    totals.thinkingBlocksDropped = 0;
+    totals.thinkingBlocksDowngraded = 0;
+    totals.toolCallIdsRemapped = 0;
+    totals.syntheticToolResultsInserted = 0;
+    totals.thoughtSignaturesDropped = 0;
+    byTrace.clear();
+    lastReport = null;
+    lastAt = null;
+}

package/dist/resources/extensions/gsd/queue-reorder-ui.js

@@ -24,6 +24,7 @@ export async function showQueueReorder(ctx, completed, pending) {
         const items = [...pending];
         let cursor = 0;
         let grabbed = false;
+        let scrollOffset = 0;
         let cachedLines;
         let validation;
         // Mutable deps map — tracks removals during this session
@@ -128,9 +129,11 @@ export async function showQueueReorder(ctx, completed, pending) {
                 return cachedLines;
             const ui = makeUI(theme, width);
             const lines = [];
+            const queueRows = [];
             const push = (...rows) => { for (const r of rows)
                 lines.push(...r); };
             const add = (s) => truncateToWidth(s, width);
+            let cursorQueueRow = 0;
             const headerText = grabbed ? "  Queue Reorder — Moving Item" : "  Queue Reorder";
             push(ui.bar(), ui.blank(), ui.header(headerText), ui.blank());
             // Completed milestones (dimmed)
@@ -153,13 +156,15 @@ export async function showQueueReorder(ctx, completed, pending) {
                 const num = i + 1;
                 const label = item.title && item.title !== item.id ? `${item.id}  ${item.title}` : item.id;
                 if (isCursor && grabbed) {
-                    lines.push(add(`  ${theme.fg("warning", `▸▸ ${num}. ${label}`)}`));
+                    cursorQueueRow = queueRows.length;
+                    queueRows.push(add(`  ${theme.fg("warning", `▸▸ ${num}. ${label}`)}`));
                 }
                 else if (isCursor) {
-                    lines.push(add(`  ${theme.fg("accent", `${GLYPH.cursor} ${num}. ${label}`)}`));
+                    cursorQueueRow = queueRows.length;
+                    queueRows.push(add(`  ${theme.fg("accent", `${GLYPH.cursor} ${num}. ${label}`)}`));
                 }
                 else {
-                    lines.push(add(`    ${theme.fg("text", `${num}. ${label}`)}`));
+                    queueRows.push(add(`    ${theme.fg("text", `${num}. ${label}`)}`));
                 }
                 // depends_on annotations
                 const deps = liveDeps.get(item.id) ?? [];
@@ -168,34 +173,35 @@ export async function showQueueReorder(ctx, completed, pending) {
                         continue;
                     const pairKey = `${item.id}:${dep}`;
                     if (violatedPairs.has(pairKey)) {
-                        lines.push(add(`       ${theme.fg("warning", `${GLYPH.statusWarning} depends_on: ${dep} — auto-removed on confirm`)}`));
+                        queueRows.push(add(`       ${theme.fg("warning", `${GLYPH.statusWarning} depends_on: ${dep} — auto-removed on confirm`)}`));
                     }
                     else if (redundantPairs.has(pairKey)) {
-                        lines.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep} (redundant)`)}`));
+                        queueRows.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep} (redundant)`)}`));
                     }
                     else {
-                        lines.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep}`)}`));
+                        queueRows.push(add(`       ${theme.fg("dim", `↳ depends_on: ${dep}`)}`));
                     }
                 }
                 // Missing deps
                 for (const v of validation.violations.filter(v => v.milestone === item.id && v.type === 'missing_dep')) {
-                    lines.push(add(`       ${theme.fg("error", `${GLYPH.statusWarning} depends_on: ${v.dependsOn} (does not exist)`)}`));
+                    queueRows.push(add(`       ${theme.fg("error", `${GLYPH.statusWarning} depends_on: ${v.dependsOn} (does not exist)`)}`));
                 }
             }
             // Removed deps feedback
+            const trailingLines = [];
             if (removedDeps.length > 0) {
-                push(ui.blank());
+                trailingLines.push(...ui.blank());
                 for (const r of removedDeps) {
-                    lines.push(add(`  ${theme.fg("success", `${GLYPH.statusDone} Removed: ${r.milestone} depends_on ${r.dep}`)}`));
+                    trailingLines.push(add(`  ${theme.fg("success", `${GLYPH.statusDone} Removed: ${r.milestone} depends_on ${r.dep}`)}`));
                 }
             }
             // Circular warning
             const circ = validation.violations.find(v => v.type === 'circular');
             if (circ) {
-                push(ui.blank());
-                lines.push(add(`  ${theme.fg("error", `${GLYPH.statusWarning} ${circ.message}`)}`));
+                trailingLines.push(...ui.blank());
+                trailingLines.push(add(`  ${theme.fg("error", `${GLYPH.statusWarning} ${circ.message}`)}`));
             }
-            push(ui.blank());
+            trailingLines.push(...ui.blank());
             // Hints — context-sensitive based on grab state
             const hints = [];
             if (grabbed) {
@@ -215,7 +221,18 @@ export async function showQueueReorder(ctx, completed, pending) {
                 hints.push("enter ok");
             }
             hints.push("esc");
-            push(ui.hints(hints), ui.bar());
+            trailingLines.push(...ui.hints(hints), ...ui.bar());
+            const maxOverlayRows = Math.max(10, process.stdout.rows ? Math.floor(process.stdout.rows * 0.8) : 24);
+            const availableQueueRows = Math.max(1, maxOverlayRows - lines.length - trailingLines.length);
+            const maxScroll = Math.max(0, queueRows.length - availableQueueRows);
+            if (cursorQueueRow < scrollOffset) {
+                scrollOffset = cursorQueueRow;
+            }
+            else if (cursorQueueRow >= scrollOffset + availableQueueRows) {
+                scrollOffset = cursorQueueRow - availableQueueRows + 1;
+            }
+            scrollOffset = Math.min(Math.max(scrollOffset, 0), maxScroll);
+            lines.push(...queueRows.slice(scrollOffset, scrollOffset + availableQueueRows), ...trailingLines);
             cachedLines = lines;
             return lines;
         }

package/dist/resources/extensions/gsd/repo-identity.js

@@ -405,19 +405,32 @@ function hasProjectState(externalPath) {
  * Returns the resolved external path (may differ from the computed identity).
  */
 function resolveExternalPathWithRecovery(projectPath) {
-    const computedPath = externalGsdRoot(projectPath);
+    const base = process.env.GSD_STATE_DIR || gsdHome();
     const computedId = repoIdentity(projectPath);
+    const computedPath = join(base, "projects", computedId);
+    const computedHasState = hasProjectState(computedPath);
+    const markerId = readGsdIdMarker(projectPath);
+    const markerPath = markerId ? join(base, "projects", markerId) : null;
+    const markerHasState = markerPath ? hasProjectState(markerPath) : false;
+    // Split-brain guard: when marker and computed identities disagree and both
+    // directories contain state, prefer the marker-backed directory. This keeps
+    // all writers anchored to a single canonical project identity even if a
+    // transient identity computation produced a stale computed hash.
+    if (markerId
+        && markerPath
+        && markerId !== computedId
+        && markerHasState
+        && computedHasState) {
+        return { path: markerPath, identity: markerId };
+    }
     // Check if computed path already has state — fast path, no recovery needed.
-    if (hasProjectState(computedPath)) {
-        return computedPath;
+    if (computedHasState) {
+        return { path: computedPath, identity: computedId };
     }
     // Check for .gsd-id marker from a previous location.
-    const markerId = readGsdIdMarker(projectPath);
-    if (markerId && markerId !== computedId) {
+    if (markerId && markerPath && markerId !== computedId) {
         // The marker points to a different identity — the repo was likely moved.
-        const base = process.env.GSD_STATE_DIR || gsdHome();
-        const markerPath = join(base, "projects", markerId);
-        if (hasProjectState(markerPath)) {
+        if (markerHasState) {
             // Recover: use the old state directory and update the marker to the new identity.
             // Move the state from the old hash dir to the new one so future lookups work
             // without the marker.
@@ -446,11 +459,11 @@ function resolveExternalPathWithRecovery(projectPath) {
             }
             catch {
                 // If migration fails, just point at the old directory.
-                return markerPath;
+                return { path: markerPath, identity: markerId };
             }
         }
     }
-    return computedPath;
+    return { path: computedPath, identity: computedId };
 }
 // ─── Symlink Management ─────────────────────────────────────────────────────
 /**
@@ -467,17 +480,18 @@ function resolveExternalPathWithRecovery(projectPath) {
  * Returns the resolved external path.
  */
 export function ensureGsdSymlink(projectPath) {
-    const result = ensureGsdSymlinkCore(projectPath);
+    const { path: result, identity } = ensureGsdSymlinkCore(projectPath);
     // Write .gsd-id marker so future relocations can recover this state (#2750).
     // Only write for the project root (not subdirectories or worktrees that
     // delegate to a parent .gsd).
     if (!isInsideWorktree(projectPath)) {
-        writeGsdIdMarker(projectPath, repoIdentity(projectPath));
+        writeGsdIdMarker(projectPath, identity);
     }
     return result;
 }
 function ensureGsdSymlinkCore(projectPath) {
-    const externalPath = resolveExternalPathWithRecovery(projectPath);
+    const resolved = resolveExternalPathWithRecovery(projectPath);
+    const externalPath = resolved.path;
     const localGsd = join(projectPath, ".gsd");
     const inWorktree = isInsideWorktree(projectPath);
     // Guard: Never create a symlink at ~/.gsd — that's the user-level GSD home,
@@ -498,7 +512,7 @@ function ensureGsdSymlinkCore(projectPath) {
     const localGsdNormalized = normalizeForGuard(localGsd);
     const gsdHomeNorm = normalizeForGuard(gsdHome());
     if (localGsdNormalized === gsdHomeNorm) {
-        return localGsd;
+        return { path: localGsd, identity: resolved.identity };
     }
     // Guard: If projectPath is a plain subdirectory (not a worktree) of a git
     // repo that already has a .gsd at the git root, do not create a duplicate
@@ -516,7 +530,10 @@ function ensureGsdSymlinkCore(projectPath) {
                     try {
                         const rootStat = lstatSync(rootGsd);
                         if (rootStat.isSymbolicLink() || rootStat.isDirectory()) {
-                            return rootStat.isSymbolicLink() ? realpathSync(rootGsd) : rootGsd;
+                            return {
+                                path: rootStat.isSymbolicLink() ? realpathSync(rootGsd) : rootGsd,
+                                identity: resolved.identity,
+                            };
                         }
                     }
                     catch {
@@ -544,7 +561,7 @@ function ensureGsdSymlinkCore(projectPath) {
         }
         catch { /* already gone */ }
         symlinkSync(externalPath, localGsd, "junction");
-        return externalPath;
+        return resolved;
     };
     // Check for dangling symlinks (e.g. after relocation recovery removed the old
     // state dir). existsSync follows symlinks, so it returns false for dangling ones.
@@ -567,7 +584,7 @@ function ensureGsdSymlinkCore(projectPath) {
         }
         catch { /* nothing to remove */ }
         symlinkSync(externalPath, localGsd, "junction");
-        return externalPath;
+        return resolved;
     }
     try {
         const stat = lstatSync(localGsd);
@@ -575,7 +592,7 @@ function ensureGsdSymlinkCore(projectPath) {
             // Already a symlink — verify it points to the right place
             const target = realpathSync(localGsd);
             if (target === externalPath) {
-                return externalPath; // correct symlink, no-op
+                return resolved; // correct symlink, no-op
             }
             // In a worktree, mismatched symlinks are always stale. Heal them so
             // the worktree points at the same external state dir as the main repo.
@@ -610,24 +627,24 @@ function ensureGsdSymlinkCore(projectPath) {
                 }
                 catch {
                     // Migration failed — preserve old symlink
-                    return target;
+                    return { path: target, identity: resolved.identity };
                 }
             }
             // Outside worktrees, preserve custom overrides or legacy symlinks.
-            return target;
+            return { path: target, identity: resolved.identity };
         }
         if (stat.isDirectory()) {
             // Real directory in the main repo — migration will handle this later.
             // In worktrees, keep the directory in place and let syncGsdStateToWorktree
             // refresh its contents. Replacing a git-tracked .gsd directory with a
             // symlink makes git think tracked planning files were deleted.
-            return localGsd;
+            return { path: localGsd, identity: resolved.identity };
         }
     }
     catch {
         // lstat failed — path exists but we can't stat it
     }
-    return localGsd;
+    return { path: localGsd, identity: resolved.identity };
 }
 // ─── Worktree Detection ─────────────────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/repository-registry.js

@@ -0,0 +1,44 @@
+// GSD-2 + Repository registry seam for parent workspace multi-repo resolution.
+import { isAbsolute, relative, resolve } from "node:path";
+import { resolveGsdPathContract } from "./paths.js";
+function assertInsideProjectRoot(projectRoot, candidateRoot, repoId) {
+    const rel = relative(projectRoot, candidateRoot);
+    if (rel === "")
+        return;
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+        throw new Error(`workspace.repositories.${repoId}.path resolves outside project root: ${candidateRoot}`);
+    }
+}
+function resolveRepositoryRoot(projectRoot, repoId, repo) {
+    const root = resolve(projectRoot, repo.path);
+    assertInsideProjectRoot(projectRoot, root, repoId);
+    return {
+        id: repoId,
+        root,
+        role: repo.role,
+        verification: repo.verification,
+        commitPolicy: repo.commit_policy,
+    };
+}
+export function createRepositoryRegistry(basePath, workspacePrefs) {
+    const contract = resolveGsdPathContract(basePath);
+    const projectRoot = contract.projectRoot;
+    const mode = workspacePrefs?.mode ?? "project";
+    const repoMap = new Map();
+    // Backward-compatible default for single-repo projects.
+    // Explicit workspacePrefs?.repositories entries can override "project"
+    // via resolveRepositoryRoot to customize role/verification/commit policy.
+    repoMap.set("project", { id: "project", root: projectRoot });
+    for (const [repoId, repoConfig] of Object.entries(workspacePrefs?.repositories ?? {})) {
+        repoMap.set(repoId, resolveRepositoryRoot(projectRoot, repoId, repoConfig));
+    }
+    return {
+        projectRoot,
+        mode,
+        repositories: Array.from(repoMap.values()),
+        byId: repoMap,
+    };
+}
+export function createRepositoryRegistryFromPreferences(basePath, preferences) {
+    return createRepositoryRegistry(basePath, preferences?.workspace);
+}

package/dist/resources/extensions/gsd/safety/evidence-collector.js

@@ -17,6 +17,8 @@ import { randomBytes } from "node:crypto";
 const EXECUTION_TOOL_NAMES = new Set([
     "bash",
     "Bash",
+    "PowerShell",
+    "async_bash",
     "gsd_exec",
     "gsd_exec_search",
     "mcp__gsd-workflow__gsd_exec",

package/dist/resources/extensions/gsd/safety/evidence-cross-ref.js

@@ -15,7 +15,7 @@
 export function crossReferenceEvidence(claimedEvidence, actualEvidence) {
     const bashCalls = actualEvidence.filter((e) => e.kind === "bash");
     const mismatches = [];
-    for (const claimed of claimedEvidence) {
+    for (const claimed of latestClaimBatch(claimedEvidence)) {
         // Skip coerced entries — they're already flagged with exitCode: -1
         // and verdict: "unknown (coerced from string)" by db-tools.ts
         if (claimed.verdict?.includes("coerced from string"))
@@ -25,9 +25,11 @@ export function crossReferenceEvidence(claimedEvidence, actualEvidence) {
         // Skip entries with empty or generic commands
         if (!claimed.command || claimed.command.length < 3)
             continue;
-        // Find matching bash call by command substring match
-        const match = findBestMatch(claimed.command, bashCalls);
-        if (!match) {
+        // Find matching bash calls by command similarity. A command may be retried
+        // after a failed first run; the newest matching execution is the one that
+        // supports or rejects a claimed pass.
+        const matches = findMatches(claimed.command, bashCalls);
+        if (matches.length === 0) {
             mismatches.push({
                 severity: "warning",
                 claimed,
@@ -37,6 +39,7 @@ export function crossReferenceEvidence(claimedEvidence, actualEvidence) {
             continue;
         }
         // Exit code mismatch: LLM claims success but actual command failed
+        const match = latestMatch(matches);
         if (claimed.exitCode === 0 && match.exitCode !== 0) {
             mismatches.push({
                 severity: "error",
@@ -50,34 +53,55 @@ export function crossReferenceEvidence(claimedEvidence, actualEvidence) {
 }
 // ─── Internals ──────────────────────────────────────────────────────────────
 /**
- * Find the best matching bash evidence entry for a claimed command.
+ * Verification evidence rows are append-only across retries, but a task
+ * completion inserts one batch at a single created_at timestamp. When that
+ * timestamp is present, safety should judge the newest completion claim only.
+ */
+function latestClaimBatch(claimedEvidence) {
+    const dated = claimedEvidence
+        .map((claim) => ({
+        claim,
+        time: typeof claim.createdAt === "string" ? Date.parse(claim.createdAt) : Number.NaN,
+    }))
+        .filter((entry) => Number.isFinite(entry.time));
+    if (dated.length === 0)
+        return claimedEvidence;
+    const latestTime = Math.max(...dated.map((entry) => entry.time));
+    return claimedEvidence.filter((claim) => (typeof claim.createdAt === "string" && Date.parse(claim.createdAt) === latestTime));
+}
+/**
+ * Find bash evidence entries matching a claimed command.
  * Uses substring matching — the claimed command may be a shortened version
  * of the actual command, or vice versa.
  */
-function findBestMatch(claimedCommand, bashCalls) {
+function findMatches(claimedCommand, bashCalls) {
     const normalized = claimedCommand.trim();
-    // Exact match first
-    const exact = bashCalls.find(b => b.command.trim() === normalized);
-    if (exact)
+    // Exact matches first
+    const exact = bashCalls.filter(b => b.command.trim() === normalized);
+    if (exact.length > 0)
         return exact;
     // Substring match: claimed is contained in actual or actual in claimed
-    const substring = bashCalls.find(b => b.command.includes(normalized) || normalized.includes(b.command));
-    if (substring)
+    const substring = bashCalls.filter(b => b.command.includes(normalized) || normalized.includes(b.command));
+    if (substring.length > 0)
         return substring;
     // Token match: split on whitespace and check significant overlap
     const claimedTokens = normalized.split(/\s+/).filter(t => t.length > 2);
     if (claimedTokens.length === 0)
-        return null;
-    let bestMatch = null;
-    let bestScore = 0;
+        return [];
+    const scoredMatches = [];
     for (const call of bashCalls) {
         const callTokens = new Set(call.command.split(/\s+/));
         const matchCount = claimedTokens.filter(t => callTokens.has(t)).length;
         const score = matchCount / claimedTokens.length;
-        if (score > bestScore && score >= 0.5) {
-            bestScore = score;
-            bestMatch = call;
+        if (score >= 0.5) {
+            scoredMatches.push({ call, score });
         }
     }
-    return bestMatch;
+    const bestScore = Math.max(0, ...scoredMatches.map((match) => match.score));
+    return scoredMatches
+        .filter((match) => match.score === bestScore)
+        .map((match) => match.call);
+}
+function latestMatch(matches) {
+    return matches.reduce((latest, match) => (match.timestamp > latest.timestamp ? match : latest));
 }

package/dist/resources/extensions/gsd/session-lock.js

@@ -18,8 +18,9 @@
 import { createRequire } from "node:module";
 import { existsSync, readFileSync, readdirSync, mkdirSync, unlinkSync, rmSync, statSync } from "node:fs";
 import { join, dirname } from "node:path";
-import { gsdRoot } from "./paths.js";
+import { gsdRoot, normalizeRealPath } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
+import { markWorkerStoppingByPid } from "./db/auto-workers.js";
 const _require = createRequire(import.meta.url);
 // ─── Module State ───────────────────────────────────────────────────────────
 /** Release function from proper-lockfile — calling it releases the OS lock. */
@@ -225,6 +226,12 @@ export function acquireSessionLock(basePath) {
     mkdirSync(dirname(lp), { recursive: true });
     // Clean up numbered lock file variants from cloud sync conflicts (#1315)
     cleanupStrayLockFiles(basePath);
+    // If lock metadata points to a dead PID, mark that worker row stopping so
+    // crash diagnostics do not keep surfacing it as active.
+    const existingPreflight = readExistingLockData(lp);
+    if (existingPreflight?.pid && !isPidAlive(existingPreflight.pid)) {
+        markWorkerStoppingByPid(normalizeRealPath(basePath), existingPreflight.pid);
+    }
     // Write our lock data first (the content is informational; the OS lock is the real guard)
     const lockData = {
         pid: process.pid,
@@ -250,7 +257,10 @@ export function acquireSessionLock(basePath) {
     const lockDir = lockTarget + ".lock";
     if (existsSync(lockDir)) {
         const existingData = readExistingLockData(lp);
-        const isOrphan = !existingData || (existingData.pid && !isPidAlive(existingData.pid));
+        const deadPid = existingData?.pid && !isPidAlive(existingData.pid) ? existingData.pid : null;
+        if (deadPid)
+            markWorkerStoppingByPid(normalizeRealPath(basePath), deadPid);
+        const isOrphan = !existingData || !!deadPid;
         if (isOrphan) {
             try {
                 rmSync(lockDir, { recursive: true, force: true });
@@ -288,6 +298,9 @@ export function acquireSessionLock(basePath) {
         // Check: if auto.lock is gone and no process is alive, the lock dir is stale.
         const existingData = readExistingLockData(lp);
         const existingPid = existingData?.pid;
+        if (existingPid && !isPidAlive(existingPid)) {
+            markWorkerStoppingByPid(normalizeRealPath(basePath), existingPid);
+        }
         // If no lock file or no alive process, try to clean up and re-acquire (#1245)
         if (!existingData || (existingPid && !isPidAlive(existingPid))) {
             try {

package/dist/resources/extensions/gsd/slice-parallel-conflict.js

@@ -42,8 +42,8 @@ function extractFilePaths(content) {
  * @returns         true if parallel is unsafe (>5 shared files or missing plan).
  */
 export function hasFileConflict(basePath, mid, sliceA, sliceB) {
-    const planPathA = join(basePath, ".gsd", "milestones", mid, sliceA, "PLAN.md");
-    const planPathB = join(basePath, ".gsd", "milestones", mid, sliceB, "PLAN.md");
+    const planPathA = join(basePath, ".gsd", "milestones", mid, "slices", sliceA, `${sliceA}-PLAN.md`);
+    const planPathB = join(basePath, ".gsd", "milestones", mid, "slices", sliceB, `${sliceB}-PLAN.md`);
     // Conservative: missing PLAN = block
     if (!existsSync(planPathA) || !existsSync(planPathB)) {
         return true;