@opengsd/gsd-pi 1.3.0 → 1.4.0

package/src/resources/extensions/google-cli/stream-adapter.ts

@@ -20,7 +20,13 @@ const ZERO_USAGE = {
 	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 };
 
-type GoogleCliProviderId = "google-gemini-cli" | "google-antigravity";
+export type GoogleCliProviderId = "google-gemini-cli" | "google-antigravity";
+
+export interface GoogleCliRunPlan {
+	command: string;
+	args: string[];
+	stdin?: string;
+}
 
 interface CliRunResult {
 	stdout: string;
@@ -29,6 +35,71 @@ interface CliRunResult {
 	signal: NodeJS.Signals | null;
 }
 
+const WINDOWS_CHILD_ENV_KEYS = new Set([
+	"ALLUSERSPROFILE",
+	"APPDATA",
+	"COMSPEC",
+	"COMMONPROGRAMFILES",
+	"COMMONPROGRAMFILES(X86)",
+	"FORCE_COLOR",
+	"HOME",
+	"HOMEDRIVE",
+	"HOMEPATH",
+	"LANG",
+	"LC_ALL",
+	"LOCALAPPDATA",
+	"NODE_EXTRA_CA_CERTS",
+	"NO_COLOR",
+	"NO_PROXY",
+	"PATHEXT",
+	"PATH",
+	"PROGRAMDATA",
+	"PROGRAMFILES",
+	"PROGRAMFILES(X86)",
+	"SSL_CERT_FILE",
+	"SYSTEMROOT",
+	"TEMP",
+	"TERM",
+	"TMP",
+	"TMPDIR",
+	"USER",
+	"USERNAME",
+	"USERPROFILE",
+	"WINDIR",
+	"XDG_CACHE_HOME",
+	"XDG_CONFIG_HOME",
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+]);
+
+const WINDOWS_CHILD_ENV_PREFIXES = [
+	"AGY_",
+	"ANTIGRAVITY_",
+	"CLOUDSDK_",
+	"GEMINI_",
+	"GOOGLE_",
+];
+
+export function buildGoogleCliChildEnv(
+	env: NodeJS.ProcessEnv = process.env,
+	platform: NodeJS.Platform = process.platform,
+): NodeJS.ProcessEnv {
+	if (platform !== "win32") return env;
+
+	const childEnv: NodeJS.ProcessEnv = {};
+	for (const [key, value] of Object.entries(env)) {
+		if (typeof value !== "string") continue;
+		const upperKey = key.toUpperCase();
+		if (
+			WINDOWS_CHILD_ENV_KEYS.has(upperKey) ||
+			WINDOWS_CHILD_ENV_PREFIXES.some((prefix) => upperKey.startsWith(prefix))
+		) {
+			childEnv[key] = value;
+		}
+	}
+	return childEnv;
+}
+
 function textBlocks(content: (TextContent | { type: string })[]): string {
 	return content
 		.map((block) => block.type === "text" ? (block as TextContent).text : `[${block.type} omitted]`)
@@ -120,15 +191,15 @@ function commandForProvider(provider: GoogleCliProviderId): string {
 	return provider === "google-gemini-cli" ? "gemini" : "agy";
 }
 
-function argsForProvider(provider: GoogleCliProviderId, model: Model<Api>, prompt: string): string[] {
+function argsForProvider(provider: GoogleCliProviderId, modelId: string, prompt?: string): string[] {
 	if (provider === "google-gemini-cli") {
-		const args = ["-p", prompt, "--output-format", "json"];
-		if (model.id !== "default") args.unshift("-m", model.id);
+		const args = prompt === undefined ? ["--output-format", "json"] : ["-p", prompt, "--output-format", "json"];
+		if (modelId !== "default") args.unshift("-m", modelId);
 		return args;
 	}
 
-	const args = ["-p", prompt];
-	if (model.id !== "default") args.unshift("-m", model.id);
+	const args = prompt === undefined ? [] : ["-p", prompt];
+	if (modelId !== "default") args.unshift("-m", modelId);
 	return args;
 }
 
@@ -136,20 +207,33 @@ export function buildGoogleCliSpawnInvocation(
 	command: string,
 	args: string[],
 	platform: NodeJS.Platform = process.platform,
-): { command: string; args: string[] } {
+): Omit<GoogleCliRunPlan, "stdin"> {
 	if (platform === "win32") {
 		return { command: "cmd", args: ["/c", command, ...args] };
 	}
 	return { command, args };
 }
 
-function runCli(command: string, args: string[], options?: SimpleStreamOptions): Promise<CliRunResult> {
+export function buildGoogleCliRunPlan(
+	provider: GoogleCliProviderId,
+	modelId: string,
+	prompt: string,
+	platform: NodeJS.Platform = process.platform,
+): GoogleCliRunPlan {
+	const pipePrompt = platform === "win32";
+	const args = argsForProvider(provider, modelId, pipePrompt ? undefined : prompt);
+	return {
+		...buildGoogleCliSpawnInvocation(commandForProvider(provider), args, platform),
+		...(pipePrompt ? { stdin: prompt } : {}),
+	};
+}
+
+function runCli(plan: GoogleCliRunPlan, options?: SimpleStreamOptions): Promise<CliRunResult> {
 	return new Promise((resolve, reject) => {
-		const invocation = buildGoogleCliSpawnInvocation(command, args);
-		const child = spawn(invocation.command, invocation.args, {
+		const child = spawn(plan.command, plan.args, {
 			cwd: options?.cwd || process.cwd(),
-			env: process.env,
-			stdio: ["ignore", "pipe", "pipe"],
+			env: buildGoogleCliChildEnv(),
+			stdio: [plan.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
 		});
 
 		let stdout = "";
@@ -174,12 +258,17 @@ function runCli(command: string, args: string[], options?: SimpleStreamOptions):
 		}
 		options?.signal?.addEventListener("abort", onAbort);
 
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => {
+		if (plan.stdin !== undefined) {
+			child.stdin?.on("error", () => {});
+			child.stdin?.end(plan.stdin);
+		}
+
+		child.stdout!.setEncoding("utf8");
+		child.stderr!.setEncoding("utf8");
+		child.stdout!.on("data", (chunk) => {
 			stdout += chunk;
 		});
-		child.stderr.on("data", (chunk) => {
+		child.stderr!.on("data", (chunk) => {
 			stderr += chunk;
 		});
 
@@ -243,9 +332,7 @@ export function streamViaGoogleCli(
 	queueMicrotask(async () => {
 		try {
 			const prompt = buildGoogleCliPrompt(context);
-			const command = commandForProvider(provider);
-			const args = argsForProvider(provider, model, prompt);
-			const result = await runCli(command, args, options);
+			const result = await runCli(buildGoogleCliRunPlan(provider, model.id, prompt), options);
 
 			if (result.code !== 0) {
 				const detail = (result.stderr || result.stdout || `CLI exited with code ${result.code}`).trim();

package/src/resources/extensions/gsd/artifact-verification.ts

@@ -0,0 +1,464 @@
+// Project/App: gsd-pi
+// File Purpose: Auto-mode artifact verification and worktree path fallbacks.
+
+import { parseUnitId } from "./unit-id.js";
+import { MILESTONE_ID_RE } from "./milestone-ids.js";
+import { clearParseCache } from "./files.js";
+import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
+import {
+  isDbAvailable,
+  getTask,
+  getSlice,
+  getSliceTasks,
+  getPendingGatesForTurn,
+} from "./gsd-db.js";
+import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
+import { isValidationTerminal } from "./state.js";
+import { getErrorMessage } from "./error-utils.js";
+import { logWarning, logError } from "./workflow-logger.js";
+import { isClosedStatus } from "./status-guards.js";
+import {
+  resolveSlicePath,
+  resolveSliceFile,
+  resolveTasksDir,
+  resolveTaskFiles,
+  relSliceFile,
+  resolveMilestoneFile,
+  clearPathCache,
+  resolveGsdRootFile,
+} from "./paths.js";
+import { existsSync, readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { LAYOUT_SEGMENTS } from "./layout-policy.js";
+import { dirname, join, resolve } from "node:path";
+import {
+  resolveExpectedArtifactPath,
+  resolveExistingSliceResearchPath,
+} from "./auto-artifact-paths.js";
+import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
+import { hasVerdict } from "./verdict-parser.js";
+import { validateArtifact } from "./schemas/validate.js";
+import { getProjectResearchStatus } from "./project-research-policy.js";
+import { isGsdWorktreePath } from "./worktree-root.js";
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
+import { loadAllCaptures, loadPendingCaptures } from "./captures.js";
+import { proveMilestoneCloseout } from "./milestone-closeout-proof.js";
+
+/**
+ * Optional override for the legacy roadmap parser used by verifyExpectedArtifact.
+ * Production leaves this null so the real parseLegacyRoadmap runs; tests inject
+ * a throwing function to deterministically exercise the parse-failure catches.
+ * @internal
+ */
+let _roadmapParserFn: ((content: string) => { slices: Array<{ id: string; done: boolean; depends?: string[] }> }) | null = null;
+
+/**
+ * Inject an override for the legacy roadmap parser, returning a function that
+ * restores the default (real parser) behavior. No production caller.
+ * @internal
+ */
+export function _setRoadmapParserFnForTests(
+  fn: ((content: string) => { slices: Array<{ id: string; done: boolean; depends?: string[] }> }) | null,
+): () => void {
+  const previous = _roadmapParserFn;
+  _roadmapParserFn = fn;
+  return () => { _roadmapParserFn = previous; };
+}
+
+function parseRoadmapForRecovery(content: string): ReturnType<NonNullable<typeof _roadmapParserFn>> {
+  if (_roadmapParserFn) return _roadmapParserFn(content);
+  return parseLegacyRoadmap(content) as unknown as ReturnType<NonNullable<typeof _roadmapParserFn>>;
+}
+
+export function diagnoseWorktreeIntegrityFailure(basePath: string): string | null {
+  if (!isGsdWorktreePath(basePath)) return null;
+  if (!existsSync(basePath)) {
+    return `Worktree integrity failure: ${basePath} does not exist. Repair or recreate the worktree before retrying.`;
+  }
+
+  const gitPath = join(basePath, ".git");
+  if (!existsSync(gitPath)) {
+    return `Worktree integrity failure: ${basePath} is not a valid git worktree (.git missing). Repair or recreate the worktree before retrying.`;
+  }
+
+  try {
+    execFileSync("git", ["rev-parse", "--git-dir"], {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+    });
+    return null;
+  } catch (err) {
+    return `Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${getErrorMessage(err).split("\n")[0]}). Repair or recreate the worktree before retrying.`;
+  }
+}
+
+export function resolveArtifactVerificationBase(unitId: string, base: string): string {
+  const { milestone } = parseUnitId(unitId);
+  if (!MILESTONE_ID_RE.test(milestone)) return base;
+  return resolveCanonicalMilestoneRoot(base, milestone);
+}
+
+function hasCapturedWorkflowPrefs(base: string): boolean {
+  const prefsPath = resolveExpectedArtifactPath("workflow-preferences", "WORKFLOW-PREFS", base);
+  if (!prefsPath || !existsSync(prefsPath)) return false;
+  const content = readFileSync(prefsPath, "utf-8");
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  return !!match && /^workflow_prefs_captured:\s*true\s*$/m.test(match[1]);
+}
+
+function hasValidResearchDecision(base: string): boolean {
+  const decisionPath = resolveExpectedArtifactPath("research-decision", "RESEARCH-DECISION", base);
+  if (!decisionPath || !existsSync(decisionPath)) return false;
+  try {
+    const cfg = JSON.parse(readFileSync(decisionPath, "utf-8")) as Record<string, unknown>;
+    return cfg.decision === "research" || cfg.decision === "skip";
+  } catch {
+    return false;
+  }
+}
+
+function hasCompleteProjectResearch(base: string): boolean {
+  return getProjectResearchStatus(base).complete;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function hasCheckedTaskCompletionOnDisk(base: string, mid: string, sid: string, tid: string): boolean {
+  const slicePath = resolveSlicePath(base, mid, sid);
+  if (!slicePath) return false;
+
+  const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
+  if (!planAbs || !existsSync(planAbs)) return false;
+
+  const planContent = readFileSync(planAbs, "utf-8");
+  const cbRe = new RegExp(`^\\s*-\\s+\\[[xX]\\]\\s+\\*\\*${escapeRegExp(tid)}(?:\\*\\*)?:`, "m");
+  return cbRe.test(planContent);
+}
+
+/**
+ * Check whether the expected artifact(s) for a unit exist on disk.
+ * Returns true if all required artifacts exist, or if the unit type has no
+ * single verifiable artifact (e.g., replan-slice).
+ */
+export function verifyExpectedArtifact(
+  unitType: string,
+  unitId: string,
+  base: string,
+): boolean {
+  if (unitType.startsWith("hook/")) return true;
+
+  clearPathCache();
+  clearParseCache();
+
+  if (unitType === "rewrite-docs") {
+    const overridesPath = resolveGsdRootFile(base, "OVERRIDES");
+    if (!existsSync(overridesPath)) return true;
+    const content = readFileSync(overridesPath, "utf-8");
+    return !content.includes("**Scope:** active");
+  }
+
+  if (unitType === "workflow-preferences") {
+    return hasCapturedWorkflowPrefs(base);
+  }
+
+  if (unitType === "triage-captures") {
+    const pending = loadPendingCaptures(base);
+    if (pending.length === 0) return true;
+    logWarning("recovery", `verify-fail triage-captures ${unitId}: ${pending.length} pending capture(s) remain in CAPTURES.md`);
+    return false;
+  }
+
+  if (unitType === "quick-task") {
+    const { slice: captureId } = parseUnitId(unitId);
+    const capture = captureId ? loadAllCaptures(base).find((entry) => entry.id === captureId) : undefined;
+    if (capture?.executed === true) return true;
+    logWarning("recovery", `verify-fail quick-task ${unitId}: capture ${captureId ?? "(missing capture id)"} not found or not marked executed`);
+    return false;
+  }
+
+  if (unitType === "discuss-project") {
+    const projectPath = resolveExpectedArtifactPath(unitType, unitId, base);
+    return !!projectPath && existsSync(projectPath) && validateArtifact(projectPath, "project").ok;
+  }
+
+  if (unitType === "discuss-requirements") {
+    const requirementsPath = resolveExpectedArtifactPath(unitType, unitId, base);
+    return !!requirementsPath && existsSync(requirementsPath) && validateArtifact(requirementsPath, "requirements").ok;
+  }
+
+  if (unitType === "research-decision") {
+    return hasValidResearchDecision(base);
+  }
+
+  if (unitType === "research-project") {
+    return hasCompleteProjectResearch(base);
+  }
+
+  if (unitType === "reactive-execute") {
+    const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
+    if (!mid || !sid || !batchPart) return false;
+    const blockerPath = resolveExpectedArtifactPath(unitType, unitId, base);
+    if (blockerPath && existsSync(blockerPath)) {
+      return true;
+    }
+    const slicePath = resolveSlicePath(base, mid, sid);
+    if (!slicePath) return false;
+
+    const plusIdx = batchPart.indexOf("+");
+    if (plusIdx === -1) {
+      const tDir = resolveTasksDir(base, mid, sid) ?? slicePath;
+      const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
+      return summaryFiles.length > 0;
+    }
+
+    const batchIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
+    if (batchIds.length === 0) return false;
+
+    const tDir = resolveTasksDir(base, mid, sid) ?? slicePath;
+    const existingSummaries = new Set(
+      resolveTaskFiles(tDir, "SUMMARY").map((f) =>
+        f.replace(/-SUMMARY\.md$/i, "").toUpperCase(),
+      ),
+    );
+
+    for (const tid of batchIds) {
+      if (!existingSummaries.has(tid.toUpperCase())) return false;
+    }
+    return true;
+  }
+
+  if (unitType === "gate-evaluate") {
+    const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
+    if (!mid || !sid || !batchPart) return false;
+
+    const plusIdx = batchPart.indexOf("+");
+    if (plusIdx === -1) return true;
+
+    const gateIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
+    if (gateIds.length === 0) return true;
+
+    try {
+      if (!isDbAvailable()) return false;
+      const pending = getPendingGatesForTurn(mid, sid, "gate-evaluate");
+      const pendingIds = new Set<string>(pending.map((g) => g.gate_id));
+      for (const gid of gateIds) {
+        if (pendingIds.has(gid)) return false;
+      }
+    } catch (err) {
+      logWarning("recovery", `gate-evaluate DB check failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return true;
+  }
+
+  if (unitType === "research-slice" && unitId.endsWith("/parallel-research")) {
+    const { milestone: mid } = parseUnitId(unitId);
+    if (!mid) return false;
+
+    const blockerPath = resolveExpectedArtifactPath(unitType, unitId, base);
+    if (blockerPath && existsSync(blockerPath)) {
+      return true;
+    }
+
+    const roadmapFile = resolveExpectedArtifactPath("plan-milestone", mid, base);
+    if (!roadmapFile || !existsSync(roadmapFile)) {
+      logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap missing`);
+      return false;
+    }
+    try {
+      const roadmap = parseRoadmapForRecovery(readFileSync(roadmapFile, "utf-8"));
+      const milestoneResearchFile = resolveExpectedArtifactPath("research-milestone", mid, base);
+      const hasMilestoneResearch = !!milestoneResearchFile && existsSync(milestoneResearchFile);
+      for (const slice of roadmap.slices) {
+        if (slice.done) continue;
+        if (hasMilestoneResearch && slice.id === "S01") continue;
+        const depsComplete = (slice.depends ?? []).every((depId) => {
+          const summaryPath = resolveExpectedArtifactPath("complete-slice", `${mid}/${depId}`, base);
+          return !!summaryPath && existsSync(summaryPath);
+        });
+        if (!depsComplete) continue;
+        if (!resolveExistingSliceResearchPath(base, mid, slice.id)) {
+          logWarning("recovery", `verify-fail ${unitType} ${unitId}: slice ${slice.id} missing RESEARCH`);
+          return false;
+        }
+      }
+      return true;
+    } catch (err) {
+      logWarning("recovery", `parallel-research verification failed: ${err instanceof Error ? err.message : String(err)}`);
+      return false;
+    }
+  }
+
+  const artifactBase = resolveArtifactVerificationBase(unitId, base);
+  let absPath = resolveExpectedArtifactPath(unitType, unitId, artifactBase);
+  if (!absPath || !existsSync(absPath)) {
+    const projectRoot = resolve(resolveWorktreeProjectRoot(artifactBase));
+    if (projectRoot && projectRoot !== artifactBase) {
+      const projectPath = resolveExpectedArtifactPath(unitType, unitId, projectRoot);
+      if (projectPath && existsSync(projectPath)) {
+        absPath = projectPath;
+      }
+    }
+  }
+  if (!absPath) {
+    logWarning("recovery", `verify-fail ${unitType} ${unitId}: resolveExpectedArtifactPath returned null (no artifact contract registered for this unit type)`);
+    return false;
+  }
+  if (!existsSync(absPath)) {
+    const worktreeFailure = diagnoseWorktreeIntegrityFailure(artifactBase);
+    if (worktreeFailure) {
+      logError("recovery", `${worktreeFailure} Unit: ${unitType} ${unitId}.`);
+      return false;
+    }
+    logWarning("recovery", `verify-fail ${unitType} ${unitId}: existsSync false for ${absPath}`);
+    return false;
+  }
+
+  if (unitType === "validate-milestone") {
+    const validationContent = readFileSync(absPath, "utf-8");
+    if (!isValidationTerminal(validationContent)) {
+      logWarning("recovery", `verify-fail ${unitType} ${unitId}: validation not terminal (len=${validationContent.length}) at ${absPath}`);
+      return false;
+    }
+  }
+
+  if (unitType === "run-uat") {
+    const assessmentContent = readFileSync(absPath, "utf-8");
+    if (!hasVerdict(assessmentContent)) {
+      logWarning("recovery", `verify-fail ${unitType} ${unitId}: assessment missing verdict at ${absPath}`);
+      return false;
+    }
+  }
+
+  if (unitType === "plan-milestone") {
+    try {
+      const roadmap = parseRoadmapForRecovery(readFileSync(absPath, "utf-8"));
+      if (roadmap.slices.length === 0) {
+        logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap has zero slices at ${absPath}`);
+        return false;
+      }
+    } catch (err) {
+      logWarning("recovery", `plan-milestone roadmap verification failed: ${err instanceof Error ? err.message : String(err)}`);
+      return false;
+    }
+  }
+
+  if (unitType === "plan-slice") {
+    const { milestone: mid, slice: sid } = parseUnitId(unitId);
+    if (mid && sid) {
+      try {
+        let taskIds: string[] | null = null;
+        let dbPrimary = false;
+        if (isDbAvailable()) {
+          const refreshed = refreshWorkflowDatabaseFromDisk();
+          if (refreshed) {
+            const tasks = getSliceTasks(mid, sid);
+            if (tasks.length > 0) {
+              taskIds = tasks.map(t => t.id);
+              dbPrimary = true;
+            }
+          }
+        }
+
+        if (!taskIds) {
+          const planContent = readFileSync(absPath, "utf-8");
+          const hasCheckboxTask = /^\s*- \[[xX ]\] \*\*T\d+/m.test(planContent);
+          const hasHeadingTask = /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
+          if (!hasCheckboxTask && !hasHeadingTask) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
+            return false;
+          }
+          const plan = parseLegacyPlan(planContent);
+          if (plan.tasks.length > 0) taskIds = plan.tasks.map((t: { id: string }) => t.id);
+        }
+
+        if (taskIds && taskIds.length > 0) {
+          const tasksDir = join(dirname(absPath), "tasks");
+          if (existsSync(tasksDir)) {
+            for (const tid of taskIds) {
+              const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
+              if (!existsSync(taskPlanFile)) {
+                logWarning("recovery", `verify-fail ${unitType} ${unitId}: task plan missing ${taskPlanFile}`);
+                return false;
+              }
+            }
+          } else if (!dbPrimary && !absPath.replace(/\\/g, "/").includes(`.gsd/${LAYOUT_SEGMENTS.level1}`)) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: tasks dir missing at ${tasksDir}`);
+            return false;
+          }
+        }
+      } catch (err) {
+        logWarning("recovery", `plan-slice task plan verification failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+
+  if (unitType === "execute-task") {
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (mid && sid && tid) {
+      const dbTask = getTask(mid, sid, tid);
+      if (dbTask) {
+        if (dbTask.status !== "complete" && dbTask.status !== "done" && !hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) {
+          return false;
+        }
+      } else if (!isDbAvailable()) {
+        if (!hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) return false;
+      } else {
+        return false;
+      }
+    }
+  }
+
+  if (unitType === "complete-slice") {
+    const { milestone: mid, slice: sid } = parseUnitId(unitId);
+    if (mid && sid) {
+      const uatPath = resolveSliceFile(base, mid, sid, "UAT")
+        ?? join(base, relSliceFile(base, mid, sid, "UAT"));
+      if (!existsSync(uatPath)) return false;
+
+      const dbSlice = getSlice(mid, sid);
+      if (dbSlice) {
+        if (dbSlice.status !== "complete") return false;
+      } else if (!isDbAvailable()) {
+        const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
+        if (roadmapFile && existsSync(roadmapFile)) {
+          try {
+            const roadmapContent = readFileSync(roadmapFile, "utf-8");
+            const roadmap = parseRoadmapForRecovery(roadmapContent);
+            const slice = roadmap.slices.find((s) => s.id === sid);
+            if (slice && !slice.done) return false;
+          } catch (e) {
+            logWarning("recovery", `roadmap parse failed: ${(e as Error).message}`);
+            return false;
+          }
+        }
+      }
+    }
+  }
+
+  if (unitType === "complete-milestone") {
+    const { milestone: mid } = parseUnitId(unitId);
+    if (!mid) return false;
+    const closeoutProof = proveMilestoneCloseout(mid, {
+      refreshFromDisk: true,
+      summaryArtifactBasePath: artifactBase,
+      implementationEvidence: {
+        basePath: base,
+        requirement: "not-absent",
+      },
+    });
+    if (!closeoutProof.ok) {
+      if (!isDbAvailable() && closeoutProof.reason === "db-unavailable") {
+        const summaryOutcome = classifyMilestoneSummaryContent(readFileSync(absPath, "utf-8"));
+        return summaryOutcome !== "failure" && hasImplementationArtifacts(base, mid) !== "absent";
+      }
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/resources/extensions/gsd/auto/dispatch-history.ts

@@ -82,6 +82,19 @@ export interface DispatchHistoryOptions {
    */
   resolveScopeId: () => string | null;
   windowSize?: number;
+  /**
+   * Session-level trace_id used to scope `rehydrate()` to the CURRENT session
+   * so stale finalize-retry entries from PREVIOUS sessions don't fire
+   * detectStuck Rule 1 on the first advance of a new session — killing
+   * auto-mode before any new dispatch runs (#852). When provided, only
+   * dispatches recorded with this trace_id are returned by the DB query;
+   * a brand-new session trace_id that has never been written to unit_dispatches
+   * returns 0 rows, giving a clean stuck window on session start.
+   *
+   * The unscoped (no resolveTraceId) path is preserved for callers without a
+   * session context so existing behaviour for those paths is unchanged.
+   */
+  resolveTraceId?: () => string | null;
 }
 
 /**
@@ -137,7 +150,12 @@ export function createDispatchHistory(options: DispatchHistoryOptions): Dispatch
       const scopeId = options.resolveScopeId();
       if (!scopeId) return 0;
       try {
-        const persisted = getRecentUnitKeysForProjectRoot(scopeId, windowSize);
+        // Scope to the current session's trace_id when available (#852):
+        // a fresh session UUID that has never been written to unit_dispatches
+        // returns 0 rows so prior-session failures don't pre-populate the
+        // stuck window and immediately block the new session.
+        const traceId = options.resolveTraceId?.() ?? undefined;
+        const persisted = getRecentUnitKeysForProjectRoot(scopeId, windowSize, traceId);
         if (persisted.length === 0) return 0;
         const rebuilt: WindowEntry[] = [];
         for (const { key } of persisted) {

package/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -52,6 +52,7 @@ export type PauseAutoUnitIdentity = {
 
 export interface PauseAutoOptions {
   expectedCurrentUnit?: PauseAutoUnitIdentity | null;
+  abortActiveTurn?: boolean;
 }
 
 type PauseAutoFn = (