gsd-pi 2.81.0 → 2.82.0

package/README.md

@@ -27,36 +27,48 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.80
+## What's New in v2.81
 
-### DB-Authoritative Context
+### Worktree Safety & Projection
 
-- **UOK contracts are DB-authoritative** — runtime contract state now flows through the database instead of file-first projections.
-- **Auto-run context mode fully wired** — context-mode execution is connected end-to-end for auto runs.
-- **Planned slice recovery** — planned slices recover correctly after artifact writes.
+- **Worktree safety is now fail-closed** — write/edit operations enforce the worktree-isolation contract before touching project files. If GSD cannot prove the active worktree is healthy, rooted correctly, and attached to the intended milestone, it stops instead of guessing.
+- **Custom-engine bypasses are explicit** — custom workflow units can opt out of worktree safety checks only through the dedicated path for that runtime. That keeps normal auto-mode writes protected while avoiding false failures for engines that do not use the same worktree lifecycle.
+- **Lifecycle and projection are split into dedicated modules** — worktree entry, exit, root projection, and merge finalization now flow through clearer boundaries. This makes it easier to reason about when state is copied into a milestone worktree, when it is projected back to the project root, and which module owns each step.
+- **Milestone merge closeout is harder to wedge** — stale leases, orphaned preflight stashes, branch-mode drift, reused branches, and wrong-branch merges are detected or recovered more reliably. If GSD finds completed work stranded in a milestone branch or preflight stash, startup and closeout paths now have better recovery hooks.
+- **Projection bypasses were closed** — post-unit and phase flows now route through the Worktree State Projection path instead of ad hoc file movement. That keeps database state, milestone artifacts, and root projections aligned during long-running auto-mode sessions.
 
-### Auto, Deep Mode & Gates
+### Memory, Context & Token Control
 
-- **Deep queued milestones continue** — deep project milestones can resume through queued work instead of stalling.
-- **Deep project registration** — deep project milestones are registered as part of the workflow.
-- **Depth-verification gate fixes** — gate workflow regressions were closed, including case-insensitive plan-slice artifact resolution.
-- **Task commits bound to milestone completion** — automated task commits now respect the milestone completion guard.
+- **Memory relevance improved** — artifacts now carry integrity fingerprints, memories track last-hit time, and relevance scoring uses time decay. Recent, repeatedly useful memories can rank higher, while stale or superseded context is less likely to crowd out the current task.
+- **Artifact integrity is easier to preserve** — content hashes are retained through worktree reconciliation, so GSD can detect whether projected artifacts still match the state it expects. This supports safer recovery and reduces accidental drift between root and worktree state.
+- **Fallback memory search is safer** — when FTS5 is unavailable, LIKE-based fallback scans are capped and surfaced with warnings instead of silently becoming expensive. Memory ranking also guards against invalid decay settings producing unusable scores.
+- **Provider tools are scoped per request** — tool availability is narrowed at request time, with provider-boundary token audit support. The model sees the tools relevant to the current provider and task instead of carrying broad tool definitions through every request.
+- **Prompt and workflow context got leaner** — repeated workflow context is capped, prompt templates use portable paths, and many high-volume workflow prompts were compacted. The goal is less repeated instruction text in long sessions without removing the guardrails that keep planning, execution, and closeout on track.
+- **Token accounting is more accurate** — session tokens are reported separately from context in VS Code, the token encoder warms at startup, and provider-boundary audit hooks make it easier to understand where request size is coming from.
 
-### MCP, Post-Exec & Cross-Platform
+### TUI & Operator Experience
 
-- **Post-exec import hardening** — explicit extension fallbacks, dotted module stems, React Router `+types`, and `+types` guards are handled more carefully.
-- **MCP write gating** — `gsd_exec` writes are gated, with Windows path-separator test coverage tightened.
-- **Project saves stay successful** — saving a project no longer fails just because registration fails.
-- **Home-directory fallback** — `currentDirectoryRoot` uses `homedir()` fallback behavior for better cross-platform consistency.
+- **Compact tool output is more useful** — compact cards show tool targets and low-signal tool output can roll up by phase.
+- **Terminal UI refreshed** — chat/tool cards align with the terminal design, adaptive refresher layouts landed, and the welcome/header lifecycle is more stable.
+- **Auto-mode stays anchored** — bottom anchoring, direct tool execution rollups, and lifecycle hook shutdown behavior were tightened.
 
-### Reliability & Review Hardening
+### Reliability, Tests & CI
 
-- **Auto orchestration seams and contracts** — orchestration boundaries were made more explicit and review feedback was folded in.
-- **Cancellation context preserved** — auto-mode pauses keep cancellation context instead of dropping it.
-- **Recovery stop lifecycle** — recovery stop now emits the expected lifecycle event.
-- **Trace and cleanup fixes** — trace correlation, cleanup-on-throw, audit context reset, and `onTurnResult` phase-result guards were tightened.
+- **Auto-mode recovery tightened** — crash recovery, session handoff, stale milestone completion replay, stale leases, and complete-project restart loops were all hardened.
+- **E2E coverage expanded** — real-process MCP, fake LLM, native ABI, schema migration, Docker runtime, Windows runner, and multi-iteration loop coverage landed.
+- **CI is faster and less noisy** — merge/build gates were simplified, expensive PR jobs are gated, and merge-conflict PRs skip heavy jobs.
 
-See the full [Changelog](./CHANGELOG.md) for the complete v2.80 entry and prior releases.
+See the full [Changelog](./CHANGELOG.md) for the complete v2.81 entry and prior releases.
+
+<details>
+<summary>v2.80 highlights</summary>
+
+- **DB-authoritative context** — UOK contracts moved through database-backed runtime state, auto-run context mode was wired end-to-end, and planned slices recover after artifact writes.
+- **Auto, deep mode, and gates** — deep queued milestones continue, deep project milestones register cleanly, depth-verification regressions were closed, and task commits respect the milestone completion guard.
+- **MCP, post-exec, and cross-platform hardening** — post-exec import fallback handling, React Router `+types` imports, `gsd_exec` write gating, project-save behavior, and home-directory fallback behavior were tightened.
+- **Reliability and review hardening** — auto orchestration contracts, cancellation context preservation, recovery stop lifecycle events, trace correlation, cleanup-on-throw, and phase-result guards were improved.
+
+</details>
 
 <details>
 <summary>v2.79 highlights</summary>
@@ -346,7 +358,7 @@ The database is authoritative for milestones, slices, tasks, requirements, decis
 
 7. **Stuck and artifact detection** — A sliding-window detector identifies repeated dispatch patterns (including multi-unit cycles). Missing expected artifacts use a separate bounded path: GSD retries artifact verification up to 3 times with failure context, then pauses auto mode with the missing artifact error instead of looping indefinitely.
 
-8. **Timeout supervision** — Soft timeout warns the LLM to wrap up. Idle watchdog detects stalls. Hard timeout pauses auto mode. Recovery steering nudges the LLM to finish durable output before giving up.
+8. **Timeout supervision** — Soft timeout warns the LLM to wrap up. Idle watchdog detects stalls. Hard timeout starts recovery and only pauses auto mode if durable progress cannot be made. Runtime progress is recorded under `.gsd/runtime/`, and journal events close out unit, finalize, and iteration phases for later forensics.
 
 9. **Cost tracking** — Every unit's token usage and cost is captured, broken down by phase, slice, and model. The dashboard shows running totals and projections. Budget ceilings can pause auto mode before overspending.
 
@@ -738,7 +750,7 @@ The best practice for working in teams is to ensure unique milestone names acros
 .gsd/metrics.json
 # Raw JSONL session dumps — crash recovery forensics, auto-pruned
 .gsd/activity/
-# Unit execution records — dispatch phase, timeouts, and recovery tracking
+# Unit execution records — dispatch phase, timeout recovery progress, and finalize tracking
 .gsd/runtime/
 # Git worktree working copies
 .gsd/worktrees/
@@ -746,7 +758,7 @@ The best practice for working in teams is to ensure unique milestone names acros
 .gsd/parallel/
 # SQLite database and WAL sidecars — authoritative runtime state, local only
 .gsd/gsd.db*
-# Daily-rotated event journal — structured event log for forensics
+# Daily-rotated event journal — structured unit/finalize/iteration event log for forensics
 .gsd/journal/
 # Doctor run history — diagnostic check results
 .gsd/doctor-history.jsonl

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

@@ -1 +1 @@
-195cc0a83851a027
+cec78fe13fe69412

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

@@ -287,6 +287,13 @@ export async function autoLoop(ctx, pi, s, deps, options) {
         }
         let dispatchId = null;
         let dispatchSettled = false;
+        let iterationEndEmitted = false;
+        const emitIterationEnd = (details = {}) => {
+            if (iterationEndEmitted)
+                return;
+            iterationEndEmitted = true;
+            journalReporter.emit("iteration-end", { iteration, ...details });
+        };
         const completeIteration = () => {
             completeWorkflowIteration({
                 get consecutiveErrors() { return consecutiveErrors; },
@@ -295,11 +302,15 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 set consecutiveCooldowns(value) { consecutiveCooldowns = value; },
                 recentErrorMessages,
             }, {
-                emitIterationEnd: () => journalReporter.emit("iteration-end", { iteration }),
+                emitIterationEnd: () => emitIterationEnd(),
                 saveStuckState: () => saveStuckState(s, loopState),
                 logIterationComplete: () => debugLog("autoLoop", { phase: "iteration-complete", iteration }),
             });
         };
+        const finishIncompleteIteration = (details) => {
+            emitIterationEnd(details);
+            saveStuckState(s, loopState);
+        };
         try {
             // ── Blanket try/catch: one bad iteration must not kill the session
             const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
@@ -373,6 +384,7 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 });
                 if (engineState.isComplete) {
                     finishTurn("completed");
+                    emitIterationEnd({ status: "completed", reason: "custom-engine-complete" });
                     await deps.stopAuto(ctx, pi, "Workflow complete");
                     break;
                 }
@@ -389,15 +401,22 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 });
                 if (dispatchFlow.action === "break") {
                     finishTurn("stopped", "manual-attention", "custom-engine-dispatch-stop");
+                    finishIncompleteIteration({
+                        status: "stopped",
+                        reason: "custom-engine-dispatch-stop",
+                        failureClass: "manual-attention",
+                    });
                     break;
                 }
                 if (dispatchFlow.action === "continue") {
                     finishTurn("skipped");
+                    emitIterationEnd({ status: "skipped", reason: "custom-engine-dispatch-skip" });
                     continue;
                 }
                 // dispatch.action === "dispatch"
                 if (dispatch.action !== "dispatch") {
                     finishTurn("skipped");
+                    emitIterationEnd({ status: "skipped", reason: "custom-engine-dispatch-mismatch" });
                     continue;
                 }
                 const step = dispatch.step;
@@ -424,6 +443,13 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 });
                 if (guardsResult.action === "break") {
                     finishTurn("stopped", "manual-attention", "guard-break");
+                    finishIncompleteIteration({
+                        status: "stopped",
+                        reason: "guard-break",
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                        failureClass: "manual-attention",
+                    });
                     break;
                 }
                 // ── Unit execution (shared with dev path) ──
@@ -449,6 +475,13 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     unitId: iterData.unitId,
                 });
                 if (unitPhaseResult.action === "break") {
+                    finishIncompleteIteration({
+                        status: "stopped",
+                        reason: unitPhaseResult.reason ?? "unit-break",
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                        failureClass: "execution",
+                    });
                     finishTurn("stopped", "execution", "unit-break");
                     break;
                 }
@@ -466,8 +499,16 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                             finishTurn,
                         },
                     });
-                    if (verifyFlow.action === "break")
+                    if (verifyFlow.action === "break") {
+                        finishIncompleteIteration({
+                            status: "paused",
+                            reason: "custom-engine-verify-pause",
+                            unitType: iterData.unitType,
+                            unitId: iterData.unitId,
+                            failureClass: "manual-attention",
+                        });
                         break;
+                    }
                 }
                 if (verifyResult === "retry") {
                     const retryOutcome = await handleCustomEngineVerifyRetry({
@@ -501,8 +542,22 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                             finishTurn,
                         },
                     });
-                    if (retryFlow.action === "break")
+                    if (retryFlow.action === "break") {
+                        finishIncompleteIteration({
+                            status: retryOutcome.action === "stop" ? "stopped" : "paused",
+                            reason: retryOutcome.action === "retry" ? "custom-engine-verify-retry" : retryOutcome.turnError,
+                            unitType: iterData.unitType,
+                            unitId: iterData.unitId,
+                            failureClass: "manual-attention",
+                        });
                         break;
+                    }
+                    finishIncompleteIteration({
+                        status: "retry",
+                        reason: "custom-engine-verify-retry",
+                        unitType: iterData.unitType,
+                        unitId: iterData.unitId,
+                    });
                     continue;
                 }
                 // Verification passed — mark step complete
@@ -694,16 +749,36 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,
                 }) || dispatchSettled;
+                finishIncompleteIteration({
+                    status: "stopped",
+                    reason: unitPhaseResult.reason ?? "unit-break",
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                    failureClass: "execution",
+                });
                 finishTurn("stopped", "execution", "unit-break");
                 break;
             }
             // ── Phase 5: Finalize ───────────────────────────────────────────────
             let finalizeResult;
+            journalReporter.emit("post-unit-finalize-start", {
+                iteration,
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+            });
             try {
                 finalizeResult = await runFinalize(ic, iterData, loopState, sidecarItem);
             }
             catch (err) {
-                dispatchSettled = settleDispatchFailed(dispatchId, formatDispatchExceptionSummary({ error: err }), {
+                const error = formatDispatchExceptionSummary({ error: err });
+                journalReporter.emit("post-unit-finalize-end", {
+                    iteration,
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                    status: "failed",
+                    error,
+                });
+                dispatchSettled = settleDispatchFailed(dispatchId, error, {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,
                 }) || dispatchSettled;
@@ -713,6 +788,15 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 unitType: iterData.unitType,
                 unitId: iterData.unitId,
             });
+            const finalizeReason = finalizeResult.action === "break" ? finalizeResult.reason : undefined;
+            journalReporter.emit("post-unit-finalize-end", {
+                iteration,
+                unitType: iterData.unitType,
+                unitId: iterData.unitId,
+                status: finalizeResult.action === "next" ? "completed" : finalizeResult.action === "continue" ? "retry" : "stopped",
+                action: finalizeResult.action,
+                ...(finalizeReason ? { reason: finalizeReason } : {}),
+            });
             const finalizeDecision = decideFinalizeResult(finalizeResult.action === "break"
                 ? { action: "break", reason: finalizeResult.reason }
                 : finalizeResult.action === "continue"
@@ -723,6 +807,13 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,
                 }) || dispatchSettled;
+                finishIncompleteIteration({
+                    status: "stopped",
+                    reason: finalizeReason ?? "finalize-break",
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                    failureClass: finalizeDecision.failureClass,
+                });
                 finishTurn("stopped", finalizeDecision.failureClass, finalizeDecision.turnError);
                 break;
             }
@@ -731,6 +822,12 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     markFailed: markDispatchFailed,
                     logWriteFailure: logDispatchLedgerWriteFailure,
                 }) || dispatchSettled;
+                finishIncompleteIteration({
+                    status: "retry",
+                    reason: "finalize-retry",
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                });
                 finishTurn("retry");
                 continue;
             }
@@ -750,10 +847,6 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                     logWriteFailure: logDispatchLedgerWriteFailure,
                 }) || dispatchSettled;
             }
-            // Always emit iteration-end on error so the journal records iteration
-            // completion even on failure (#2344). Without this, errors in
-            // runFinalize leave the journal incomplete, making diagnosis harder.
-            journalReporter.emit("iteration-end", { iteration, error: msg });
             // ── Pre-send model-policy block: not a retryable error (#4959 / #4850) ──
             // The model-policy gate runs before the prompt is sent.  When every
             // candidate model is denied (cross-provider disabled + flat-rate
@@ -778,6 +871,12 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 });
                 ctx.ui.notify(policyDecision.notifyMessage, "error");
                 journalReporter.emit("unit-end", policyDecision.journalData);
+                finishIncompleteIteration({
+                    status: "blocked",
+                    reason: "model-policy-dispatch-blocked",
+                    unitType: loopErr.unitType,
+                    unitId: loopErr.unitId,
+                });
                 // Carry the blocked unit identity into the turn-result observer:
                 // the throw originated inside dispatch, so observedUnitType/Id were
                 // not assigned by the success path at lines 453/631/647 — but the
@@ -790,6 +889,10 @@ export async function autoLoop(ctx, pi, s, deps, options) {
                 // not a transient runtime fault.
                 break;
             }
+            // Always emit iteration-end on error so the journal records iteration
+            // completion even on failure (#2344). Without this, errors in
+            // runFinalize leave the journal incomplete, making diagnosis harder.
+            finishIncompleteIteration({ status: "failed", error: msg });
             // ── Infrastructure errors: immediate stop, no retry ──
             // These are unrecoverable (disk full, OOM, etc.). Retrying just burns
             // LLM budget on guaranteed failures.