@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/dist/resources/extensions/gsd/prompts/quick-task.md

@@ -37,4 +37,4 @@ You are executing a GSD quick task — a lightweight, focused unit of work outsi
 - <what was tested/verified>
 ```
 
-When done, say: "Quick task {{taskNum}} complete." Say this exactly once — if you already said it in a prior message, do not repeat it.
+When done, say: "Quick task {{taskNum}} closeout submitted." Do not say the task is complete. Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/reactive-execute.md

@@ -10,7 +10,7 @@ You are executing **multiple tasks in parallel** for this slice. The task graph
 
 **Critical rule:** Use the `subagent` tool in **parallel mode** to dispatch all ready tasks simultaneously. Each subagent gets a task-specific execution packet (task plan + dependency carry-forward + completion contract) and is responsible for its own implementation, verification, task summary, and completion tool calls. The parent batch agent orchestrates, verifies, and records failures only when a dispatched task failed before it could leave its own summary behind.
 
-**Tool call format:** Call `subagent` with `tasks: [...]` as a **native JSON array** — one object per ready task. Do NOT JSON.stringify the array into a string; the tool validates that `tasks` is an array, and a serialized string will be rejected with "must be array".
+**Tool call format:** Call `subagent` with `tasks: [...]` as a **native JSON array** — one object per ready task. Each task object MUST include `cwd: "{{workingDirectory}}"` so child agents inherit the milestone worktree, not the project root. Do NOT JSON.stringify the array into a string; the tool validates that `tasks` is an array, and a serialized string will be rejected with "must be array".
 
 ## Task Dependency Graph
 
@@ -24,7 +24,7 @@ You are executing **multiple tasks in parallel** for this slice. The task graph
 
 ## Execution Protocol
 
-1. **Dispatch all ready tasks** using `subagent` in parallel mode. Call `subagent` with `tasks: [{ agent: "worker", task: "<prompt>" }, ...]` — one object per ready task. Each subagent prompt is provided below.
+1. **Dispatch all ready tasks** using `subagent` in parallel mode. Call `subagent` with `tasks: [{ agent: "worker", cwd: "{{workingDirectory}}", task: "<prompt>" }, ...]` — one object per ready task. Each subagent prompt is provided below.
 2. **Wait for all subagents** to complete.
 3. **Verify each dispatched task's outputs** — check that expected files were created/modified, that verification commands pass where applicable, and that each task wrote its own `T##-SUMMARY.md`.
 4. **Do not rewrite successful task summaries or duplicate completion tool calls.** Treat a subagent-written summary as authoritative for that task.

package/dist/resources/extensions/gsd/prompts/run-uat.md

@@ -10,6 +10,8 @@ If any inlined plan, summary, verification command, or prior artifact names an a
 
 All relevant context has been preloaded below. Start working immediately without re-reading these files.
 
+If a `.gsd/**` or `.gsd/**/*` glob returns no matches, treat that as a possible symlink-backed traversal limitation; do not infer that the GSD harness is missing. Use the preloaded UAT context and direct `.gsd/...` file paths named in this prompt instead.
+
 {{inlinedContext}}
 
 {{skillActivation}}
@@ -100,4 +102,8 @@ checks: [{
 
 **You MUST call `gsd_uat_result_save` before finishing. Do not write the assessment file directly, and do not call `gsd_summary_save` as a substitute.**
 
-When done, say: "UAT {{sliceId}} complete." Say this exactly once — if you already said it in a prior message, do not repeat it.
+### Closeout messaging (auto-mode)
+
+You submit UAT results; **GSD auto-mode** decides when UAT is actually **done**. Never say "UAT {{sliceId}} complete" in this unit — not even after `gsd_uat_result_save` succeeds. GSD announces completion only after post-unit verification passes.
+
+When done, say: "UAT {{sliceId}} results submitted." Do not say UAT is complete. Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/triage-captures.md

@@ -65,4 +65,4 @@ Classify each capture as one of:
 
 **Important:** Do NOT execute any resolutions. Only classify and update CAPTURES.md. Resolution execution happens separately (in auto-mode dispatch or manually by the user).
 
-When done, say: "Triage complete." Say this exactly once — if you already said it in a prior message, do not repeat it.
+When done, say: "Triage closeout submitted." Do not say triage is complete — GSD announces completion only after post-unit verification passes. Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/workflow-start.md

@@ -25,4 +25,5 @@ Follow the workflow defined below. Execute each phase in order, completing one b
 3. **Atomic commits.** Commit working code after each meaningful change. Use conventional commit format: `<type>(<scope>): <description>`.
 4. **Verify before shipping.** Run the project's test suite and build before marking the workflow complete.
 5. **Decision gates, not ceremony.** After each phase, summarize what changed. For low/medium complexity, ask for confirmation only when the next phase depends on a real user choice or external approval. For high complexity, confirm before proceeding to each new phase.
-6. **Stay focused.** This is a {{complexity}}-complexity workflow. Match your ceremony level to the task — don't over-engineer or under-deliver.
+6. **Persist workflow state.** If the artifact directory contains `STATE.json`, update it after each phase: mark the finished phase `completed`, mark the next phase `active`, set `currentPhase` to the active phase index, and refresh `updatedAt`. When every phase is completed, set `completedAt` to the completion timestamp.
+7. **Stay focused.** This is a {{complexity}}-complexity workflow. Match your ceremony level to the task — don't over-engineer or under-deliver.

package/dist/resources/extensions/gsd/provider-error-guidance.js

@@ -44,11 +44,35 @@ function defaultAlternateModel(provider, modelId) {
     }
     return undefined;
 }
+function isGeminiCliDeprecatedError(errorMsg) {
+    return (/IneligibleTierError/i.test(errorMsg)
+        || /UNSUPPORTED_CLIENT/i.test(errorMsg)
+        || /no longer supported for Gemini Code Assist for individuals/i.test(errorMsg)
+        || /migrate to the Antigravity suite/i.test(errorMsg));
+}
+function resolveGeminiCliDeprecationGuidance(input) {
+    const { provider, modelId, unitType } = input;
+    const modelLabel = provider && modelId ? `${provider}/${modelId}` : modelId ?? provider ?? "google-gemini-cli";
+    const unitSuffix = unitType ? ` during ${unitType}` : "";
+    return {
+        summary: `Provider error on ${modelLabel}${unitSuffix}. ` +
+            "Google no longer supports Gemini CLI for individual-tier users — migrate to Antigravity CLI.",
+        steps: [
+            "Install Antigravity CLI: curl -fsSL https://antigravity.google/cli/install.sh | bash",
+            "Run `agy` in a terminal and complete authentication.",
+            "In GSD, run `/login` and select Antigravity, or restart GSD to auto-migrate when `agy` is on PATH.",
+            "Run /gsd next to resume the paused unit.",
+        ],
+    };
+}
 /**
  * Build concrete next steps for a provider/model rejection pause.
  */
 export function resolveProviderErrorGuidance(input) {
     const { errorMsg, provider, modelId, unitType, preferencesPath, hasConfiguredFallbacks, } = input;
+    if (isGeminiCliDeprecatedError(errorMsg)) {
+        return resolveGeminiCliDeprecationGuidance(input);
+    }
     const modelLabel = provider && modelId ? `${provider}/${modelId}` : modelId ?? provider ?? "current model";
     const phaseKey = unitTypeToPrefsPhaseKey(unitType);
     const prefsFile = preferencesPath ?? ".gsd/PREFERENCES.md";

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

@@ -21,6 +21,7 @@ import { join, dirname } from "node:path";
 import { gsdRoot, normalizeRealPath } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { markWorkerStoppingByPid } from "./db/auto-workers.js";
+import { logWarning } from "./workflow-logger.js";
 const _require = createRequire(import.meta.url);
 // ─── Module State ───────────────────────────────────────────────────────────
 /** Release function from proper-lockfile — calling it releases the OS lock. */
@@ -175,12 +176,12 @@ function createLockCompromisedHandler(lockFilePath) {
     return () => {
         const elapsed = Date.now() - _lockAcquiredAt;
         if (elapsed < 1_800_000) {
-            process.stderr.write(`[gsd] Lock heartbeat caught up after ${Math.round(elapsed / 1000)}s — long LLM call, no action needed.\n`);
+            logWarning("session", `Lock heartbeat caught up after ${Math.round(elapsed / 1000)}s — long LLM call, no action needed.`);
             return;
         }
         const existing = readExistingLockDataWithRetry(lockFilePath);
         if (existing && existing.pid === process.pid) {
-            process.stderr.write(`[gsd] Lock heartbeat mismatch after ${Math.round(elapsed / 1000)}s — lock file still owned by PID ${process.pid}, treating as false positive.\n`);
+            logWarning("session", `Lock heartbeat mismatch after ${Math.round(elapsed / 1000)}s — lock file still owned by PID ${process.pid}, treating as false positive.`);
             return;
         }
         _lockCompromised = true;
@@ -404,7 +405,7 @@ export function getSessionLockStatus(basePath) {
             try {
                 const result = acquireSessionLock(basePath);
                 if (result.acquired) {
-                    process.stderr.write(`[gsd] Lock recovered after onCompromised — lock file PID matched, re-acquired.\n`);
+                    logWarning("session", "Lock recovered after onCompromised — lock file PID matched, re-acquired.");
                     return { valid: true, recovered: true };
                 }
             }

package/dist/resources/extensions/gsd/skill-activation.js

@@ -108,11 +108,8 @@ function formatSkillActivationBlock(skillNames) {
     const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
     if (safe.length === 0)
         return "";
-    // Use explicit parameter syntax so LLMs pass { skill: "..." } instead of { name: "..." }.
-    // The function-call-like syntax `Skill('name')` led LLMs to infer a positional
-    // parameter name, causing tool validation failures — see #2224.
-    const calls = safe.map(name => `Call Skill({ skill: '${name}' })`).join('. ');
-    return `<skill_activation>${calls}.</skill_activation>`;
+    const reads = safe.map(name => `Read the installed '${name}' skill file from <available_skills>`).join(". ");
+    return `<skill_activation>${reads}.</skill_activation>`;
 }
 /**
  * Manifest-driven recommendations block — informational only, does NOT
@@ -132,7 +129,7 @@ function formatSkillRecommendationsBlock(unitType, skillNames) {
     const safe = skillNames.filter(name => SAFE_SKILL_NAME.test(name));
     if (safe.length === 0)
         return "";
-    return `<skill_recommendations unit="${unitType}">For this unit type, also consider invoking: ${safe.join(", ")}. Use Skill({ skill: 'name' }) when relevant — these are recommendations, not requirements.</skill_recommendations>`;
+    return `<skill_recommendations unit="${unitType}">For this unit type, also consider reading these installed skill files from <available_skills>: ${safe.join(", ")}. These are recommendations, not requirements.</skill_recommendations>`;
 }
 export function buildSkillActivationBlock(params) {
     const prefs = params.preferences ?? loadEffectiveGSDPreferences(params.base)?.preferences;

package/dist/resources/extensions/gsd/state-reconciliation/drift/artifact-db.js

@@ -300,6 +300,17 @@ function quarantineSliceDir(record, basePath) {
     const target = join(quarantineDir, `${basename(record.sliceDir)}-${stamp}`);
     renameSync(record.sliceDir, target);
 }
+export function completedMilestoneReopenedGuidance(record) {
+    const when = record.completedDispatchAt ?? "time unknown";
+    const intro = `Milestone ${record.milestoneId} has completed closeout dispatch history (${when}) ` +
+        `but DB status is still ${record.dbStatus}.`;
+    if (isClosedStatus(record.dbStatus)) {
+        return (`${intro} Use gsd_milestone_reopen for ${record.milestoneId} to redo this milestone, then run /gsd next.`);
+    }
+    return (`${intro} Finish closeout with \`/gsd dispatch complete-milestone ${record.milestoneId}\`, ` +
+        `review with \`/gsd status ${record.milestoneId}\`, then run /gsd next. ` +
+        "Running /gsd next again before fixing this will pause immediately.");
+}
 function diskSliceIdDivergenceGuidance(record) {
     const quarantineExample = `.gsd/quarantine/milestones/${record.milestoneId}/slices/${record.sliceId}-manual-review`;
     return (`Slice ID drift in ${record.milestoneId}: ${record.reason}. ` +
@@ -326,9 +337,7 @@ export function repairArtifactDbDrift(record, ctx) {
         return;
     }
     if (record.kind === "completed-milestone-reopened") {
-        throw new Error(`Milestone ${record.milestoneId} has completed complete-milestone dispatch history` +
-            ` (${record.completedDispatchAt ?? "time unknown"}) but the DB status is ${record.dbStatus}. ` +
-            "Refusing to plan it again without an explicit reopen or recovery.");
+        throw new Error(completedMilestoneReopenedGuidance(record));
     }
     throw new Error(`Artifact/DB status drift in ${record.milestoneId}` +
         `${record.sliceId ? `/${record.sliceId}` : ""}` +
@@ -343,9 +352,7 @@ export function describeArtifactDbDriftBlocker(record) {
         return diskSliceIdDivergenceGuidance(record);
     }
     if (record.kind === "completed-milestone-reopened") {
-        return (`Milestone ${record.milestoneId} has completed complete-milestone dispatch history` +
-            ` (${record.completedDispatchAt ?? "time unknown"}) but the DB status is ${record.dbStatus}. ` +
-            "Refusing to plan it again without an explicit reopen or recovery.");
+        return completedMilestoneReopenedGuidance(record);
     }
     return (`Artifact/DB status drift in ${record.milestoneId}` +
         `${record.sliceId ? `/${record.sliceId}` : ""}` +

package/dist/resources/extensions/gsd/state.js

@@ -23,7 +23,7 @@ import { logWarning } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
 import { detectPendingEscalation } from './escalation.js';
 import { isTerminalMilestoneSummaryContent } from './milestone-summary-classifier.js';
-import { isDbAvailable, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, getRequirementCounts, getLatestAssessmentByScope, getPendingGateCountForTurn, } from './gsd-db.js';
+import { isDbAvailable, getAllMilestones, getMilestone, getSlicesByMilestoneIds, getSliceTasks, getReplanHistory, getSlice, getRequirementCounts, getLatestAssessmentByScope, getPendingGateCountForTurn, } from './gsd-db.js';
 import { wasWorkflowDatabaseOpenAttempted } from './db-workspace.js';
 import { formatCompletePhaseNextAction, countUnmappedActiveRequirements } from './requirements-backlog.js';
 import { classifyMilestoneReadiness, readinessNeedsDiscussion, } from './milestone-readiness.js';
@@ -366,12 +366,16 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
     let activeMilestoneFound = false;
     let activeMilestoneHasDraft = false;
     let firstDeferredQueuedShell = null;
+    const activeMilestoneIds = milestones
+        .filter((m) => !parkedMilestoneIds.has(m.id))
+        .map((m) => m.id);
+    const slicesByMilestone = getSlicesByMilestoneIds(activeMilestoneIds);
     for (const m of milestones) {
         if (parkedMilestoneIds.has(m.id)) {
             registry.push({ id: m.id, title: stripMilestonePrefix(m.title) || m.id, status: 'parked' });
             continue;
         }
-        const slices = getMilestoneSlices(m.id);
+        const slices = slicesByMilestone.get(m.id) ?? [];
         // DB-authoritative completeness (#4179): only trust completeMilestoneIds,
         // which is itself derived from DB status. SUMMARY-file presence alone must
         // not imply completion.

package/dist/resources/extensions/gsd/tool-surface-readiness.js

@@ -1,7 +1,10 @@
 // Project/App: gsd-pi
 // File Purpose: Tool Contract module's runtime face — verify the live SDK tool surface covers a Unit's required workflow tools.
+import { testMcpServerConnection } from "../mcp-client/manager.js";
 import { mcpToolMatchesBaseName } from "./mcp-tool-name.js";
 import { getRequiredWorkflowToolsForUnit } from "./unit-tool-contracts.js";
+import { recordWorkflowMcpProbe, WORKFLOW_MCP_PROBE_TIMEOUT_MS, } from "./workflow-mcp-readiness-cache.js";
+import { resolveWorkflowMcpProjectRoot } from "./workflow-mcp.js";
 import { isWorkflowToolSurfaceName } from "./workflow-tool-surface.js";
 /**
  * Stable phrase recognized as transient by auto-tool-tracking's
@@ -11,20 +14,73 @@ import { isWorkflowToolSurfaceName } from "./workflow-tool-surface.js";
 export const TOOL_SURFACE_NOT_READY = "workflow tool surface not ready";
 /** MCP server statuses that will not self-heal within the session. */
 const TERMINAL_MCP_SERVER_STATUSES = new Set(["failed", "needs-auth", "disabled"]);
-/**
- * Verify the live tool surface observed at SDK session init covers the Unit's
- * required workflow tools. Complements the static pre-dispatch gate
- * (getWorkflowTransportSupportError), which only proves the MCP launch config
- * is discoverable — the workflow server connects asynchronously after session
- * start, so the static gate cannot see whether the tools actually registered.
- *
- * Returns a transient, recovery-classifiable error (kind tool-unavailable →
- * retry) when the workflow server failed or has not yet registered a required
- * tool, so dispatch aborts before the first model turn instead of letting the
- * Unit improvise around "No such tool available". Returns null when no
- * workflow server is part of this session (native tool path), when the Unit
- * requires no workflow tools, or when the surface is ready.
- */
+export const DEFAULT_WORKFLOW_MCP_PREFLIGHT_TIMEOUT_MS = 30_000;
+export const DEFAULT_WORKFLOW_MCP_PREFLIGHT_POLL_MS = 200;
+const RUN_UAT_PREFLIGHT_TIMEOUT_MS = 90_000;
+function resolveWorkflowMcpPreflightTimeoutMs(unitType) {
+    if (unitType === "run-uat")
+        return RUN_UAT_PREFLIGHT_TIMEOUT_MS;
+    return DEFAULT_WORKFLOW_MCP_PREFLIGHT_TIMEOUT_MS;
+}
+export function probeCoversRequiredWorkflowTools(tools, required) {
+    return required.every((tool) => tools.some((name) => name === tool || mcpToolMatchesBaseName(name, tool)));
+}
+export async function awaitWorkflowMcpToolRegistration(input) {
+    const { unitType, workflowServerName, projectRoot } = input;
+    if (!unitType || !workflowServerName)
+        return null;
+    const required = getRequiredWorkflowToolsForUnit(unitType).filter(isWorkflowToolSurfaceName);
+    if (required.length === 0)
+        return null;
+    const probe = input.probe ?? (async (serverName, root) => {
+        const result = await testMcpServerConnection(serverName, {
+            projectDir: resolveWorkflowMcpProjectRoot(root),
+            timeoutMs: WORKFLOW_MCP_PROBE_TIMEOUT_MS,
+        });
+        return { ok: result.ok, tools: result.tools };
+    });
+    const deadline = Date.now() + (input.timeoutMs ?? resolveWorkflowMcpPreflightTimeoutMs(unitType));
+    const pollMs = input.pollMs ?? DEFAULT_WORKFLOW_MCP_PREFLIGHT_POLL_MS;
+    while (Date.now() < deadline) {
+        throwIfAborted(input.signal);
+        const result = await probe(workflowServerName, projectRoot);
+        throwIfAborted(input.signal);
+        if (result.ok && probeCoversRequiredWorkflowTools(result.tools, required)) {
+            recordWorkflowMcpProbe(projectRoot, workflowServerName, result.tools);
+            return null;
+        }
+        await sleep(pollMs, input.signal);
+    }
+    return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" did not register required tools before session start: ${required.join(", ")}`;
+}
+function makeAbortError() {
+    const error = new Error("AbortError: The operation was aborted");
+    error.name = "AbortError";
+    return error;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw makeAbortError();
+}
+function sleep(ms, signal) {
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timeout);
+            reject(makeAbortError());
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+/** Brief pause after a successful preflight before SDK query (race with MCP attach). */
+export const POST_PREFLIGHT_SDK_SETTLE_MS = 750;
+export const POST_PREFLIGHT_READINESS_RETRY_DELAYS_MS = [
+    1_000, 2_000, 3_000, 5_000, 8_000, 10_000, 15_000, 15_000, 15_000, 15_000,
+];
 export function getToolSurfaceReadinessError(input) {
     const { unitType, workflowServerName, observation } = input;
     if (!unitType || !workflowServerName)
@@ -33,24 +89,20 @@ export function getToolSurfaceReadinessError(input) {
     if (required.length === 0)
         return null;
     const server = observation.mcpServers.find((entry) => entry.name === workflowServerName);
-    if (!server) {
-        return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" is absent from the init surface (not yet connected): ${required.join(", ")}`;
-    }
-    // The SDK does not wait for MCP servers before init — a still-connecting
-    // server reports "pending" there routinely, then registers within seconds,
-    // usually well before the Unit's first workflow tool call. Aborting on
-    // "pending" would fail the common healthy session, so it passes through;
-    // a genuine miss after pass-through still surfaces in-session as
-    // "No such tool available" and classifies tool-unavailable → bounded retry.
-    // Only statuses that cannot self-heal abort here.
-    if (server.status !== "connected" && !TERMINAL_MCP_SERVER_STATUSES.has(server.status)) {
-        return null;
+    if (server && TERMINAL_MCP_SERVER_STATUSES.has(server.status)) {
+        const missing = required.filter((tool) => !observation.tools.some((name) => name === tool || mcpToolMatchesBaseName(name, tool)));
+        const tools = missing.length > 0 ? missing : required;
+        return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" status is "${server.status}" (terminal) — cannot register: ${tools.join(", ")}`;
     }
     const missing = required.filter((tool) => !observation.tools.some((name) => name === tool || mcpToolMatchesBaseName(name, tool)));
-    if (missing.length === 0)
+    if (missing.length === 0) {
         return null;
-    const serverDetail = server.status === "connected"
-        ? `MCP server "${workflowServerName}" is connected but has not registered`
-        : `MCP server "${workflowServerName}" status is "${server.status}" and it has not registered`;
-    return `${TOOL_SURFACE_NOT_READY} for ${unitType}: ${serverDetail}: ${missing.join(", ")}`;
+    }
+    if (!server) {
+        return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" is absent from the init surface (not yet connected): ${missing.join(", ")}`;
+    }
+    if (server.status !== "connected") {
+        return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" status is "${server.status}" (not yet connected): ${missing.join(", ")}`;
+    }
+    return `${TOOL_SURFACE_NOT_READY} for ${unitType}: MCP server "${workflowServerName}" is connected but has not registered: ${missing.join(", ")}`;
 }

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

@@ -8,6 +8,7 @@
  * Projection write failures are reported as stale projections and do not roll
  * back committed DB state.
  */
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { isClosedStatus } from "../status-guards.js";
 import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, updateTaskStatus, deleteVerificationEvidence, saveGateResult, getPendingGatesForTurn, } from "../gsd-db.js";
@@ -29,6 +30,35 @@ import { buildEscalationArtifact, writeEscalationArtifact } from "../escalation.
 function taskSummaryPath(basePath, milestoneId, sliceId, taskId) {
     return join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks", `${taskId}-SUMMARY.md`);
 }
+async function repairMissingTaskSummaryProjection(artifactBasePath, taskRow) {
+    const summaryPath = taskSummaryPath(artifactBasePath, taskRow.milestone_id, taskRow.slice_id, taskRow.id);
+    const summaryMd = renderSummaryContent(taskRow, taskRow.slice_id, taskRow.milestone_id, []);
+    let stale = false;
+    try {
+        await saveFile(summaryPath, summaryMd);
+        await renderPlanCheckboxes(artifactBasePath, taskRow.milestone_id, taskRow.slice_id);
+    }
+    catch (renderErr) {
+        stale = true;
+        logWarning("projection", `complete_task missing-summary repair failed for ${taskRow.milestone_id}/${taskRow.slice_id}/${taskRow.id}`, { error: renderErr.message });
+    }
+    invalidateStateCache();
+    clearPathCache();
+    clearParseCache();
+    try {
+        await flushWorkflowProjections(artifactBasePath, { milestoneId: taskRow.milestone_id });
+    }
+    catch (projErr) {
+        logWarning("tool", `complete-task repair projection warning: ${projErr.message}`);
+    }
+    try {
+        writeManifest(artifactBasePath);
+    }
+    catch (mfErr) {
+        logWarning("tool", `complete-task repair manifest warning: ${mfErr.message}`);
+    }
+    return { summaryPath, stale };
+}
 /**
  * Map an execute-task-owned gate id to the CompleteTaskParams field whose
  * presence drives `pass` vs. `omitted`. Keep in lockstep with the gates
@@ -136,6 +166,7 @@ export async function handleCompleteTask(params, basePath) {
     const completedAt = new Date().toISOString();
     let guardError = null;
     let summaryMd = "";
+    let repairTaskSummaryRow = null;
     // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
     // Building the artifact runs the full shape validation (2-4 options, unique
     // ids, recommendation references a real id). If the payload is malformed
@@ -197,6 +228,12 @@ export async function handleCompleteTask(params, basePath) {
                 guardError = "__stale_duplicate__";
                 return;
             }
+            const existingSummaryPath = taskSummaryPath(artifactBasePath, params.milestoneId, params.sliceId, params.taskId);
+            if (existingTask.full_summary_md.trim() && !existsSync(existingSummaryPath)) {
+                repairTaskSummaryRow = existingTask;
+                guardError = "__repair_missing_summary__";
+                return;
+            }
             guardError = `task ${params.taskId} is already complete — use gsd_task_reopen first if you need to redo it`;
             return;
         }
@@ -252,6 +289,17 @@ export async function handleCompleteTask(params, basePath) {
             stale: true,
         };
     }
+    if (guardError === "__repair_missing_summary__" && repairTaskSummaryRow) {
+        const repair = await repairMissingTaskSummaryProjection(artifactBasePath, repairTaskSummaryRow);
+        return {
+            taskId: params.taskId,
+            sliceId: params.sliceId,
+            milestoneId: params.milestoneId,
+            summaryPath: repair.summaryPath,
+            duplicate: true,
+            ...(repair.stale ? { stale: true } : {}),
+        };
+    }
     if (guardError) {
         return { error: guardError };
     }
@@ -349,6 +397,20 @@ export async function handleCompleteTask(params, basePath) {
         }
     }
     else if (params.escalation && !escalationWriteEnabled) {
+        if (params.escalation.continueWithDefault === false) {
+            const msg = `complete-task received a hard-blocker escalation (continueWithDefault=false) but phases.mid_execution_escalation is disabled for ${params.milestoneId}/${params.sliceId}/${params.taskId}; reverting to pending instead of silently advancing.`;
+            logWarning("tool", msg);
+            try {
+                deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
+                updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
+                invalidateStateCache();
+                logWarning("tool", `complete-task rolled back DB completion for ${params.milestoneId}/${params.sliceId}/${params.taskId} because hard-blocker escalation handling is disabled; SUMMARY.md left on disk for retry.`);
+            }
+            catch (rollbackErr) {
+                logWarning("tool", `complete-task rollback failed after disabled hard-blocker escalation for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${rollbackErr.message}`);
+            }
+            return { error: msg };
+        }
         logWarning("tool", `complete-task received escalation payload but phases.mid_execution_escalation is not enabled; ignoring (${params.milestoneId}/${params.sliceId}/${params.taskId})`);
     }
     // Invalidate all caches

package/dist/resources/extensions/gsd/tools/exec-tool.js

@@ -1,10 +1,8 @@
 // Project/App: gsd-pi
 // File Purpose: Executor for the gsd_exec MCP tool.
 import { EXEC_DEFAULTS, runExecSandbox, } from "../exec-sandbox.js";
-import { realpathSync } from "node:fs";
-import path from "node:path";
 import { isContextModeEnabled } from "../preferences-types.js";
-import { projectRootFromWorktreePath } from "../worktree-root.js";
+import { bashReferencesProjectRootOutsideWorktree } from "../worktree-shell-guard.js";
 import { contextModeDisabledResult } from "./context-mode-tool-result.js";
 const UAT_EXEC_INTENTS = [
     "uat-artifact-check",
@@ -131,110 +129,6 @@ function rejectUatScript(script) {
 function isToolExecutionResult(value) {
     return typeof value === "object" && value !== null && Array.isArray(value.content);
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function normalizeScanPath(value) {
-    const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
-    return normalized.startsWith("/private/var/")
-        ? normalized.slice("/private".length)
-        : normalized;
-}
-function parseWorktreeBase(baseDir) {
-    const normalizedBase = normalizeScanPath(baseDir);
-    const originalRoot = projectRootFromWorktreePath(normalizedBase);
-    if (!originalRoot)
-        return null;
-    return { originalRoot, worktreeRoot: normalizedBase };
-}
-function pathInside(parent, target) {
-    const parentWithSep = parent.endsWith("/") ? parent : `${parent}/`;
-    return target === parent || target.startsWith(parentWithSep);
-}
-function comparablePathVariants(value) {
-    const variants = new Set();
-    const normalized = normalizeScanPath(path.resolve(value));
-    variants.add(normalized);
-    try {
-        variants.add(normalizeScanPath(realpathSync(normalized)));
-    }
-    catch {
-        // Nonexistent paths are still compared lexically.
-    }
-    if (normalized.startsWith("/private/var/")) {
-        variants.add(normalized.replace(/^\/private\/var\//, "/var/"));
-    }
-    else if (normalized.startsWith("/var/")) {
-        variants.add(`/private${normalized}`);
-    }
-    return [...variants];
-}
-function pathInsideAny(parents, targets) {
-    return targets.some((target) => parents.some((parent) => pathInside(parent, target)));
-}
-function stripWrappingQuotes(value) {
-    const trimmed = value.trim();
-    if (trimmed.length < 2)
-        return trimmed;
-    const first = trimmed[0];
-    const last = trimmed[trimmed.length - 1];
-    if ((first === "'" || first === '"' || first === "`") && last === first) {
-        return trimmed.slice(1, -1).trim();
-    }
-    return trimmed;
-}
-function extractPathLikeValues(script) {
-    const values = [];
-    const push = (candidate) => {
-        const cleaned = stripWrappingQuotes(candidate).trim();
-        if (!cleaned)
-            return;
-        values.push(cleaned);
-    };
-    const pushQuotedLiterals = (source, depth = 0) => {
-        for (const match of source.matchAll(/(["'`])((?:\\.|(?!\1).)*)\1/g)) {
-            push(match[2]);
-            if (depth < 2 && /["'`]/.test(match[2])) {
-                pushQuotedLiterals(match[2], depth + 1);
-            }
-        }
-    };
-    for (const match of script.matchAll(/(?:^|[;\n\r]|\&\&|\|\|)\s*cd\s+([^\n\r;|&]+)/g)) {
-        push(match[1]);
-    }
-    for (const match of script.matchAll(/process\.chdir\(\s*([^\n\r;]+?)\s*\)/g)) {
-        push(match[1]);
-        pushQuotedLiterals(match[1]);
-    }
-    pushQuotedLiterals(script);
-    return values;
-}
-function resolvesToOriginalRootOutsideWorktree(script, baseDir) {
-    const parsed = parseWorktreeBase(baseDir);
-    if (!parsed)
-        return false;
-    const normalizedWorktree = normalizeScanPath(path.resolve(parsed.worktreeRoot));
-    const normalizedOriginalRoot = normalizeScanPath(path.resolve(parsed.originalRoot));
-    const worktreeRoots = comparablePathVariants(normalizedWorktree);
-    const originalRoots = comparablePathVariants(normalizedOriginalRoot);
-    for (const value of extractPathLikeValues(script)) {
-        const resolved = comparablePathVariants(path.resolve(normalizedWorktree, value));
-        if (pathInsideAny(originalRoots, resolved) && !pathInsideAny(worktreeRoots, resolved)) {
-            return true;
-        }
-    }
-    return false;
-}
-function scriptReferencesOriginalRootFromWorktree(script, baseDir) {
-    const parsed = parseWorktreeBase(baseDir);
-    if (!parsed)
-        return false;
-    const normalizedScript = script.replace(/\\/g, "/");
-    return comparablePathVariants(parsed.originalRoot).some((originalRoot) => {
-        const originalRootPattern = new RegExp(`${escapeRegExp(originalRoot)}(?=$|[\\s'"\\\`;)&|<>]|/(?!\\.gsd(?:-worktrees|/worktrees)(?:/|$)))`);
-        return originalRootPattern.test(normalizedScript);
-    });
-}
 export async function executeGsdExec(params, deps) {
     if (!isEnabled(deps.preferences))
         return contextModeDisabledResult("gsd_exec");
@@ -247,8 +141,7 @@ export async function executeGsdExec(params, deps) {
     if (Buffer.byteLength(script, "utf8") > 200_000) {
         return paramError("script exceeds the 200 KB length limit");
     }
-    if (resolvesToOriginalRootOutsideWorktree(script, deps.baseDir)
-        || scriptReferencesOriginalRootFromWorktree(script, deps.baseDir)) {
+    if (bashReferencesProjectRootOutsideWorktree(script, deps.baseDir)) {
         return paramError("script references the original project root while running inside a milestone worktree; use the active worktree path or relative paths");
     }
     const opts = buildExecOptions(deps.baseDir, deps.preferences?.context_mode, { env: deps.env, now: deps.now, generateId: deps.generateId });