@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/dist/resources/extensions/gsd/auto-verification.js

@@ -9,7 +9,7 @@ import { isDbAvailable, getTask, getSliceTasks, getMilestoneSlices } from "./gsd
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { isClosedStatus } from "./status-guards.js";
 import { loadFile } from "./files.js";
-import { runVerificationGate, runVerificationGateForTargets, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
+import { runVerificationGate, runVerificationGateForTargets, formatFailureContext, formatFailureSignature, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
 import { logWarning } from "./workflow-logger.js";
 import { runPostExecutionChecks } from "./post-execution-checks.js";
@@ -686,10 +686,13 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
                 ctx.ui.notify(`Unit ${s.currentUnit.id} cost spike detected (${unitCostUsd.toFixed(2)} vs avg ${rollingAvgUsd.toFixed(2)}) during verification retry; keeping verification failure as the authoritative blocker.`, "warning");
             }
             const nextAttempt = attempt + 1;
+            const failureContext = verdict.failureContext || formatFailureContext(result);
+            const failureSignature = formatFailureSignature(result);
             s.verificationRetryCount.set(retryKey, nextAttempt);
             s.pendingVerificationRetry = {
                 unitId: s.currentUnit.id,
-                failureContext: verdict.failureContext || formatFailureContext(result),
+                failureContext,
+                ...(failureSignature ? { signature: failureSignature } : {}),
                 attempt: nextAttempt,
             };
             const failedCmds = result.checks

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

@@ -986,10 +986,10 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
     const branch = autoWorktreeBranch(milestoneId);
     const { preserveBranch = false, preserveWorktree = false } = opts;
     const previousCwd = safeCwd(originalBasePath);
+    let clearActiveWorkspace = true;
     // Wrap the entire teardown body in a single try/finally so activeWorkspace
-    // is ALWAYS cleared — even if process.chdir throws (e.g. originalBasePath
-    // was deleted before teardown ran). Previously the finally only covered
-    // removeWorktree, leaving the registry stale on a chdir failure (H3 fix).
+    // is cleared on completion or irrecoverable failure — even if process.chdir
+    // throws (e.g. originalBasePath was deleted before teardown ran).
     try {
         try {
             process.chdir(originalBasePath);
@@ -1026,17 +1026,23 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
         // 3. Remove the worktree unless this exit path explicitly preserves it
         //    (slice-parallel dispatch stops the parent loop but keeps the parent
         //    milestone worktree for restart/re-entry).
+        let worktreeRemoved = preserveWorktree;
         if (!preserveWorktree) {
-            removeWorktree(originalBasePath, milestoneId, {
+            worktreeRemoved = removeWorktree(originalBasePath, milestoneId, {
                 branch,
                 deleteBranch: !preserveBranch,
             });
+            if (!worktreeRemoved) {
+                logWarning("worktree", `Worktree removal aborted for ${milestoneId}; uncommitted work was preserved. ` +
+                    `Manual quarantine recovery may be needed before retrying teardown.`, { worktree: milestoneId });
+                clearActiveWorkspace = false;
+            }
         }
         // Verify cleanup succeeded — warn if the worktree directory is still on disk.
         // On Windows, bash-based cleanup can silently fail when paths contain
         // backslashes (#1436), leaving ~1 GB+ orphaned directories.
         const wtDir = worktreePath(originalBasePath, milestoneId);
-        if (!preserveWorktree && existsSync(wtDir)) {
+        if (!preserveWorktree && worktreeRemoved && existsSync(wtDir)) {
             logWarning("reconcile", `Worktree directory still exists after teardown: ${wtDir}. ` +
                 `This is likely an orphaned directory consuming disk space. ` +
                 `Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`, { worktree: milestoneId });
@@ -1057,10 +1063,12 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
         }
     }
     finally {
-        // Clear module state unconditionally — regardless of which step above
-        // failed. A stale activeWorkspace causes getActiveAutoWorktreeContext()
-        // to return wrong data for subsequent operations.
-        setActiveWorkspace(null);
+        // Clear module state when teardown completed or failed irrecoverably.
+        // When removeWorktree returns false (quarantine failure), preserve the
+        // registry so recovery logic still sees the active milestone worktree.
+        if (clearActiveWorkspace) {
+            setActiveWorkspace(null);
+        }
     }
 }
 /**
@@ -1491,15 +1499,28 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         catch (err) {
             logWarning("worktree", `clearProjectRootStateFiles failed during already-merged cleanup: ${err instanceof Error ? err.message : String(err)}`);
         }
+        let worktreeRemoved = true;
         try {
-            removeWorktree(originalBasePath_, milestoneId, {
+            worktreeRemoved = removeWorktree(originalBasePath_, milestoneId, {
                 branch: milestoneBranch,
                 deleteBranch: false,
             });
         }
         catch (err) {
+            worktreeRemoved = false;
             logWarning("worktree", `worktree removal failed: ${err instanceof Error ? err.message : String(err)}`);
         }
+        if (!worktreeRemoved) {
+            logWarning("worktree", `Skipping milestone branch deletion for ${milestoneBranch}; worktree removal was aborted to preserve uncommitted milestone work.`);
+            nudgeGitBranchCache(previousCwd);
+            try {
+                process.chdir(originalBasePath_);
+            }
+            catch (err) {
+                logWarning("worktree", `chdir to project root after already-merged cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return { commitMessage, pushed: false, prCreated: false, codeFilesChanged: true };
+        }
         try {
             nativeBranchDelete(originalBasePath_, milestoneBranch);
         }
@@ -1932,16 +1953,22 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     }
     const finalizeMilestoneCleanup = () => {
         // 12. Remove worktree directory first (must happen before branch deletion)
+        let worktreeRemoved = true;
         try {
-            removeWorktree(originalBasePath_, milestoneId, {
+            worktreeRemoved = removeWorktree(originalBasePath_, milestoneId, {
                 branch: milestoneBranch,
                 deleteBranch: false,
             });
         }
         catch (err) {
+            worktreeRemoved = false;
             // Best-effort -- worktree dir may already be gone
             logWarning("worktree", `worktree removal failed: ${err instanceof Error ? err.message : String(err)}`);
         }
+        if (!worktreeRemoved) {
+            logWarning("worktree", `Skipping milestone branch deletion for ${milestoneBranch}; worktree removal was aborted to preserve uncommitted milestone work.`);
+            return;
+        }
         // 13. Delete milestone branch (after worktree removal so ref is unlocked)
         try {
             nativeBranchDelete(originalBasePath_, milestoneBranch);

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

@@ -27,7 +27,7 @@ import { writeLock, clearLock, clearStaleWorkerLock, readCrashLock, isLockProces
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, loadEffectiveGSDPreferencesWithRegistry, resolveProfileAnchorProvider, getIsolationMode, resolveEffectiveUnitIsolationMode, } from "./preferences.js";
 import { playNotificationBell, sendDesktopNotification } from "./notifications.js";
-import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, resolveCompactionThresholdPercent, shouldRerootStepSessionForContext, } from "./auto-budget.js";
+import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, HARD_CONTEXT_REROOT_THRESHOLD_PERCENT, resolveCompactionThresholdPercent, shouldRerootStepSessionForContext, shouldWarnStepSessionForContext, } from "./auto-budget.js";
 import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, isDeterministicPolicyError, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { selectAndApplyModel, resolveModelId, clearToolBaseline } from "./auto-model-selection.js";
@@ -369,7 +369,7 @@ function getEffectiveUnitIsolationMode(basePath) {
  * running suspiciously long (e.g., a Bash command hung because `&` kept stdout open).
  */
 // Re-export budget utilities for external consumers
-export { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, getContextPauseAction, resolveCompactionThresholdPercent, shouldRerootStepSessionForContext, } from "./auto-budget.js";
+export { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, getContextPauseAction, resolveCompactionThresholdPercent, shouldRerootStepSessionForContext, shouldWarnStepSessionForContext, } from "./auto-budget.js";
 function closeOutSignalInterruptedUnit(currentBasePath) {
     const currentUnit = s.currentUnit;
     if (!currentUnit)
@@ -651,6 +651,11 @@ export function stopAutoRemote(projectRoot) {
  * The normal stop path stays SIGTERM-only so cooperative sessions can clean up;
  * this path is only for the explicit "Force start" action.
  */
+// Grace window between SIGTERM and SIGKILL so the target can run its cleanup
+// handler (lock release, DB snapshot flush, worktree teardown). Polled so a
+// process that exits early is not made to wait the full window.
+const FORCE_STOP_GRACE_MS = 3000;
+const FORCE_STOP_POLL_MS = 100;
 export function forceStopAutoRemote(projectRoot) {
     const lock = readCrashLock(projectRoot);
     if (!lock)
@@ -665,6 +670,14 @@ export function forceStopAutoRemote(projectRoot) {
     }
     try {
         process.kill(lock.pid, "SIGTERM");
+        // Poll for graceful exit before escalating. Synchronous sleep keeps this
+        // function sync for its callers (Atomics.wait times out with no notify).
+        const deadline = Date.now() + FORCE_STOP_GRACE_MS;
+        while (Date.now() < deadline) {
+            if (!isLockProcessAlive(lock))
+                break;
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, FORCE_STOP_POLL_MS);
+        }
         if (isLockProcessAlive(lock)) {
             process.kill(lock.pid, "SIGKILL");
         }
@@ -904,9 +917,10 @@ export async function rerootCommandSession(cmdCtx, workspaceRoot) {
     }
 }
 /**
- * After a completed step-mode unit, reclaim context headroom when usage is at
- * or above the compaction threshold. Writes a context-mode snapshot first, then
- * re-roots the visible command session while leaving the NEXT progress surface.
+ * After a completed step-mode unit, warn when usage reaches the configurable
+ * soft context threshold. At the fixed hard boundary, write a context-mode
+ * snapshot and re-root the visible command session while leaving the NEXT
+ * progress surface.
  */
 export async function maybeRerootStepSessionForHighContext(ctx, workspaceRoot, cmdCtx, originalBasePath) {
     if (!cmdCtx)
@@ -915,18 +929,24 @@ export async function maybeRerootStepSessionForHighContext(ctx, workspaceRoot, c
     const { loadEffectiveGSDPreferences } = await import("./preferences.js");
     const prefs = loadEffectiveGSDPreferences(workspaceRoot);
     const compactionThreshold = prefs?.preferences.context_management?.compaction_threshold_percent;
-    if (!shouldRerootStepSessionForContext(contextPercent, compactionThreshold)) {
+    const shouldWarn = shouldWarnStepSessionForContext(contextPercent, compactionThreshold);
+    const shouldReroot = shouldRerootStepSessionForContext(contextPercent);
+    if (!shouldWarn && !shouldReroot) {
+        return { rerooted: false };
+    }
+    const displayPercent = contextPercent.toFixed(1);
+    const thresholdDisplay = resolveCompactionThresholdPercent(compactionThreshold).toFixed(0);
+    if (!shouldReroot) {
+        ctx.ui.notify(`Step complete — context at ${displayPercent}% (soft threshold: ${thresholdDisplay}%). Use /compact when convenient; continuing in this session is still safe.`, "info");
         return { rerooted: false };
     }
     const { resolveWorktreeProjectRoot } = await import("./worktree-root.js");
     const snapshotBase = resolveWorktreeProjectRoot(workspaceRoot, originalBasePath);
     const { writeContextModeCompactionSnapshot } = await import("./context-mode-snapshot.js");
     await writeContextModeCompactionSnapshot(snapshotBase);
-    const displayPercent = contextPercent.toFixed(1);
-    const thresholdDisplay = resolveCompactionThresholdPercent(compactionThreshold).toFixed(0);
     const result = await rerootCommandSession(cmdCtx, workspaceRoot);
     if (result.status === "ok") {
-        ctx.ui.notify(`Step complete — context at ${displayPercent}% (threshold: ${thresholdDisplay}%). Fresh session ready for /gsd next.`, "info");
+        ctx.ui.notify(`Step complete — context at ${displayPercent}% (hard threshold: ${HARD_CONTEXT_REROOT_THRESHOLD_PERCENT}%). Fresh session ready for /gsd next.`, "info");
         return { rerooted: true };
     }
     if (result.status === "cancelled") {
@@ -1545,7 +1565,7 @@ export function _selectStopAutoWorktreeExit(args) {
 /**
  * Pause auto-mode without destroying state. Context is preserved.
  * The user can interact with the agent, then `/gsd auto` resumes
- * from disk state. Called when the user presses Escape during auto-mode.
+ * from disk state. Called when the user presses Escape or runs `/gsd pause`.
  */
 export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
     if (!s.active)
@@ -1564,6 +1584,8 @@ export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
     ].filter((path) => Boolean(path)));
     s.active = false;
     s.paused = true;
+    if (options.abortActiveTurn && ctx && !ctx.isIdle())
+        ctx.abort();
     clearUnitTimeout();
     stopAutoCommandPolling();
     // Flush queued follow-up messages (#3512).

package/dist/resources/extensions/gsd/bootstrap/core-session-tools.js

@@ -0,0 +1,39 @@
+// Project/App: gsd-pi
+// File Purpose: Canonical core session tool surface shared by auto-mode scoping and loop guards.
+/** Base tools available during auto-mode execution before unit-specific GSD tools are added. */
+export const MINIMAL_AUTO_BASE_TOOL_NAMES = [
+    "ask_user_questions",
+    "bash",
+    "bg_shell",
+    "edit",
+    "find",
+    "glob",
+    "grep",
+    "fetch_page",
+    "search-the-web",
+    "ls",
+    "read",
+    "subagent",
+    "write",
+    "ToolSearch",
+];
+/** Tools excluded from the high per-turn loop-guard cap (strict or orchestration). */
+const NON_REPEATABLE_FROM_MINIMAL_BASE = new Set([
+    "ask_user_questions",
+    "subagent",
+    "ToolSearch",
+]);
+/** Additional core tools not in MINIMAL_AUTO_BASE but routinely multi-called per turn. */
+const EXTRA_INHERENTLY_REPEATABLE = [
+    "gsd_exec",
+    "multi_edit",
+    "todo_write",
+    "notebook_edit",
+    "search_and_read",
+];
+/** Core session tools that may be invoked many times per agent turn. */
+export const INHERENTLY_REPEATABLE_TOOL_NAMES = [
+    ...MINIMAL_AUTO_BASE_TOOL_NAMES.filter((name) => !NON_REPEATABLE_FROM_MINIMAL_BASE.has(name)),
+    ...EXTRA_INHERENTLY_REPEATABLE,
+];
+export const INHERENTLY_REPEATABLE_TOOL_SET = new Set(INHERENTLY_REPEATABLE_TOOL_NAMES);

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -654,8 +654,9 @@ export function registerDbTools(pi) {
         promptSnippet: "Plan a slice via DB write + PLAN render + cache invalidation",
         promptGuidelines: [
             "Use gsd_plan_slice for slice planning instead of writing S##-PLAN.md or task PLAN files directly.",
-            "Keep parameters flat and provide the full slice planning payload, including tasks.",
-            "The tool validates input, requires an existing parent slice, writes slice/task planning data, renders PLAN.md and task plan files from DB, and clears both state and parse caches after success.",
+            "For incremental planning, call gsd_plan_slice with slice metadata only, then call gsd_plan_task once per task.",
+            "When tasks is omitted or empty, the tool writes only slice planning metadata and preserves existing tasks.",
+            "When tasks is non-empty, the tool validates input, requires an existing parent slice, writes slice/task planning data, renders PLAN.md and task plan files from DB, and clears both state and parse caches after success.",
             "Use the canonical name gsd_plan_slice; gsd_slice_plan is only an alias.",
         ],
         parameters: Type.Object({
@@ -663,7 +664,7 @@ export function registerDbTools(pi) {
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
             goal: Type.String({ description: "Slice goal" }),
-            tasks: Type.Array(Type.Object({
+            tasks: Type.Optional(Type.Array(Type.Object({
                 taskId: Type.String({ description: "Task ID (e.g. T01)" }),
                 title: Type.String({ description: "Task title" }),
                 description: Type.String({ description: "Task description / steps block" }),
@@ -673,12 +674,14 @@ export function registerDbTools(pi) {
                 inputs: Type.Array(Type.String(), { description: "Array<string> of input files or references; pass [\"path\"] or [], never a single string" }),
                 expectedOutput: Type.Array(Type.String(), { description: "Array<string> of files this task creates or overwrites; pass [\"path\"] or [], never prose or a single string" }),
                 observabilityImpact: Type.Optional(Type.String({ description: "Task observability impact" })),
-            }), { description: "Planned tasks for the slice" }),
+                targetRepositories: Type.Optional(Type.Array(Type.String(), { description: "Repository id(s) this task touches (parent workspace); must match a Declared Repository. Omit for single-repo projects." })),
+            }), { description: "Optional full task replacement for the slice. Omit for incremental planning, then call gsd_plan_task once per task." })),
             // ── Enrichment metadata (optional — defaults to empty) ────────────
             successCriteria: Type.Optional(Type.String({ description: "Slice success criteria block" })),
             proofLevel: Type.Optional(Type.String({ description: "Slice proof level" })),
             integrationClosure: Type.Optional(Type.String({ description: "Slice integration closure" })),
             observabilityImpact: Type.Optional(Type.String({ description: "Slice observability impact" })),
+            targetRepositories: Type.Optional(Type.Array(Type.String(), { description: "Slice-wide default repository id(s) (parent workspace); must match a Declared Repository. Omit for single-repo projects." })),
             // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
             actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
             triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'plan-phase complete')" })),
@@ -748,6 +751,7 @@ export function registerDbTools(pi) {
             inputs: Type.Array(Type.String(), { description: "Array<string> of input files or references; pass [\"path\"] or [], never a single string" }),
             expectedOutput: Type.Array(Type.String(), { description: "Array<string> of files this task creates or overwrites; pass [\"path\"] or [], never prose or a single string" }),
             observabilityImpact: Type.Optional(Type.String({ description: "Task observability impact" })),
+            targetRepositories: Type.Optional(Type.Array(Type.String(), { description: "Repository id(s) this task touches (parent workspace); must match a Declared Repository. Omit for single-repo projects." })),
             // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
             actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
             triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'plan-phase complete')" })),

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -14,6 +14,7 @@ import { registerShortcuts } from "./register-shortcuts.js";
 import { writeCrashLog } from "./crash-log.js";
 import { logWarning, isGsdExtensionStderrEnabled } from "../workflow-logger.js";
 import { UNIT_TOOL_CONTRACTS } from "../unit-tool-contracts.js";
+import { installManifestFlushOnProcessTeardown } from "../workflow-manifest.js";
 // Static import so cmux event listeners are registered synchronously during
 // extension bootstrap. Prior implementation used `void import().then()` which
 // queued listener registration as a microtask — any CMUX_CHANNELS emit fired
@@ -177,6 +178,7 @@ export function registerGsdExtension(pi) {
         process.stderr.write(`[gsd] Failed to bootstrap hook-emitter bridge: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
     });
     installEpipeGuard();
+    installManifestFlushOnProcessTeardown();
     // Ecosystem handlers captured by the GSDExtensionAPI wrapper for the
     // GSD-owned `before_agent_start` dispatch step (#3338).
     const ecosystemHandlers = [];

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -13,8 +13,10 @@ import { resolveManifest } from "../unit-context-manifest.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
 import { clearAutoCompletionStopInProgress, clearToolInvocationError, getAutoRuntimeSnapshot, getSourceObservationStore, isAutoActive, isAutoCompletionStopInProgress, isAutoPaused, isInteractiveElicitationInFlight, markToolEnd, markToolStart, recordAutoToolSurfaceSnapshot, recordToolInvocationError, } from "../auto-runtime-state.js";
+import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationError, isToolUnavailableError, } from "../auto-tool-tracking.js";
 import { applyProviderPayloadPolicy } from "../provider-payload-policy.js";
-import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
+import { checkToolCallLoop, recordToolCallLoopMutation, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
+import { MINIMAL_AUTO_BASE_TOOL_NAMES } from "./core-session-tools.js";
 import { maybePauseAutoForApprovalGate, resetPendingGatePauseGuard } from "./pending-gate-pause.js";
 import { saveActivityLog } from "../activity-log.js";
 import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult, saveEvidenceToDisk } from "../safety/evidence-collector.js";
@@ -42,7 +44,15 @@ import { supportsSourceObservationsForUnit } from "../source-observations.js";
 import { clearPendingAutoStart } from "../pending-auto-start.js";
 import { resolveWorkflowToolBasePath } from "./dynamic-tools.js";
 import { getRequiredWorkflowToolsForUnit } from "../unit-tool-contracts.js";
+import { flushAllManifests } from "../workflow-manifest.js";
+import { recordUnitHarnessAbort } from "../unit-runtime.js";
 let approvalQuestionAbortInFlight = false;
+function recordCurrentUnitHarnessAbort(abort) {
+    const dash = getAutoRuntimeSnapshot();
+    if (!dash.active || !dash.basePath || !dash.currentUnit)
+        return;
+    recordUnitHarnessAbort(dash.basePath, dash.currentUnit.type, dash.currentUnit.id, dash.currentUnit.startedAt, abort);
+}
 async function loadWelcomeScreenModule() {
     const candidates = [];
     const gsdBinPath = process.env.GSD_BIN_PATH;
@@ -138,22 +148,7 @@ export const MINIMAL_GSD_TOOL_NAMES = [
     "capture_thought",
     "gsd_capture_thought",
 ];
-export const MINIMAL_AUTO_BASE_TOOL_NAMES = [
-    "ask_user_questions",
-    "bash",
-    "bg_shell",
-    "edit",
-    "find",
-    "glob",
-    "grep",
-    "fetch_page",
-    "search-the-web",
-    "ls",
-    "read",
-    "subagent",
-    "write",
-    "ToolSearch",
-];
+export { MINIMAL_AUTO_BASE_TOOL_NAMES } from "./core-session-tools.js";
 function withPreservedShimTools(toolNames) {
     return [...new Set([...toolNames, ...ALWAYS_PRESERVED_SHIM_TOOL_NAMES])];
 }
@@ -173,9 +168,23 @@ const WORKFLOW_GSD_TOOL_NAMES = [
     ...MINIMAL_GSD_TOOL_NAMES,
     ...Object.values(AUTO_UNIT_SCOPED_TOOLS).flat(),
 ].filter(isGsdManagedTool);
+const WORKFLOW_ONLY_AUTO_BASE_TOOL_NAMES = [
+    "find",
+    "glob",
+    "grep",
+    "ls",
+    "read",
+    "subagent",
+];
 function isGsdManagedTool(name) {
     return name.startsWith("gsd_") || name === "memory_query" || name === "capture_thought" || name === "gsd_graph";
 }
+function autoBaseToolNamesForUnit(unitType) {
+    const manifest = unitType ? resolveManifest(unitType) : null;
+    return manifest?.tools.mode === "workflow-only"
+        ? WORKFLOW_ONLY_AUTO_BASE_TOOL_NAMES
+        : MINIMAL_AUTO_BASE_TOOL_NAMES;
+}
 /**
  * Resolves requested tool names against active tools using exact and MCP-scoped matches.
  *
@@ -226,7 +235,7 @@ export function buildMinimalAutoGsdToolSet(activeToolNames, unitType, registered
         return buildRunUatGsdToolSet(activeToolNames, registeredToolNames);
     }
     const unitTools = unitType ? AUTO_UNIT_SCOPED_TOOLS[unitType] ?? [] : [];
-    const autoBaseTools = new Set(MINIMAL_AUTO_BASE_TOOL_NAMES);
+    const autoBaseTools = new Set(autoBaseToolNamesForUnit(unitType));
     const availableBaseTools = registeredToolNames.filter((name) => autoBaseTools.has(name));
     const preserved = [...new Set([
             ...activeToolNames.filter((name) => autoBaseTools.has(name)),
@@ -449,6 +458,85 @@ function deferApprovalGateFromSnapshot(gateId, basePath, snapshot) {
 function contextBasePath(ctx) {
     return typeof ctx?.cwd === "string" ? ctx.cwd : process.cwd();
 }
+const LOOP_GUARD_INTERACTIVE_INSTRUCTIONS = [
+    "Do not retry this tool or call other tools this turn — stop and respond to the user in text.",
+    "Do not retry this tool or pivot to other tools this turn — stop and respond to the user in text.",
+];
+const LOOP_GUARD_AUTO_INSTRUCTION = "Do not re-issue this blocked tool. In /gsd auto, stop tool calls for this turn and return control to the auto-mode recovery/replan path.";
+function formatLoopGuardBlockReason(reason) {
+    if (!reason || !getAutoRuntimeSnapshot().active)
+        return reason;
+    return LOOP_GUARD_INTERACTIVE_INSTRUCTIONS.reduce((formatted, instruction) => formatted.replace(instruction, LOOP_GUARD_AUTO_INSTRUCTION), reason);
+}
+function isGateResultPersistenceTool(toolName) {
+    return toolName === "gsd_save_gate_result" || toolName === "gsd_uat_result_save";
+}
+function resultDetails(result) {
+    if (!result || typeof result !== "object")
+        return {};
+    const details = result.details;
+    return details && typeof details === "object" ? details : {};
+}
+function isAbortedExecutionToolResult(toolName, result) {
+    if (toolName !== "gsd_exec" && toolName !== "gsd_uat_exec")
+        return false;
+    const details = resultDetails(result);
+    return details.aborted === true || details.force_resolved === true || details.timed_out === true;
+}
+function isRetryableHarnessToolError(toolName, result, errorText) {
+    if (isGateResultPersistenceTool(toolName))
+        return false;
+    if (isDeterministicPolicyError(errorText))
+        return false;
+    if (toolName === "gsd_exec" || toolName === "gsd_uat_exec") {
+        if (isAbortedExecutionToolResult(toolName, result))
+            return true;
+        if (isToolUnavailableError(errorText))
+            return true;
+        if (isQueuedUserMessageSkip(errorText))
+            return true;
+        return isToolInvocationError(errorText);
+    }
+    if (isToolUnavailableError(errorText))
+        return true;
+    if (isQueuedUserMessageSkip(errorText))
+        return true;
+    return false;
+}
+function recordRetryableHarnessToolError(toolName, result, errorText) {
+    if (!isRetryableHarnessToolError(toolName, result, errorText))
+        return;
+    recordCurrentUnitHarnessAbort({
+        kind: "tool-error",
+        reason: errorText || "Tool execution failed before the unit could complete its gate evaluation.",
+        toolName,
+    });
+}
+function recordRetryableTurnAbort(event) {
+    const origin = typeof event.abortOrigin === "string" ? event.abortOrigin : undefined;
+    if (origin === "session-transition")
+        return;
+    const messages = Array.isArray(event.messages) ? event.messages : [];
+    const lastMsg = messages[messages.length - 1];
+    const stopReason = lastMsg && typeof lastMsg === "object"
+        ? lastMsg.stopReason
+        : undefined;
+    if (stopReason !== "aborted" && stopReason !== "error")
+        return;
+    const errorMessage = lastMsg && typeof lastMsg === "object"
+        ? lastMsg.errorMessage
+        : undefined;
+    const reason = [
+        "Agent turn aborted before the unit could complete its gate evaluation.",
+        origin ? `origin=${origin}` : undefined,
+        typeof stopReason === "string" ? `stopReason=${stopReason}` : undefined,
+        typeof errorMessage === "string" && errorMessage.trim() ? `error=${errorMessage.trim()}` : undefined,
+    ].filter(Boolean).join(" ");
+    recordCurrentUnitHarnessAbort({
+        kind: "turn-abort",
+        reason,
+    });
+}
 function beginSourceObservationStoreForCurrentUnit(ctx) {
     if (!isAutoActive())
         return null;
@@ -699,8 +787,8 @@ export function registerHooks(pi, ecosystemHandlers) {
         await applyCompactionThresholdOverride(ctx);
         await prepareWorkflowMcpForHookContext(ctx, basePath);
         // Migrate legacy .gsd/milestones/ to flat-phase .gsd/phases/ when detected.
-        // Best-effort — never blocks session startup. Skipped inside auto-worktrees
-        // (migration already ran on the project root before the worktree was created).
+        // Fail closed on migration errors: resolvers assume flat-phase paths after
+        // startup, so continuing with nested disk state corrupts later checks.
         try {
             const { isInAutoWorktree } = await import("../auto-worktree.js");
             if (!isInAutoWorktree(basePath)) {
@@ -713,13 +801,27 @@ export function registerHooks(pi, ecosystemHandlers) {
                         await migrateToFlatPhase(basePath);
                     }
                     else {
-                        safetyLogWarning("bootstrap", "flat-phase migration deferred: legacy .gsd/milestones/ layout detected but the workflow database could not be opened — will retry on next session");
+                        safetyLogWarning("bootstrap", "flat-phase migration required: legacy .gsd/milestones/ layout detected but the workflow database could not be opened — fix database access before starting GSD");
+                        throw new Error("flat-phase migration required but the workflow database could not be opened; fix database access before starting GSD");
                     }
                 }
             }
         }
         catch (err) {
-            safetyLogWarning("bootstrap", `flat-phase migration: ${err instanceof Error ? err.message : String(err)}`);
+            const message = err instanceof Error ? err.message : String(err);
+            safetyLogWarning("bootstrap", `flat-phase migration failed: ${message}`);
+            throw new Error(`flat-phase migration failed: ${message}`);
+        }
+        try {
+            const projectRoot = resolveWorktreeProjectRoot(basePath);
+            const { pruneStaleFlatPhaseBackups } = await import("../flat-phase-migration.js");
+            const pruned = pruneStaleFlatPhaseBackups(projectRoot);
+            if (pruned > 0) {
+                safetyLogWarning("bootstrap", `pruned ${pruned} stale flat-phase migration backup(s) from .gsd-backups/ (retention exceeded)`);
+            }
+        }
+        catch (err) {
+            safetyLogWarning("bootstrap", `flat-phase backup pruning: ${err instanceof Error ? err.message : String(err)}`);
         }
         // Apply show_token_cost preference (#1515)
         try {
@@ -868,12 +970,24 @@ export function registerHooks(pi, ecosystemHandlers) {
     });
     pi.on("agent_end", async (event, ctx) => {
         approvalQuestionAbortInFlight = false;
+        recordRetryableTurnAbort(event);
         resetToolCallLoopGuard();
         resetPendingGatePauseGuard();
         await resetAskUserQuestionsTurnCache();
         const { handleAgentEnd } = await import("./agent-end-recovery.js");
         const agentEndBasePath = contextBasePath(ctx);
         try {
+            // The manifest is a non-critical projection (the append-only event log is
+            // the authoritative recovery source), so a flush failure must not skip
+            // agent_end recovery. drainManifestWrites still propagates write failures
+            // to explicit flush callers; here we deliberately log and continue so
+            // handleAgentEnd (and the finally below) always run.
+            try {
+                await flushAllManifests();
+            }
+            catch (err) {
+                safetyLogWarning("manifest", `flushAllManifests on agent_end failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
             await handleAgentEnd(pi, event, ctx);
         }
         finally {
@@ -1063,7 +1177,13 @@ export function registerHooks(pi, ecosystemHandlers) {
         // ── Loop guard: block repeated identical tool calls ──
         const loopCheck = checkToolCallLoop(toolName, event.input);
         if (loopCheck.block) {
-            return { block: true, reason: loopCheck.reason };
+            recordCurrentUnitHarnessAbort({
+                kind: "tool-loop-guard",
+                reason: loopCheck.reason ?? "Tool-call loop guard blocked a repeated tool call.",
+                toolName,
+                count: loopCheck.count,
+            });
+            return { block: true, reason: formatLoopGuardBlockReason(loopCheck.reason) };
         }
         const deferredGateGuard = shouldBlockDeferredApprovalTool(toolName, event.input, discussionBasePath);
         if (deferredGateGuard.block) {
@@ -1269,6 +1389,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             }
         }
         if (!event.isError) {
+            recordToolCallLoopMutation(toolName);
             refreshSourceObservationAfterMutation(toolName, event.input, ctx);
             clearSourceObservationsAfterShell(toolName);
         }
@@ -1284,6 +1405,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             // Let recordToolInvocationError classify the failure so non-gsd_ harness
             // errors and deterministic policy rejections are handled consistently.
             recordToolInvocationError(event.toolName, errorText);
+            recordRetryableHarnessToolError(toolName, resultPayload, errorText);
         }
         else if (isAutoActive()) {
             clearToolInvocationError();
@@ -1451,6 +1573,7 @@ export function registerHooks(pi, ecosystemHandlers) {
     // for every finalized tool call on every engine, so error classification
     // and evidence persistence here cover external engines that skip tool_result.
     pi.on("tool_execution_end", async (event) => {
+        const toolName = canonicalToolName(event.toolName);
         markToolEnd(event.toolCallId);
         // #2883/#4974: Capture deterministic invocation/policy errors
         // so postUnitPreVerification can break the retry loop instead of re-dispatching.
@@ -1461,6 +1584,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             // Let recordToolInvocationError classify the failure so non-gsd_ harness
             // errors and deterministic policy rejections are handled consistently.
             recordToolInvocationError(event.toolName, errorText);
+            recordRetryableHarnessToolError(toolName, event.result, errorText);
         }
         else if (isAutoActive()) {
             clearToolInvocationError();