@opengsd/gsd-pi 1.3.0-dev.72e3af2a → 1.3.0-dev.738160b9

package/README.md

@@ -158,7 +158,7 @@ Need help choosing settings? Use the [GSD Pi web configurator](https://pi.opengs
 gsd
 ```
 
-Run the setup flow, choose your preferred model provider, and open a project directory. GSD stores project planning and runtime state in `.gsd/`.
+Run the setup flow, choose your preferred model provider, and open a project directory. GSD stores project planning and runtime state in `.gsd/`, with gitignored sibling runtime directories such as `.gsd-backups/` for migration snapshots. Stale `.gsd-backups/migrate-*` snapshots are pruned after 30 days once the flat-phase `.gsd/phases/` migration is complete.
 
 For a full first-run walkthrough, see [Getting Started With gsd-pi](./docs/user-docs/getting-started.md).
 

package/dist/cli.js

@@ -22,15 +22,23 @@ import { markStartup, printStartupTimings } from './startup-timings.js';
 import { applyRtkProcessEnv, GSD_RTK_DISABLED_ENV, isTruthy } from './rtk-shared.js';
 let piCodingAgentModulePromise;
 let agentCoreModulePromise;
-let agentModesModulePromise;
+let interactiveModeModulePromise;
+let printModeModulePromise;
+let rpcModeModulePromise;
 function loadPiCodingAgentModule() {
     return (piCodingAgentModulePromise ??= import('@gsd/pi-coding-agent'));
 }
 function loadAgentCoreModule() {
     return (agentCoreModulePromise ??= import('@gsd/agent-core'));
 }
-function loadAgentModesModule() {
-    return (agentModesModulePromise ??= import('@gsd/agent-modes'));
+function loadInteractiveModeModule() {
+    return (interactiveModeModulePromise ??= import('@gsd/agent-modes/modes/interactive/interactive-mode.js'));
+}
+function loadPrintModeModule() {
+    return (printModeModulePromise ??= import('@gsd/agent-modes/modes/print-mode.js'));
+}
+function loadRpcModeModule() {
+    return (rpcModeModulePromise ??= import('@gsd/agent-modes/modes/rpc/rpc-mode.js'));
 }
 // ---------------------------------------------------------------------------
 // V8 compile cache — Node 22+ can cache compiled bytecode across runs,
@@ -511,7 +519,6 @@ if (!isPrintMode &&
 }
 const { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager, SessionManager, } = await loadPiCodingAgentModule();
 const { createAgentSession } = await loadAgentCoreModule();
-const { InteractiveMode, runPrintMode, runRpcMode } = await loadAgentModesModule();
 markStartup('loadPiCodingAgent');
 // Pi's tool bootstrap can mis-detect already-installed fd/rg on some systems
 // because spawnSync(..., ["--version"]) returns EPERM despite a zero exit code.
@@ -530,6 +537,9 @@ markStartup('ModelRegistry');
 const settingsManager = SettingsManager.create(process.cwd(), agentDir);
 applySecurityOverrides(settingsManager);
 markStartup('SettingsManager.create');
+const { configureHttpDispatcher } = await import('@gsd/pi-coding-agent/core/http-dispatcher.js');
+configureHttpDispatcher(settingsManager.getHttpIdleTimeoutMs());
+markStartup('configureHttpDispatcher');
 // Run onboarding wizard on first launch (no LLM provider configured)
 if (!isPrintMode && shouldRunOnboarding(authStorage, settingsManager.getDefaultProvider())) {
     await runOnboarding(authStorage);
@@ -651,6 +661,7 @@ if (isPrintMode) {
     applyModelOverride(session, modelRegistry, cliFlags.model);
     const mode = cliFlags.mode || 'text';
     if (mode === 'rpc') {
+        const { runRpcMode } = await loadRpcModeModule();
         printStartupTimings();
         await runRpcMode(session);
         process.exit(0);
@@ -674,6 +685,7 @@ if (isPrintMode) {
         // MCP server runs until the transport closes; keep alive
         await new Promise(() => { });
     }
+    const { runPrintMode } = await loadPrintModeModule();
     printStartupTimings();
     await runPrintMode(session, {
         mode: mode,
@@ -809,6 +821,7 @@ if (!process.stdin.isTTY || !process.stdout.isTTY) {
             : 'stdout is';
     printNonTtyErrorAndExit(missing, true);
 }
+const { InteractiveMode } = await loadInteractiveModeModule();
 const interactiveMode = new InteractiveMode(session);
 markStartup('InteractiveMode');
 printStartupTimings();

package/dist/headless-answers.js

@@ -6,7 +6,7 @@
  * default auto-responder or supervised mode.
  */
 import { readFileSync } from 'node:fs';
-import { serializeJsonLine } from '@gsd/agent-modes';
+import { serializeJsonLine } from '@gsd/agent-modes/modes/rpc/jsonl.js';
 import { canonicalHeadlessToolName } from './headless-events.js';
 export function normalizeQuestionId(id) {
     return id.trim().toLowerCase().replace(/[-\s]+/g, '_').replace(/_confirm$/, '');

package/dist/headless-ui.d.ts

@@ -5,7 +5,7 @@
  * formats progress events for stderr output, and reads orchestrator
  * commands from stdin in supervised mode.
  */
-import { RpcClient } from '@gsd/agent-modes';
+import type { RpcClient } from '@gsd/agent-modes/modes/rpc/rpc-client.js';
 interface ExtensionUIRequest {
     type: 'extension_ui_request';
     id: string;

package/dist/headless-ui.js

@@ -5,7 +5,7 @@
  * formats progress events for stderr output, and reads orchestrator
  * commands from stdin in supervised mode.
  */
-import { attachJsonlLineReader } from '@gsd/agent-modes';
+import { attachJsonlLineReader } from '@gsd/agent-modes/modes/rpc/jsonl.js';
 // ---------------------------------------------------------------------------
 // ANSI Color Helpers
 // ---------------------------------------------------------------------------

package/dist/headless.js

@@ -14,7 +14,7 @@
 import { existsSync, mkdirSync, writeFileSync, writeSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolve } from 'node:path';
-import { RpcClient } from '@gsd/agent-modes';
+import { RpcClient } from '@gsd/agent-modes/modes/rpc/rpc-client.js';
 import { SessionManager } from '@gsd/pi-coding-agent';
 import { getProjectSessionsDir } from './project-sessions.js';
 import { loadAndValidateAnswerFile, AnswerInjector } from './headless-answers.js';

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-f088e947f0ebb875
+bd26f10d1f8c134c

package/dist/resources/extensions/claude-code-cli/models.js

@@ -46,6 +46,15 @@ export const CLAUDE_CODE_MODELS = [
         contextWindow: 1_000_000,
         maxTokens: 128_000,
     },
+    {
+        id: "claude-sonnet-5",
+        name: "Claude Sonnet 5 (via Claude Code)",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: ZERO_COST,
+        contextWindow: 1_000_000,
+        maxTokens: 128_000,
+    },
     {
         id: "claude-sonnet-4-6",
         name: "Claude Sonnet 4.6 (via Claude Code)",

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

@@ -124,6 +124,13 @@ export class AutoSession {
      * the issues after MAX_PRE_EXEC_RETRIES re-attempts.
      */
     preExecRetryCount = new Map();
+    /**
+     * Tracks how many times each slice unit has been re-dispatched to plan-slice
+     * because task plan files were missing. Keyed by unitId (e.g. "M001/S01").
+     * Separate from preExecRetryCount so pre-exec gate failures do not block or
+     * conflate with missing-task-plan recovery.
+     */
+    missingTaskPlanRetryCount = new Map();
     // ── Tool invocation errors (#2883) ──────────────────────────────────
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
@@ -310,6 +317,7 @@ export class AutoSession {
         this.consecutiveCompleteBootstraps = 0;
         this.lastPreExecFailure = null;
         this.preExecRetryCount.clear();
+        this.missingTaskPlanRetryCount.clear();
         this.lastToolInvocationError = null;
         this.toolUnavailableRetries = 0;
         this.lastUnitAgentEndMessages = null;

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

@@ -25,7 +25,7 @@ export function decideVerificationRetry(input) {
         return { action: "pause", reason: "missing-retry-context" };
     }
     const key = verificationRetryKey(unitType, retryInfo.unitId);
-    const failureHash = hashVerificationFailureContext(retryInfo.failureContext);
+    const failureHash = hashVerificationFailureContext(retryInfo.signature ?? retryInfo.failureContext);
     if (input.previousFailureHash === failureHash) {
         return {
             action: "pause",

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

@@ -68,6 +68,10 @@ export function resolveCompactionThresholdPercent(raw) {
     const value = typeof raw === "number" && Number.isFinite(raw) && raw >= 0.5 && raw <= 0.95 ? raw : 0.6;
     return value <= 1 ? value * 100 : value;
 }
-export function shouldRerootStepSessionForContext(contextPercent, compactionThresholdPercent) {
+export const HARD_CONTEXT_REROOT_THRESHOLD_PERCENT = 90;
+export function shouldWarnStepSessionForContext(contextPercent, compactionThresholdPercent) {
     return getContextPauseAction(contextPercent, resolveCompactionThresholdPercent(compactionThresholdPercent)) === "pause";
 }
+export function shouldRerootStepSessionForContext(contextPercent) {
+    return getContextPauseAction(contextPercent, HARD_CONTEXT_REROOT_THRESHOLD_PERCENT) === "pause";
+}

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

@@ -1238,6 +1238,7 @@ export const DISPATCH_RULES = [
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
             const tid = state.activeTask.id;
+            const unitId = `${mid}/${sid}`;
             const artifactBasePath = resolveArtifactBasePath(basePath, mid, session);
             // Guard: if the slice plan exists but the individual task plan files are
             // missing, the planner created S##-PLAN.md with task entries but never
@@ -1263,6 +1264,17 @@ export const DISPATCH_RULES = [
             if ((!taskPlanPath || !existsSync(taskPlanPath)) &&
                 !existsSync(projectionTaskPlanPath) &&
                 !tasksEmbeddedInSlicePlan) {
+                const MAX_MISSING_TASK_PLAN_RETRIES = 2;
+                const retryCount = session?.missingTaskPlanRetryCount?.get(unitId) ?? 0;
+                if (retryCount >= MAX_MISSING_TASK_PLAN_RETRIES) {
+                    session?.missingTaskPlanRetryCount?.delete(unitId);
+                    return {
+                        action: "stop",
+                        reason: `Missing task-plan recovery failed ${retryCount} times for ${unitId} - manual intervention required. Task plan ${tid} is still missing after regenerating the slice plan. Fix the task-plan files manually, then run /gsd auto to resume.`,
+                        level: "error",
+                    };
+                }
+                session?.missingTaskPlanRetryCount?.set(unitId, retryCount + 1);
                 if (isDebugEnabled()) {
                     const expectedTaskPlanPath = join(artifactBasePath, relTaskFile(artifactBasePath, mid, sid, tid, "PLAN"));
                     const originalProjectRoot = session?.originalBasePath || basePath;
@@ -1286,10 +1298,11 @@ export const DISPATCH_RULES = [
                 return {
                     action: "dispatch",
                     unitType: "plan-slice",
-                    unitId: `${mid}/${sid}`,
+                    unitId,
                     prompt: await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, basePath, undefined, { sessionContextWindow, modelRegistry, sessionProvider }),
                 };
             }
+            session?.missingTaskPlanRetryCount?.delete(unitId);
             return null;
         },
     },

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -1834,7 +1834,7 @@ export async function postUnitPreVerification(pctx, opts) {
                     saveCustomVerifyRetryCounts(s, { logFailure: err => debugLog("postUnit", { phase: "save-verify-retries-failed", error: err instanceof Error ? err.message : String(err) }) });
                     s.pendingVerificationRetry = {
                         unitId: s.currentUnit.id,
-                        failureContext: `${failureDetails} (attempt ${attempt}/${MAX_ARTIFACT_VERIFICATION_RETRIES}).`,
+                        failureContext: failureDetails,
                         attempt,
                     };
                     debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });

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

@@ -10,7 +10,7 @@
 import { loadFile, parseContinue, parseSummary, loadActiveOverrides, formatOverridesSection } from "./files.js";
 import { hasVerdict, extractVerdict } from "./verdict-parser.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
-import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
+import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, relTaskFile, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
 import { isContextModeEnabled } from "./preferences-types.js";
 import { parseRoadmap } from "./parsers-legacy.js";
@@ -2282,7 +2282,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         : "- (no prior tasks)";
     const taskPlanPath = resolveTaskFile(base, mid, sid, tid, "PLAN");
     const taskPlanContent = taskPlanPath ? await loadFile(taskPlanPath) : null;
-    const taskPlanRelPath = relSlicePath(base, mid, sid) + `/tasks/${tid}-PLAN.md`;
+    const taskPlanRelPath = relTaskFile(base, mid, sid, tid, "PLAN");
     const taskPlanContext = taskPlanContent
         ? [
             "## Inlined Task Plan (authoritative local execution contract)",
@@ -3376,7 +3376,7 @@ opts) {
         const depPaths = await getDependencyTaskSummaryPaths(mid, sid, tid, node?.dependsOn ?? [], base);
         const taskPlanPath = resolveTaskFile(base, mid, sid, tid, "PLAN");
         const taskPlanContent = taskPlanPath ? await loadFile(taskPlanPath) : null;
-        const taskPlanRelPath = `${relSlicePath(base, mid, sid)}/tasks/${tid}-PLAN.md`;
+        const taskPlanRelPath = relTaskFile(base, mid, sid, tid, "PLAN");
         const taskPlanInline = taskPlanContent
             ? [
                 "## Inlined Task Plan (authoritative local execution contract)",

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

@@ -16,7 +16,7 @@ import { isDbAvailable, getTask, updateTaskStatus, updateSliceStatus, insertSlic
 import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning } from "./workflow-logger.js";
-import { isClosedStatus } from "./status-guards.js";
+import { isClosedStatus, isInactiveStatus } from "./status-guards.js";
 import { resolveSlicePath, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, clearPathCache, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { dirname } from "node:path";
@@ -194,7 +194,7 @@ export function writeReactiveExecuteBlocker(unitId, base, reason) {
     transaction(() => {
         for (const tid of summaryPresent) {
             const task = getTask(mid, sid, tid);
-            if (!task || isClosedStatus(task.status)) {
+            if (!task || isInactiveStatus(task.status)) {
                 unchangedTaskIds.push(tid);
                 continue;
             }
@@ -203,7 +203,7 @@ export function writeReactiveExecuteBlocker(unitId, base, reason) {
         }
         for (const tid of summaryMissing) {
             const task = getTask(mid, sid, tid);
-            if (!task || isClosedStatus(task.status)) {
+            if (!task || isInactiveStatus(task.status)) {
                 unchangedTaskIds.push(tid);
                 continue;
             }

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.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)
@@ -904,9 +904,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 +916,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 +1552,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 +1571,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

@@ -25,6 +25,7 @@ const NON_REPEATABLE_FROM_MINIMAL_BASE = new Set([
 ]);
 /** 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",

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,7 +674,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" })),
-            }), { description: "Planned tasks for the slice" }),
+            }), { 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" })),

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

@@ -14,7 +14,7 @@ import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from
 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 { 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";
@@ -43,6 +43,7 @@ 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";
 let approvalQuestionAbortInFlight = false;
 async function loadWelcomeScreenModule() {
     const candidates = [];
@@ -435,6 +436,16 @@ 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 beginSourceObservationStoreForCurrentUnit(ctx) {
     if (!isAutoActive())
         return null;
@@ -703,6 +714,12 @@ export function registerHooks(pi, ecosystemHandlers) {
                     }
                 }
             }
+            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 migration: ${err instanceof Error ? err.message : String(err)}`);
@@ -860,6 +877,17 @@ export function registerHooks(pi, ecosystemHandlers) {
         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 {
@@ -1049,7 +1077,7 @@ 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 };
+            return { block: true, reason: formatLoopGuardBlockReason(loopCheck.reason) };
         }
         const deferredGateGuard = shouldBlockDeferredApprovalTool(toolName, event.input, discussionBasePath);
         if (deferredGateGuard.block) {
@@ -1255,6 +1283,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             }
         }
         if (!event.isError) {
+            recordToolCallLoopMutation(toolName);
             refreshSourceObservationAfterMutation(toolName, event.input, ctx);
             clearSourceObservationsAfterShell(toolName);
         }

package/dist/resources/extensions/gsd/bootstrap/tool-call-loop-guard.js

@@ -14,10 +14,12 @@
  * to stop tooling for the rest of that turn and answer in text.
  *
  * The per-tool-name check (#783 Brief C) tracks call counts within a
- * turn regardless of args. This catches improvisation
+ * turn regardless of args, decaying after successful state-mutating tools.
+ * This catches improvisation
  * loops where the model attempts the same missing workflow tool through
  * varied surfaces (bash → `node -e` → CLI), each with a different
- * signature, so the identical-args streak never trips. Whichever guard
+ * signature, so the identical-args streak never trips, while allowing
+ * tool-heavy turns that are making file-mutation progress. Whichever guard
  * trips first blocks.
  */
 import { createHash } from "node:crypto";
@@ -38,12 +40,16 @@ const MAX_CONSECUTIVE_STRICT = 1;
  */
 const PER_TOOL_DEFAULT_CAP = 6;
 const PER_TOOL_REPEATABLE_CAP = 15;
+const PER_TOOL_CAP_EXEMPT_TOOLS = new Set(["find", "glob", "grep", "ls", "read", "search_and_read"]);
+const STATE_MUTATING_TOOL_SET = new Set(["edit", "write", "multi_edit", "notebook_edit"]);
 let consecutiveCount = 0;
 let lastSignature = "";
 let lastToolName = "";
 let enabled = true;
 /** Per-tool-name call counts within the current turn (#783 Brief C). */
 const perToolCounts = new Map();
+let mutationEpoch = 0;
+const perToolLastMutationEpoch = new Map();
 /** Hash tool name + args into a compact signature for comparison. */
 function hashToolCall(toolName, args) {
     const h = createHash("sha256");
@@ -67,7 +73,8 @@ function hashToolCall(toolName, args) {
  *  1. Identical-signature streak (MAX_CONSECUTIVE_IDENTICAL_CALLS, strict for
  *     ask_user_questions).
  *  2. Per-tool-name cap (PER_TOOL_DEFAULT_CAP / PER_TOOL_REPEATABLE_CAP),
- *     independent of args — catches improvisation loops (#783).
+ *     independent of args, reset after file-mutation progress — catches
+ *     improvisation loops (#783).
  */
 export function checkToolCallLoop(toolName, args) {
     if (!enabled)
@@ -97,8 +104,17 @@ export function checkToolCallLoop(toolName, args) {
     // ── Guard 2: per-tool-name cap, independent of args (#783 Brief C) ──
     // Catches improvisation loops where the same tool is invoked many times with
     // varied args (e.g. retrying a missing workflow tool via bash/node -e/CLI).
-    const perToolCount = (perToolCounts.get(toolName) ?? 0) + 1;
+    const priorPerToolCount = (perToolLastMutationEpoch.get(toolName) ?? mutationEpoch) < mutationEpoch
+        ? 0
+        : (perToolCounts.get(toolName) ?? 0);
+    const perToolCount = priorPerToolCount + 1;
     perToolCounts.set(toolName, perToolCount);
+    perToolLastMutationEpoch.set(toolName, mutationEpoch);
+    // Read-only navigation tools are normal context gathering; Guard 1 still
+    // catches true reread loops with identical arguments.
+    if (PER_TOOL_CAP_EXEMPT_TOOLS.has(toolName)) {
+        return { block: false, count: consecutiveCount };
+    }
     const perToolCap = INHERENTLY_REPEATABLE_TOOL_SET.has(toolName)
         ? PER_TOOL_REPEATABLE_CAP
         : PER_TOOL_DEFAULT_CAP;
@@ -114,6 +130,14 @@ export function checkToolCallLoop(toolName, args) {
     }
     return { block: false, count: consecutiveCount };
 }
+/** Record successful mutation progress so Guard 2 can decay on the next count. */
+export function recordToolCallLoopMutation(toolName) {
+    if (!enabled)
+        return;
+    if (!STATE_MUTATING_TOOL_SET.has(toolName))
+        return;
+    mutationEpoch++;
+}
 /** Reset the guard state. Call at agent turn boundaries. */
 export function resetToolCallLoopGuard() {
     consecutiveCount = 0;
@@ -121,6 +145,8 @@ export function resetToolCallLoopGuard() {
     lastToolName = "";
     enabled = true;
     perToolCounts.clear();
+    mutationEpoch = 0;
+    perToolLastMutationEpoch.clear();
 }
 /** Disable the guard (e.g. during shutdown). */
 export function disableToolCallLoopGuard() {
@@ -129,6 +155,8 @@ export function disableToolCallLoopGuard() {
     lastSignature = "";
     lastToolName = "";
     perToolCounts.clear();
+    mutationEpoch = 0;
+    perToolLastMutationEpoch.clear();
 }
 /** Get current consecutive count for diagnostics. */
 export function getToolCallLoopCount() {