gsd-pi 2.82.0 → 3.0.0-dev.2e8b124f7

package/src/resources/extensions/gsd/provider-switch-observer.ts

@@ -0,0 +1,185 @@
+// 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, type ProviderSwitchReport } from "@gsd/pi-ai";
+
+import { autoSession } from "./auto-runtime-state.js";
+import { appendNotification } from "./notification-store.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+
+/** Rollup of cross-provider context transformations, grouped by trace. */
+export interface ProviderSwitchStats {
+  /** Total non-empty reports observed since process start (or last reset). */
+  totalSwitches: number;
+  /** Sum of every counted transformation across all reports. */
+  totals: {
+    thinkingBlocksDropped: number;
+    thinkingBlocksDowngraded: number;
+    toolCallIdsRemapped: number;
+    syntheticToolResultsInserted: number;
+    thoughtSignaturesDropped: number;
+  };
+  /** Per-trace breakdown. Key "interactive" covers reports outside auto-mode. */
+  byTrace: Record<string, TraceSwitchStats>;
+  /** The most recent non-empty report, if any. */
+  lastReport: ProviderSwitchReport | null;
+  /** ISO timestamp of the most recent non-empty report, if any. */
+  lastAt: string | null;
+}
+
+export interface TraceSwitchStats {
+  switches: number;
+  lastReport: ProviderSwitchReport;
+  lastAt: string;
+}
+
+const INTERACTIVE_TRACE_KEY = "interactive";
+
+interface MutableTraceStats {
+  switches: number;
+  lastReport: ProviderSwitchReport;
+  lastAt: string;
+}
+
+let installed = false;
+let totalSwitches = 0;
+const totals = {
+  thinkingBlocksDropped: 0,
+  thinkingBlocksDowngraded: 0,
+  toolCallIdsRemapped: 0,
+  syntheticToolResultsInserted: 0,
+  thoughtSignaturesDropped: 0,
+};
+const byTrace = new Map<string, MutableTraceStats>();
+let lastReport: ProviderSwitchReport | null = null;
+let lastAt: string | null = null;
+
+/** Format a one-line summary suitable for a notification message. */
+function summarize(report: ProviderSwitchReport): string {
+  const parts: string[] = [];
+  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: ProviderSwitchReport): void {
+  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: ProviderSwitchReport): void {
+  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: ProviderSwitchReport): void {
+  try {
+    appendNotification(summarize(report), "warning", "workflow-logger");
+  } catch {
+    // Notification persistence is best-effort.
+  }
+}
+
+function handleReport(report: ProviderSwitchReport): void {
+  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(): void {
+  if (installed) return;
+  setProviderSwitchObserver(handleReport);
+  installed = true;
+}
+
+/** Uninstall the observer. Intended for tests. */
+export function uninstallProviderSwitchObserver(): void {
+  setProviderSwitchObserver(undefined);
+  installed = false;
+}
+
+/** Read-only snapshot of the in-memory rollup. */
+export function getProviderSwitchStats(): ProviderSwitchStats {
+  const trace: Record<string, TraceSwitchStats> = {};
+  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(): void {
+  totalSwitches = 0;
+  totals.thinkingBlocksDropped = 0;
+  totals.thinkingBlocksDowngraded = 0;
+  totals.toolCallIdsRemapped = 0;
+  totals.syntheticToolResultsInserted = 0;
+  totals.thoughtSignaturesDropped = 0;
+  byTrace.clear();
+  lastReport = null;
+  lastAt = null;
+}

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/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/slice-parallel-orchestrator.ts

@@ -18,13 +18,15 @@ import { randomUUID } from "node:crypto";
 import {
   appendFileSync,
   existsSync,
+  lstatSync,
+  rmSync,
   writeFileSync,
   readFileSync,
   mkdirSync,
   renameSync,
   unlinkSync,
 } from "node:fs";
-import { join, dirname } from "node:path";
+import { isAbsolute, join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager.js";
@@ -105,6 +107,37 @@ export function _buildSliceWorkerEnvForTest(
   };
 }
 
+function isValidSliceWorktreePath(basePath: string, wtPath: string): boolean {
+  if (!existsSync(wtPath)) return false;
+  const gitPath = join(wtPath, ".git");
+  if (!existsSync(gitPath)) return false;
+  try {
+    if (!lstatSync(gitPath).isFile()) return false;
+    const content = readFileSync(gitPath, "utf8").trim();
+    if (!content.startsWith("gitdir: ")) return false;
+    const rawGitdir = content.slice("gitdir: ".length).trim();
+    if (!rawGitdir) return false;
+    const resolvedGitdir = isAbsolute(rawGitdir) ? rawGitdir : resolve(wtPath, rawGitdir);
+    const expectedPrefix = join(basePath, ".git", "worktrees").replaceAll("\\", "/");
+    const normalized = resolvedGitdir.replaceAll("\\", "/");
+    return normalized === expectedPrefix || normalized.startsWith(`${expectedPrefix}/`);
+  } catch {
+    return false;
+  }
+}
+
+function isWorkerPidAlive(pid: number): boolean {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException)?.code;
+    if (code === "ESRCH") return false;
+    return true;
+  }
+}
+
 interface PersistedSliceWorker {
   milestoneId: string;
   sliceId: string;
@@ -427,6 +460,9 @@ export async function startSliceParallel(
       const wtName = `${milestoneId}-${slice.id}`;
       const wtPath = worktreePath(basePath, wtName);
 
+      if (existsSync(wtPath) && !isValidSliceWorktreePath(basePath, wtPath)) {
+        rmSync(wtPath, { recursive: true, force: true });
+      }
       if (!existsSync(wtPath)) {
         createWorktree(basePath, wtName, { branch: wtBranch });
       }
@@ -470,6 +506,21 @@ export async function startSliceParallel(
     }
   }
 
+  // Guard: if workers died immediately, treat as failed start so callers
+  // don't exit auto-mode and re-dispatch in a rapid loop.
+  for (let i = started.length - 1; i >= 0; i--) {
+    const sid = started[i];
+    const worker = sliceState.workers.get(sid);
+    if (worker && isWorkerPidAlive(worker.pid)) continue;
+    started.splice(i, 1);
+    errors.push({ sid, error: "Worker exited immediately after spawn" });
+    sliceState.workers.delete(sid);
+    const wtName = `${milestoneId}-${sid}`;
+    try {
+      removeWorktree(basePath, wtName, { deleteBranch: true, force: true });
+    } catch { /* ignore cleanup failures */ }
+  }
+
   // If nothing started, deactivate
   if (started.length === 0) {
     sliceState.active = false;

package/src/resources/extensions/gsd/smart-entry-routing.ts

@@ -0,0 +1,77 @@
+// GSD-2 — Smart entry routing decisions.
+// Pure route selection for /gsd guided wizard choices.
+
+export type SmartEntryIsolationMode = "worktree" | "branch" | "none";
+
+export type ActiveTaskChoice =
+  | "execute"
+  | "auto"
+  | "status"
+  | "milestone_actions";
+
+export type ActiveTaskRoute =
+  | {
+      kind: "auto-bootstrap";
+      verboseMode: false;
+      options?: {
+        step?: true;
+        milestoneLock?: string;
+      };
+    }
+  | {
+      kind: "guided-dispatch";
+      unitType: "execute-task";
+    }
+  | {
+      kind: "status";
+    }
+  | {
+      kind: "milestone-actions";
+    };
+
+export function resolveGuidedExecuteLaunchMode(
+  isolationMode: SmartEntryIsolationMode,
+): "auto-step" | "guided-dispatch" {
+  return isolationMode === "worktree" ? "auto-step" : "guided-dispatch";
+}
+
+export function resolveActiveTaskChoiceRoute(input: {
+  choice: ActiveTaskChoice;
+  isolationMode: SmartEntryIsolationMode;
+  milestoneId: string;
+}): ActiveTaskRoute {
+  if (input.choice === "auto") {
+    return {
+      kind: "auto-bootstrap",
+      verboseMode: false,
+    };
+  }
+
+  if (input.choice === "execute") {
+    if (resolveGuidedExecuteLaunchMode(input.isolationMode) === "auto-step") {
+      return {
+        kind: "auto-bootstrap",
+        verboseMode: false,
+        options: {
+          step: true,
+          milestoneLock: input.milestoneId,
+        },
+      };
+    }
+
+    return {
+      kind: "guided-dispatch",
+      unitType: "execute-task",
+    };
+  }
+
+  if (input.choice === "status") {
+    return { kind: "status" };
+  }
+
+  if (input.choice === "milestone_actions") {
+    return { kind: "milestone-actions" };
+  }
+
+  throw new Error(`Invalid ActiveTaskChoice: ${input.choice}`);
+}