gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.04f5ccf82

package/src/resources/extensions/gsd/queue-reorder-ui.ts

@@ -43,6 +43,7 @@ export async function showQueueReorder(
     const items = [...pending];
     let cursor = 0;
     let grabbed = false;
+    let scrollOffset = 0;
     let cachedLines: string[] | undefined;
     let validation: DependencyValidation;
 
@@ -154,8 +155,10 @@ export async function showQueueReorder(
 
       const ui = makeUI(theme, width);
       const lines: string[] = [];
+      const queueRows: string[] = [];
       const push = (...rows: string[][]) => { for (const r of rows) lines.push(...r); };
       const add = (s: string) => 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());
@@ -188,11 +191,13 @@ export async function showQueueReorder(
         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
@@ -201,36 +206,37 @@ export async function showQueueReorder(
           if (completedIds.has(dep)) 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: string[] = [];
       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: string[] = [];
@@ -250,7 +256,19 @@ export async function showQueueReorder(
       }
       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/src/resources/extensions/gsd/repo-identity.ts

@@ -427,22 +427,38 @@ function hasProjectState(externalPath: string): boolean {
  *
  * Returns the resolved external path (may differ from the computed identity).
  */
-function resolveExternalPathWithRecovery(projectPath: string): string {
-  const computedPath = externalGsdRoot(projectPath);
+function resolveExternalPathWithRecovery(projectPath: string): { path: string; identity: string } {
+  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.
@@ -465,12 +481,12 @@ function resolveExternalPathWithRecovery(projectPath: string): string {
         try { rmSync(markerPath, { recursive: true, force: true }); } catch { /* non-fatal */ }
       } 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 ─────────────────────────────────────────────────────
@@ -489,20 +505,21 @@ function resolveExternalPathWithRecovery(projectPath: string): string {
  * Returns the resolved external path.
  */
 export function ensureGsdSymlink(projectPath: string): string {
-  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: string): string {
-  const externalPath = resolveExternalPathWithRecovery(projectPath);
+function ensureGsdSymlinkCore(projectPath: string): { path: string; identity: string } {
+  const resolved = resolveExternalPathWithRecovery(projectPath);
+  const externalPath = resolved.path;
   const localGsd = join(projectPath, ".gsd");
   const inWorktree = isInsideWorktree(projectPath);
 
@@ -519,7 +536,7 @@ function ensureGsdSymlinkCore(projectPath: string): string {
   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
@@ -538,7 +555,10 @@ function ensureGsdSymlinkCore(projectPath: string): string {
           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 {
             // Fall through to normal logic if we can't stat root .gsd
@@ -560,12 +580,12 @@ function ensureGsdSymlinkCore(projectPath: string): string {
   // Write repo metadata once so cleanup commands can identify this directory later.
   writeRepoMeta(externalPath, getRemoteUrl(projectPath), resolveGitRoot(projectPath));
 
-  const replaceWithSymlink = (): string => {
+  const replaceWithSymlink = (): { path: string; identity: string } => {
     rmSync(localGsd, { recursive: true, force: true });
     // Defensive: remove any residual entry (e.g. dangling symlink) before creating.
     try { unlinkSync(localGsd); } catch { /* already gone */ }
     symlinkSync(externalPath, localGsd, "junction");
-    return externalPath;
+    return resolved;
   };
 
   // Check for dangling symlinks (e.g. after relocation recovery removed the old
@@ -585,7 +605,7 @@ function ensureGsdSymlinkCore(projectPath: string): string {
     // Defensive: remove any residual entry to avoid EEXIST race (#2750).
     try { unlinkSync(localGsd); } catch { /* nothing to remove */ }
     symlinkSync(externalPath, localGsd, "junction");
-    return externalPath;
+    return resolved;
   }
 
   try {
@@ -595,7 +615,7 @@ function ensureGsdSymlinkCore(projectPath: string): string {
       // 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.
@@ -620,11 +640,11 @@ function ensureGsdSymlinkCore(projectPath: string): string {
           return replaceWithSymlink();
         } 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()) {
@@ -632,13 +652,13 @@ function ensureGsdSymlinkCore(projectPath: string): string {
       // 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/src/resources/extensions/gsd/repository-registry.ts

@@ -0,0 +1,77 @@
+// GSD-2 + Repository registry seam for parent workspace multi-repo resolution.
+
+import { isAbsolute, relative, resolve } from "node:path";
+import type { GSDPreferences, WorkspacePreferences, WorkspaceRepositoryPreference } from "./preferences-types.js";
+import { resolveGsdPathContract } from "./paths.js";
+
+export interface RegisteredRepository {
+  id: string;
+  root: string;
+  role?: string;
+  verification?: string[];
+  commitPolicy?: "auto" | "skip";
+}
+
+export interface RepositoryRegistry {
+  projectRoot: string;
+  mode: "project" | "parent";
+  repositories: RegisteredRepository[];
+  byId: ReadonlyMap<string, RegisteredRepository>;
+}
+
+function assertInsideProjectRoot(projectRoot: string, candidateRoot: string, repoId: string): void {
+  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: string,
+  repoId: string,
+  repo: WorkspaceRepositoryPreference,
+): RegisteredRepository {
+  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: string,
+  workspacePrefs?: WorkspacePreferences,
+): RepositoryRegistry {
+  const contract = resolveGsdPathContract(basePath);
+  const projectRoot = contract.projectRoot;
+  const mode = workspacePrefs?.mode ?? "project";
+  const repoMap = new Map<string, RegisteredRepository>();
+
+  // 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: string,
+  preferences?: Pick<GSDPreferences, "workspace">,
+): RepositoryRegistry {
+  return createRepositoryRegistry(basePath, preferences?.workspace);
+}

package/src/resources/extensions/gsd/safety/evidence-collector.ts

@@ -53,6 +53,8 @@ export type EvidenceEntry = BashEvidence | FileWriteEvidence | FileEditEvidence;
 const EXECUTION_TOOL_NAMES = new Set([
   "bash",
   "Bash",
+  "PowerShell",
+  "async_bash",
   "gsd_exec",
   "gsd_exec_search",
   "mcp__gsd-workflow__gsd_exec",

package/src/resources/extensions/gsd/safety/evidence-cross-ref.ts

@@ -1,3 +1,4 @@
+
 /**
  * Evidence cross-reference for auto-mode safety harness.
  * Compares the LLM's claimed verification evidence (command + exitCode)
@@ -14,6 +15,7 @@ export interface ClaimedEvidence {
   command: string;
   exitCode: number;
   verdict: string;
+  createdAt?: string;
 }
 
 export interface EvidenceMismatch {
@@ -40,7 +42,7 @@ export function crossReferenceEvidence(
   );
   const mismatches: EvidenceMismatch[] = [];
 
-  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")) continue;
@@ -49,10 +51,12 @@ export function crossReferenceEvidence(
     // 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);
+    // 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 (!match) {
+    if (matches.length === 0) {
       mismatches.push({
         severity: "warning",
         claimed,
@@ -63,6 +67,7 @@ export function crossReferenceEvidence(
     }
 
     // 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",
@@ -79,42 +84,72 @@ export function crossReferenceEvidence(
 // ─── 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: readonly ClaimedEvidence[],
+): readonly 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(
+function findMatches(
   claimedCommand: string,
   bashCalls: readonly BashEvidence[],
-): BashEvidence | null {
+): BashEvidence[] {
   const normalized = claimedCommand.trim();
 
-  // Exact match first
-  const exact = bashCalls.find(b => b.command.trim() === normalized);
-  if (exact) return 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(
+  const substring = bashCalls.filter(
     b => b.command.includes(normalized) || normalized.includes(b.command),
   );
-  if (substring) return substring;
+  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;
+  if (claimedTokens.length === 0) return [];
 
-  let bestMatch: BashEvidence | null = null;
-  let bestScore = 0;
+  const scoredMatches: Array<{ call: BashEvidence; score: number }> = [];
 
   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: readonly BashEvidence[]): BashEvidence {
+  return matches.reduce((latest, match) => (
+    match.timestamp > latest.timestamp ? match : latest
+  ));
 }

package/src/resources/extensions/gsd/session-lock.ts

@@ -19,8 +19,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);
 
@@ -281,6 +282,13 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
   // 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: SessionLockData = {
     pid: process.pid,
@@ -308,7 +316,9 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
   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 }); } catch { /* best-effort */ }
       try { if (existsSync(lp)) unlinkSync(lp); } catch { /* best-effort */ }
@@ -344,6 +354,9 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     // 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))) {

package/src/resources/extensions/gsd/slice-parallel-conflict.ts

@@ -55,8 +55,8 @@ export function hasFileConflict(
   sliceA: string,
   sliceB: string,
 ): boolean {
-  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)) {