gsd-pi 2.76.0-dev.fe143342a → 2.77.0-dev.538325aea

package/dist/resources/extensions/gsd/pre-execution-checks.js

@@ -281,6 +281,15 @@ function extractPathFromAnnotation(raw) {
     if (backtickMatch) {
         return backtickMatch[2].trim();
     }
+    // Strip leading/trailing double or single quotes wrapping the whole value.
+    // Plan documents sometimes emit `"src/foo.ts"` or `'src/bar.ts'` as input
+    // annotations. Stripping the wrapper allows the inner path to be checked
+    // correctly instead of producing a false-positive "file not found" error
+    // for a literal string with quote characters in it (#3747).
+    const quoteMatch = trimmed.match(/^(["'])([^"']+)\1$/);
+    if (quoteMatch) {
+        return quoteMatch[2].trim();
+    }
     const annotatedMatch = trimmed.match(/^(.+?)\s+[—–-]\s+.+$/);
     if (annotatedMatch) {
         const prefix = annotatedMatch[1].trim();
@@ -343,13 +352,19 @@ function containsGlobPattern(candidate) {
 }
 /**
  * Build a set of files that will be created by tasks up to (but not including) taskIndex.
+ * Also includes outputs of completed tasks at any position — a completed task has already
+ * run and its outputs are available regardless of sequence position or disk state (#4071).
  * All paths are normalized for consistent comparison.
  */
 function getExpectedOutputsUpTo(tasks, taskIndex) {
     const outputs = new Set();
-    for (let i = 0; i < taskIndex; i++) {
-        for (const file of tasks[i].expected_output) {
-            outputs.add(normalizeFilePath(file));
+    for (let i = 0; i < tasks.length; i++) {
+        const task = tasks[i];
+        // Include prior tasks (i < taskIndex) OR completed tasks at any position
+        if (i < taskIndex || task.status === "completed") {
+            for (const file of task.expected_output) {
+                outputs.add(normalizeFilePath(file));
+            }
         }
     }
     return outputs;
@@ -426,8 +441,14 @@ export function checkTaskOrdering(tasks, basePath) {
         const task = tasks[i];
         for (const file of task.expected_output) {
             const normalizedFile = normalizeFilePath(file);
-            if (!fileCreators.has(normalizedFile)) {
-                fileCreators.set(normalizedFile, { taskId: task.id, index: i, originalPath: file });
+            const existing = fileCreators.get(normalizedFile);
+            if (!existing || (!existing.completed && task.status === "completed")) {
+                fileCreators.set(normalizedFile, {
+                    taskId: task.id,
+                    index: i,
+                    originalPath: file,
+                    completed: task.status === "completed",
+                });
             }
         }
     }
@@ -451,7 +472,11 @@ export function checkTaskOrdering(tasks, basePath) {
             const creator = fileCreators.get(normalizedFile);
             const absolutePath = resolve(basePath, normalizedFile);
             const existsOnDisk = existsSync(absolutePath);
-            if (creator && creator.index > i && !existsOnDisk) {
+            // Skip if the creating task has already completed — its output is available
+            // regardless of disk state (e.g. file was a temp artifact cleaned up after
+            // the task ran, or a replan introduced a new earlier-sequence task that
+            // reads this pre-execution output). (#4071)
+            if (creator && creator.index > i && !existsOnDisk && !creator.completed) {
                 // Task reads file that is created later — impossible ordering
                 results.push({
                     category: "file",

package/dist/resources/extensions/gsd/prompts/discuss-headless.md

@@ -162,6 +162,10 @@ Preserve the specification's exact terminology, emphasis, and specific framing.
 6. For each architectural or pattern decision, call `gsd_decision_save` — the tool auto-assigns IDs and regenerates `.gsd/DECISIONS.md` automatically.
 7. {{commitInstruction}}
 
+### Ready-phrase pre-condition (NON-BYPASSABLE)
+
+Before emitting the ready phrase, verify in the CURRENT turn that you have written `.gsd/PROJECT.md`, `.gsd/REQUIREMENTS.md`, `{{contextPath}}`, and called `gsd_plan_milestone`. If any is missing, **STOP** — emit the missing tool calls in this same turn. The system rejects premature ready signals and retries are capped.
+
 After writing the files, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
 
 ### Multi-Milestone
@@ -234,6 +238,10 @@ For single-milestone projects, do NOT write this file.
 
 7. {{multiMilestoneCommitInstruction}}
 
+### Ready-phrase pre-condition (NON-BYPASSABLE)
+
+Before emitting the ready phrase, verify in the CURRENT turn that you have written `.gsd/PROJECT.md`, `.gsd/REQUIREMENTS.md`, the primary `CONTEXT.md`, called `gsd_plan_milestone` for the primary milestone, and written `.gsd/DISCUSSION-MANIFEST.json` with `gates_completed === total`. If any is missing, **STOP** — emit the missing tool calls in this same turn. The system rejects premature ready signals and retries are capped.
+
 After writing the files, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
 
 ## Critical Rules

package/dist/resources/extensions/gsd/prompts/discuss.md

@@ -339,7 +339,20 @@ These sections are in addition to whatever other context the discussion surfaced
 6. For each architectural or pattern decision made during discussion, call `gsd_decision_save` — the tool auto-assigns IDs and regenerates `.gsd/DECISIONS.md` automatically.
 7. {{commitInstruction}}
 
-After writing the files, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
+### Ready-phrase pre-condition (NON-BYPASSABLE)
+
+Before emitting the ready phrase, verify in the CURRENT turn that you have:
+
+- [ ] Written `.gsd/PROJECT.md` (step 2)
+- [ ] Written `.gsd/REQUIREMENTS.md` (step 3)
+- [ ] Written `{{contextPath}}` (step 4)
+- [ ] Called `gsd_plan_milestone` (step 5)
+
+If ANY box is unchecked, **STOP**. Do NOT emit the ready phrase. Emit the missing tool calls in this same turn. The system detects missing artifacts and will reject premature ready signals — you will be asked again and retries are capped.
+
+Do not announce the ready phrase as something you are "about to" do. Do not narrate "now writing the files" as a substitute for actually writing them. The ready phrase is a post-write signal, not an intent signal.
+
+After completing steps 1–7 above, say exactly: "Milestone {{milestoneId}} ready." — nothing else. Auto-mode will start automatically.
 
 ### Multi-Milestone
 
@@ -418,6 +431,20 @@ For single-milestone projects, do NOT write this file — it is only for multi-m
 
 7. {{multiMilestoneCommitInstruction}}
 
-After writing the files, say exactly: "Milestone M001 ready." — nothing else. Auto-mode will start automatically.
+### Ready-phrase pre-condition (NON-BYPASSABLE)
+
+Before emitting the ready phrase, verify in the CURRENT turn that you have:
+
+- [ ] Written `.gsd/PROJECT.md` (Phase 1)
+- [ ] Written `.gsd/REQUIREMENTS.md` (Phase 1)
+- [ ] Written primary-milestone `CONTEXT.md` (Phase 2)
+- [ ] Called `gsd_plan_milestone` for the primary milestone (Phase 2)
+- [ ] Written `.gsd/DISCUSSION-MANIFEST.json` with `gates_completed === total` (Phase 3)
+
+If ANY box is unchecked, **STOP**. Do NOT emit the ready phrase. Emit the missing tool calls in this same turn. The system detects missing artifacts and will reject premature ready signals — you will be asked again and retries are capped.
+
+Do not announce the ready phrase as something you are "about to" do. Do not narrate "now writing the files" as a substitute for actually writing them. The ready phrase is a post-write signal, not an intent signal.
+
+After completing all phases above, say exactly: "Milestone M001 ready." — nothing else. Auto-mode will start automatically.
 
 {{inlinedTemplates}}

package/dist/resources/extensions/gsd/prompts/parallel-research-slices.md

@@ -15,8 +15,11 @@ Dispatch ALL slices simultaneously using the `subagent` tool in **parallel mode*
 1. Call `subagent` with `tasks: [...]` containing one entry per slice below
 2. Wait for ALL subagents to complete
 3. Verify each slice's RESEARCH file was written (check the `.gsd/{{mid}}/` directory)
-4. If any subagent failed to write its RESEARCH file, re-run it individually
-5. Report which slices completed research and which (if any) failed
+4. If a subagent failed to write its RESEARCH file, retry it **once** individually
+5. If it fails a second time, write a partial RESEARCH file for that slice with a `## BLOCKER` section explaining the failure — do NOT retry again
+6. Report which slices completed research and which (if any) needed a blocker note
+
+**Important**: Each failed slice gets exactly one retry. After that, write the blocker and move on. Never retry the same slice more than once.
 
 ## Subagent Prompts
 

package/dist/resources/extensions/gsd/prompts/system.md

@@ -213,6 +213,7 @@ Fix the root cause, not symptoms. When applying a temporary mitigation, label it
 - State uncertainty plainly: "Not sure this handles X - testing it." No performed confidence, no hedging paragraphs.
 - All user-visible narration must be grammatical English. Do not emit compressed planner notes like "Need inspect X" or "Maybe read Y first". If it would look acceptable in a commit comment or standup note, it's acceptable here.
 - When debugging, stay curious. Problems are puzzles. Say what's interesting about the failure before reaching for fixes.
+- After completing a task, give a brief completion summary and present 2-4 contextual next-step options as a numbered list (the last option is always "Other"). This reduces cognitive load by letting the user pick rather than formulate what's next. Omit the numbered list when the response must follow a strict output format (JSON, patches, commit messages, structured data).
 
 Good narration: "Three existing handlers follow a middleware pattern - using that instead of a custom wrapper."
 Good narration: "Tests pass. Running slice-level verification."

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

@@ -3,9 +3,17 @@
  * Tracks every bash command, file write, and file edit during a unit execution.
  * Evidence is compared against LLM completion claims in evidence-cross-ref.ts.
  *
+ * Evidence is persisted to .gsd/safety/evidence-<mid>-<sid>-<tid>.json so it
+ * survives session restarts (pause/resume, crash recovery). On unit start,
+ * call resetEvidence() then loadEvidenceFromDisk(). On every new tool call,
+ * saveEvidenceToDisk() is called automatically by recordToolCall/recordToolResult.
+ *
  * Follows the same module-level Map pattern as auto-tool-tracking.ts.
  * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
  */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, } from "node:fs";
+import { join, dirname } from "node:path";
+import { randomBytes } from "node:crypto";
 // ─── Module State ───────────────────────────────────────────────────────────
 let unitEvidence = [];
 // ─── Public API ─────────────────────────────────────────────────────────────
@@ -27,6 +35,94 @@ export function getFilePaths() {
         .filter((e) => e.kind === "write" || e.kind === "edit")
         .map(e => e.path);
 }
+// ─── Persistence (Bug #4385 — evidence must survive session restarts) ────────
+/**
+ * Build the path for the evidence JSON file for a given unit.
+ * Lives under .gsd/safety/ which is gitignored and session-scoped.
+ */
+function evidencePath(basePath, milestoneId, sliceId, taskId) {
+    return join(basePath, ".gsd", "safety", `evidence-${milestoneId}-${sliceId}-${taskId}.json`);
+}
+/**
+ * Validate that a parsed value is an array of EvidenceEntry objects.
+ * Rejects corrupt / schema-mismatch data rather than letting it poison state.
+ */
+function isEvidenceArray(data) {
+    if (!Array.isArray(data))
+        return false;
+    return data.every((e) => {
+        if (e === null || typeof e !== "object")
+            return false;
+        const rec = e;
+        if (typeof rec.toolCallId !== "string")
+            return false;
+        if (typeof rec.timestamp !== "number")
+            return false;
+        if (rec.kind === "bash") {
+            return (typeof rec.command === "string" &&
+                typeof rec.exitCode === "number" &&
+                typeof rec.outputSnippet === "string");
+        }
+        if (rec.kind === "write" || rec.kind === "edit") {
+            return typeof rec.path === "string";
+        }
+        return false;
+    });
+}
+/**
+ * Persist the current in-memory evidence to disk so it survives a session
+ * restart. Called from saveEvidenceToDisk after recordToolCall/recordToolResult.
+ * Non-fatal — persistence failures must never break unit execution.
+ */
+export function saveEvidenceToDisk(basePath, milestoneId, sliceId, taskId) {
+    try {
+        const path = evidencePath(basePath, milestoneId, sliceId, taskId);
+        mkdirSync(dirname(path), { recursive: true });
+        const tmp = `${path}.tmp.${randomBytes(4).toString("hex")}`;
+        writeFileSync(tmp, JSON.stringify(unitEvidence, null, 2) + "\n", "utf-8");
+        renameSync(tmp, path);
+    }
+    catch {
+        // Non-fatal — don't let persistence failures break unit execution
+    }
+}
+/**
+ * Load persisted evidence from disk into the in-memory array.
+ * Call after resetEvidence() on session resume to restore context for a
+ * partially-executed unit. If the file does not exist (fresh unit), this
+ * is a no-op — getEvidence() will return [] which is correct.
+ */
+export function loadEvidenceFromDisk(basePath, milestoneId, sliceId, taskId) {
+    try {
+        const path = evidencePath(basePath, milestoneId, sliceId, taskId);
+        if (!existsSync(path))
+            return;
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (isEvidenceArray(parsed)) {
+            unitEvidence = parsed;
+        }
+    }
+    catch {
+        // Non-fatal — corrupt / missing file is treated as empty evidence
+    }
+}
+/**
+ * Delete the persisted evidence file for a unit after it has been fully
+ * processed. Prevents stale evidence from affecting future retries of
+ * the same unit ID.
+ */
+export function clearEvidenceFromDisk(basePath, milestoneId, sliceId, taskId) {
+    try {
+        const path = evidencePath(basePath, milestoneId, sliceId, taskId);
+        if (existsSync(path)) {
+            unlinkSync(path);
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+}
 // ─── Recording (called from register-hooks.ts) ─────────────────────────────
 /**
  * Record a tool call at dispatch time (before execution).

package/dist/resources/extensions/gsd/safety/file-change-validator.js

@@ -4,13 +4,18 @@
  *
  * Uses tasks.expected_output (DB column, populated from per-task ## Expected Output)
  * and tasks.files (from slice PLAN.md - Files: subline) as the expected set.
- * Compares against git diff HEAD~1 --name-only after auto-commit.
+ * Compares against `git diff-tree --root --no-commit-id -r --name-only HEAD` after auto-commit.
+ * Using diff-tree --root handles initial commits, shallow clones, and merge commits correctly
+ * (Bug #4385 — git diff HEAD~1 failed on initial commits).
  *
  * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
  */
+import { createRequire } from "node:module";
 import { execFileSync } from "node:child_process";
 import { normalizePlannedFileReference } from "../files.js";
 import { logWarning } from "../workflow-logger.js";
+const _require = createRequire(import.meta.url);
+const picomatch = _require("picomatch");
 // ─── Public API ─────────────────────────────────────────────────────────────
 /**
  * Validate file changes after auto-commit for an execute-task unit.
@@ -20,7 +25,7 @@ import { logWarning } from "../workflow-logger.js";
  * @param expectedOutput - JSON array from tasks.expected_output DB column
  * @param plannedFiles - JSON array from tasks.files DB column
  */
-export function validateFileChanges(basePath, expectedOutput, plannedFiles) {
+export function validateFileChanges(basePath, expectedOutput, plannedFiles, fileChangeAllowlist = []) {
     const allExpected = new Set([...expectedOutput, ...plannedFiles]);
     // If no expected files were planned, skip validation
     if (allExpected.size === 0)
@@ -33,8 +38,11 @@ export function validateFileChanges(basePath, expectedOutput, plannedFiles) {
     const projectFiles = actualFiles.filter(f => !f.startsWith(".gsd/") && !f.startsWith(".gsd\\"));
     // Normalize expected paths (strip leading ./ or /)
     const normalizedExpected = new Set([...allExpected].map((f) => normalizePlannedFileReference(f).replace(/^\.\//, "").replace(/^\//, "")));
-    // Compute symmetric difference
-    const unexpectedFiles = projectFiles.filter(f => !normalizedExpected.has(f));
+    // Build allowlist matchers once (dot: true so patterns like `**/.hidden` work).
+    const allowlistMatchers = fileChangeAllowlist.map(p => picomatch(p, { dot: true }));
+    const isAllowlisted = (f) => allowlistMatchers.some(m => m(f));
+    // Compute symmetric difference, excluding allowlisted files
+    const unexpectedFiles = projectFiles.filter(f => !normalizedExpected.has(f) && !isAllowlisted(f));
     const missingFiles = [...normalizedExpected].filter(f => !projectFiles.includes(f));
     const violations = [];
     for (const f of unexpectedFiles) {

package/dist/resources/extensions/gsd/safety/safety-harness.js

@@ -23,6 +23,7 @@ const DEFAULTS = {
     checkpoints: true,
     auto_rollback: false,
     timeout_scale_cap: 6,
+    file_change_allowlist: [],
 };
 // ─── Public API ─────────────────────────────────────────────────────────────
 /**
@@ -42,6 +43,9 @@ export function resolveSafetyHarnessConfig(raw) {
         checkpoints: typeof raw.checkpoints === "boolean" ? raw.checkpoints : DEFAULTS.checkpoints,
         auto_rollback: typeof raw.auto_rollback === "boolean" ? raw.auto_rollback : DEFAULTS.auto_rollback,
         timeout_scale_cap: typeof raw.timeout_scale_cap === "number" ? raw.timeout_scale_cap : DEFAULTS.timeout_scale_cap,
+        file_change_allowlist: Array.isArray(raw.file_change_allowlist)
+            ? raw.file_change_allowlist.filter((p) => typeof p === "string")
+            : DEFAULTS.file_change_allowlist,
     };
 }
 /**
@@ -56,7 +60,7 @@ export function isHarnessEnabled(raw) {
     return DEFAULTS.enabled;
 }
 // ─── Re-exports ─────────────────────────────────────────────────────────────
-export { resetEvidence, getEvidence, getBashEvidence, getFilePaths, recordToolCall, recordToolResult, } from "./evidence-collector.js";
+export { resetEvidence, getEvidence, getBashEvidence, getFilePaths, recordToolCall, recordToolResult, saveEvidenceToDisk, loadEvidenceFromDisk, clearEvidenceFromDisk, } from "./evidence-collector.js";
 export { classifyCommand } from "./destructive-guard.js";
 export { validateFileChanges } from "./file-change-validator.js";
 export { crossReferenceEvidence } from "./evidence-cross-ref.js";

package/dist/resources/extensions/gsd/token-counter.js

@@ -16,7 +16,11 @@ async function getEncoder() {
     try {
         // @ts-ignore — tiktoken may not have type declarations in extensions tsconfig
         const tiktoken = await import("tiktoken");
-        encoder = tiktoken.encoding_for_model("gpt-4o");
+        // Use cl100k_base — the most conservative and broadly compatible BPE encoding.
+        // It is shared by GPT-3.5/GPT-4 and gives a safer (larger) estimate than
+        // gpt-4o's o200k_base encoding, which produces fewer tokens for the same text
+        // and would cause context windows for non-OpenAI providers to be under-counted.
+        encoder = tiktoken.get_encoding("cl100k_base");
         return encoder;
     }
     catch {
@@ -24,19 +28,32 @@ async function getEncoder() {
         return null;
     }
 }
-export async function countTokens(text) {
+/**
+ * Count tokens in `text` using tiktoken (cl100k_base) when available.
+ *
+ * When tiktoken is not loaded, falls back to a provider-aware character-ratio
+ * estimate via `estimateTokensForProvider`. Passing `provider` is recommended
+ * so the heuristic fallback is as accurate as possible.
+ */
+export async function countTokens(text, provider) {
     const enc = await getEncoder();
     if (enc) {
         const tokens = enc.encode(text);
         return tokens.length;
     }
-    return Math.ceil(text.length / 4);
+    return estimateTokensForProvider(text, provider ?? "unknown");
 }
-export function countTokensSync(text) {
+/**
+ * Synchronous token count — only accurate after `initTokenCounter()` resolves.
+ *
+ * Before init, or when tiktoken is unavailable, falls back to a provider-aware
+ * character-ratio estimate. Passing `provider` is recommended.
+ */
+export function countTokensSync(text, provider) {
     if (encoder) {
         return encoder.encode(text).length;
     }
-    return Math.ceil(text.length / 4);
+    return estimateTokensForProvider(text, provider ?? "unknown");
 }
 export async function initTokenCounter() {
     const enc = await getEncoder();

package/dist/resources/extensions/gsd/tools/complete-milestone.js

@@ -6,7 +6,7 @@
  * for recovery, and invalidates caches.
  */
 import { join } from "node:path";
-import { mkdirSync } from "node:fs";
+import { mkdirSync, existsSync } from "node:fs";
 import { transaction, getMilestone, getMilestoneSlices, getSliceTasks, updateMilestoneStatus, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { isClosedStatus } from "../status-guards.js";
@@ -141,15 +141,21 @@ export async function handleCompleteMilestone(params, basePath) {
         mkdirSync(manualDir, { recursive: true });
         summaryPath = join(manualDir, `${params.milestoneId}-SUMMARY.md`);
     }
-    try {
-        await saveFile(summaryPath, summaryMd);
-    }
-    catch (renderErr) {
-        // Disk render failed — roll back DB status so state stays consistent
-        logWarning("tool", `complete_milestone — disk render failed, rolling back DB status: ${renderErr.message}`);
-        updateMilestoneStatus(params.milestoneId, 'active', null);
-        invalidateStateCache();
-        return { error: `disk render failed: ${renderErr.message}` };
+    // Guard (#4598): if SUMMARY.md already exists on disk, do not overwrite it.
+    // This handles re-dispatch scenarios (DB/disk state divergence) where a prior
+    // completion already wrote the file. Overwriting would silently destroy the
+    // richer content the agent produced during the original completion run.
+    if (!existsSync(summaryPath)) {
+        try {
+            await saveFile(summaryPath, summaryMd);
+        }
+        catch (renderErr) {
+            // Disk render failed — roll back DB status so state stays consistent
+            logWarning("tool", `complete_milestone — disk render failed, rolling back DB status: ${renderErr.message}`);
+            updateMilestoneStatus(params.milestoneId, 'active', null);
+            invalidateStateCache();
+            return { error: `disk render failed: ${renderErr.message}` };
+        }
     }
     // Invalidate all caches
     invalidateStateCache();

package/dist/resources/extensions/gsd/uok/plan-v2.js

@@ -22,6 +22,23 @@ function hasFileContent(path) {
         return false;
     }
 }
+function getArtifactLookupBases(basePath) {
+    const bases = [basePath];
+    const projectRoot = process.env.GSD_PROJECT_ROOT;
+    if (projectRoot && projectRoot.trim().length > 0 && projectRoot !== basePath) {
+        bases.push(projectRoot);
+    }
+    return bases;
+}
+function hasMilestoneFileContent(basePath, milestoneId, suffix) {
+    const bases = getArtifactLookupBases(basePath);
+    for (const candidateBase of bases) {
+        if (hasFileContent(resolveMilestoneFile(candidateBase, milestoneId, suffix))) {
+            return true;
+        }
+    }
+    return false;
+}
 function countSliceResearchArtifacts(basePath, milestoneId, slices) {
     let count = 0;
     for (const slice of slices) {
@@ -43,9 +60,9 @@ export function compileUnitGraphFromState(basePath, state) {
     const slices = getMilestoneSlices(mid).sort((a, b) => Number(a.sequence ?? 0) - Number(b.sequence ?? 0));
     const nodes = [];
     const clarifyRoundLimit = PLAN_V2_CLARIFY_ROUND_LIMIT;
-    const draftContextIncluded = hasFileContent(resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT"));
-    const finalizedContextIncluded = hasFileContent(resolveMilestoneFile(basePath, mid, "CONTEXT"));
-    const researchSynthesized = hasFileContent(resolveMilestoneFile(basePath, mid, "RESEARCH"))
+    const draftContextIncluded = hasMilestoneFileContent(basePath, mid, "CONTEXT-DRAFT");
+    const finalizedContextIncluded = hasMilestoneFileContent(basePath, mid, "CONTEXT");
+    const researchSynthesized = hasMilestoneFileContent(basePath, mid, "RESEARCH")
         || countSliceResearchArtifacts(basePath, mid, slices) > 0;
     if (isExecutionEntryPhase(state.phase) && !finalizedContextIncluded) {
         const reason = draftContextIncluded

package/dist/resources/extensions/gsd/worktree-resolver.js

@@ -16,8 +16,30 @@ import { existsSync, unlinkSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { debugLog } from "./debug-logger.js";
-import { MergeConflictError } from "./git-service.js";
 import { emitJournalEvent } from "./journal.js";
+// ─── Path Helpers ──────────────────────────────────────────────────────────
+/**
+ * Worktree marker segment — present in any path produced by worktreePath().
+ * Used to strip the worktree suffix and recover the project root (#3729).
+ */
+const WORKTREE_MARKER = "/.gsd/worktrees/";
+/**
+ * Resolve the project root from session path state.
+ *
+ * Prefers `originalBasePath` (always the project root when set), but falls
+ * back to `basePath` when `originalBasePath` is falsy (e.g. fresh AutoSession
+ * with default empty string). If `basePath` itself is inside a worktree
+ * directory (contains `/.gsd/worktrees/`), strip that suffix to recover the
+ * actual project root — preventing double-nested worktree paths (#3729).
+ */
+export function resolveProjectRoot(originalBasePath, basePath) {
+    let resolved = originalBasePath || basePath;
+    const markerIdx = resolved.indexOf(WORKTREE_MARKER);
+    if (markerIdx !== -1) {
+        resolved = resolved.slice(0, markerIdx);
+    }
+    return resolved;
+}
 // ─── WorktreeResolver ──────────────────────────────────────────────────────
 export class WorktreeResolver {
     s;
@@ -33,11 +55,11 @@ export class WorktreeResolver {
     }
     /** Original project root — always the non-worktree path. */
     get projectRoot() {
-        return this.s.originalBasePath || this.s.basePath;
+        return resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
     }
     /** Path for auto.lock file — same as the old lockBase(). */
     get lockPath() {
-        return this.s.originalBasePath || this.s.basePath;
+        return resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
     }
     // ── Private Helpers ────────────────────────────────────────────────────
     rebuildGitService() {
@@ -99,7 +121,10 @@ export class WorktreeResolver {
             });
             return;
         }
-        const basePath = this.s.originalBasePath || this.s.basePath;
+        // Resolve the project root for worktree operations via shared helper.
+        // Handles the case where originalBasePath is falsy and basePath is itself
+        // a worktree path — prevents double-nested worktree paths (#3729).
+        const basePath = resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
         debugLog("WorktreeResolver", {
             action: "enterMilestone",
             milestoneId,
@@ -429,11 +454,13 @@ export class WorktreeResolver {
                     /* best-effort */
                 }
             }
-            // Re-throw MergeConflictError so the auto loop can detect real code
-            // conflicts and stop instead of retrying forever (#2330).
-            if (err instanceof MergeConflictError) {
-                throw err;
-            }
+            // Restore state before re-throwing so callers always get a consistent
+            // session (#4380).
+            this.restoreToProjectRoot();
+            // Re-throw: MergeConflictError stops the auto loop (#2330); non-conflict
+            // errors (permission denied, filesystem failures) must also propagate so
+            // broken states are diagnosable (#4380).
+            throw err;
         }
         // Always restore basePath and rebuild — whether merge succeeded or failed
         this.restoreToProjectRoot();
@@ -500,6 +527,8 @@ export class WorktreeResolver {
                 error: msg,
             });
             ctx.notify(`Milestone merge failed (branch mode): ${msg}`, "warning");
+            // Re-throw all errors so callers can apply their own recovery logic (#4380).
+            throw err;
         }
     }
     // ── Merge and Enter Next ───────────────────────────────────────────────
@@ -516,7 +545,18 @@ export class WorktreeResolver {
             currentMilestoneId,
             nextMilestoneId,
         });
-        this.mergeAndExit(currentMilestoneId, ctx);
+        try {
+            this.mergeAndExit(currentMilestoneId, ctx);
+        }
+        catch (err) {
+            // mergeAndExit emits a warning and restores state when it fails during
+            // merge/cleanup. But if it throws before recovery runs (e.g., in
+            // validateMilestoneId or emitJournalEvent), basePath won't be restored
+            // to projectRoot — re-throw so we don't enter the next milestone with
+            // the current one unmerged.
+            if (this.s.basePath !== this.projectRoot)
+                throw err;
+        }
         this.enterMilestone(nextMilestoneId, ctx);
     }
 }

package/dist/resources/extensions/mcp-client/index.js

@@ -398,7 +398,7 @@ export default function (pi) {
     pi.on("session_shutdown", async () => {
         await closeAll();
     });
-    pi.on("session_switch", async () => {
+    pi.on("session_before_switch", async () => {
         await closeAll();
         configCache = null;
     });

package/dist/resources/extensions/ollama/index.js

@@ -63,12 +63,11 @@ async function probeAndRegister(pi) {
     // so the "ollama" fallback is harmless. For cloud endpoints (OLLAMA_HOST pointing
     // to ollama.com or a remote instance), OLLAMA_API_KEY is picked up here.
     pi.registerProvider("ollama", {
-        authMode: "apiKey",
+        // authMode and isReady removed from ProviderConfig in pi 0.67.2
         apiKey: process.env.OLLAMA_API_KEY ?? "ollama",
         baseUrl,
         api: "ollama-chat",
         streamSimple: streamOllamaChat,
-        isReady: () => true,
         models: models.map((m) => ({
             id: m.id,
             name: m.name,

package/dist/resources/extensions/ollama/ollama-chat-provider.js

@@ -126,7 +126,7 @@ export function streamOllamaChat(model, context, options) {
                         processChunks(thinkParser.flush());
                     endBlock();
                     output.usage = buildUsage(chunk);
-                    output.inferenceMetrics = extractMetrics(chunk);
+                    // inferenceMetrics removed from AssistantMessage in pi 0.67.2
                     // Preserve "toolUse" if tool calls were processed
                     if (output.stopReason !== "toolUse") {
                         output.stopReason = mapStopReason(chunk.done_reason);
@@ -145,6 +145,7 @@ export function streamOllamaChat(model, context, options) {
 }
 // ─── Request building ───────────────────────────────────────────────────────
 function buildRequest(model, context, options) {
+    // providerOptions removed from Model in pi 0.67.2; cast via unknown for extension data
     const ollamaOpts = (model.providerOptions ?? {});
     const request = {
         model: model.id,
@@ -319,20 +320,9 @@ function buildUsage(chunk) {
         cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
     };
 }
-function extractMetrics(chunk) {
-    if (!chunk.eval_duration && !chunk.total_duration)
-        return undefined;
-    const evalCount = chunk.eval_count ?? 0;
-    const evalDurationNs = chunk.eval_duration ?? 0;
-    const evalDurationMs = evalDurationNs / 1e6;
-    const tokensPerSecond = evalDurationNs > 0 ? evalCount / (evalDurationNs / 1e9) : 0;
-    return {
-        tokensPerSecond,
-        totalDurationMs: (chunk.total_duration ?? 0) / 1e6,
-        evalDurationMs,
-        promptEvalDurationMs: (chunk.prompt_eval_duration ?? 0) / 1e6,
-    };
-}
+// extractMetrics removed: InferenceMetrics was removed from pi-ai in pi 0.67.2
+// and inferenceMetrics was removed from AssistantMessage. Ollama perf metrics
+// (tokensPerSecond, evalDurationMs, etc.) are no longer surfaced via this path.
 // ─── Stream lifecycle helpers ───────────────────────────────────────────────
 // Replicated from openai-shared.ts (not exported from @gsd/pi-ai)
 function buildInitialOutput(model) {