gsd-pi 2.45.0 → 2.46.0-dev.cc9d310

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

@@ -19,13 +19,11 @@ import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, } from "./session-forensics.js";
 import { writeLock, clearLock, readCrashLock, isLockProcessAlive, } from "./crash-recovery.js";
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
-import { clearUnitRuntimeRecord, readUnitRuntimeRecord, writeUnitRuntimeRecord, } from "./unit-runtime.js";
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, } from "./auto-budget.js";
 import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
-import { selfHealRuntimeRecords } from "./auto-recovery.js";
 import { selectAndApplyModel, resolveModelId } from "./auto-model-selection.js";
 import { syncProjectRootToWorktree, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree-sync.js";
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
@@ -44,7 +42,7 @@ import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { createAutoWorktree, enterAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, syncWorktreeStateBack, } from "./auto-worktree.js";
 import { pruneQueueOrder } from "./queue-order.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
-import { verifyExpectedArtifact, reconcileMergeState, } from "./auto-recovery.js";
+import { reconcileMergeState, } from "./auto-recovery.js";
 import { resolveDispatch, DISPATCH_RULES } from "./auto-dispatch.js";
 import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
@@ -82,11 +80,10 @@ const s = new AutoSession();
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 export function shouldUseWorktreeIsolation() {
     const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
-    if (prefs?.isolation === "none")
-        return false;
-    if (prefs?.isolation === "branch")
-        return false;
-    return true; // default: worktree
+    if (prefs?.isolation === "worktree")
+        return true;
+    // Default is false — worktree isolation requires explicit opt-in
+    return false;
 }
 /** Crash recovery prompt — set by startAuto, consumed by the main loop */
 /** Pending verification retry — set when gate fails with retries remaining, consumed by autoLoop */
@@ -146,7 +143,6 @@ export function getAutoDashboardData() {
             ? (s.autoStartTime > 0 ? Date.now() - s.autoStartTime : 0)
             : 0,
         currentUnit: s.currentUnit ? { ...s.currentUnit } : null,
-        completedUnits: [...s.completedUnits],
         basePath: s.basePath,
         totalCost: totals?.cost ?? 0,
         totalTokens: totals?.tokens.total ?? 0,
@@ -245,7 +241,6 @@ export function checkRemoteAutoSession(projectRoot) {
         unitType: lock.unitType,
         unitId: lock.unitId,
         startedAt: lock.startedAt,
-        completedUnits: lock.completedUnits,
     };
 }
 export function isStepMode() {
@@ -270,16 +265,12 @@ function clearUnitTimeout() {
     }
     clearInFlightTools();
 }
-/** Build snapshot metric opts, enriching with continueHereFired from the runtime record. */
-function buildSnapshotOpts(unitType, unitId) {
-    const runtime = s.currentUnit
-        ? readUnitRuntimeRecord(s.basePath, unitType, unitId)
-        : null;
+/** Build snapshot metric opts. */
+function buildSnapshotOpts(_unitType, _unitId) {
     return {
         promptCharCount: s.lastPromptCharCount,
         baselineCharCount: s.lastBaselineCharCount,
         ...(s.currentUnitRouting ?? {}),
-        ...(runtime?.continueHereFired ? { continueHereFired: true } : {}),
     };
 }
 function handleLostSessionLock(ctx, lockStatus) {
@@ -587,12 +578,6 @@ export async function pauseAuto(ctx, _pi) {
         catch {
             // Non-fatal — best-effort closeout on pause
         }
-        try {
-            clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
-        }
-        catch {
-            // Non-fatal
-        }
         s.currentUnit = null;
     }
     if (lockBase()) {
@@ -711,9 +696,6 @@ function buildLoopDeps() {
         getMainBranch,
         // Unit closeout + runtime records
         closeoutUnit,
-        verifyExpectedArtifact,
-        clearUnitRuntimeRecord,
-        writeUnitRuntimeRecord,
         recordOutcome,
         writeLock,
         captureAvailableSkills,
@@ -862,15 +844,6 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             });
         }
         invalidateAllCaches();
-        // Clean stale runtime records left from the paused session
-        try {
-            await selfHealRuntimeRecords(s.basePath, ctx);
-        }
-        catch (e) {
-            debugLog("resume-self-heal-runtime-failed", {
-                error: e instanceof Error ? e.message : String(e),
-            });
-        }
         if (s.pausedSessionFile) {
             const activityDir = join(gsdRoot(s.basePath), "activity");
             const recovery = synthesizeCrashRecovery(s.basePath, s.currentUnit?.type ?? "unknown", s.currentUnit?.id ?? "unknown", s.pausedSessionFile ?? undefined, activityDir);
@@ -880,11 +853,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             }
             s.pausedSessionFile = null;
         }
-        updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown", s.completedUnits.length);
-        writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown", s.completedUnits.length);
+        updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
+        writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
-        // Clear orphaned runtime records from prior process deaths before entering the loop
-        await selfHealRuntimeRecords(s.basePath, ctx);
         await autoLoop(ctx, pi, s, buildLoopDeps());
         cleanupAfterLoopExit(ctx);
         return;
@@ -906,8 +877,6 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         // Best-effort only — sidebar sync must never block auto-mode startup
     }
     logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
-    // Clear orphaned runtime records from prior process deaths before entering the loop
-    await selfHealRuntimeRecords(s.basePath, ctx);
     // Dispatch the first unit
     await autoLoop(ctx, pi, s, buildLoopDeps());
     cleanupAfterLoopExit(ctx);
@@ -1006,7 +975,6 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         s.basePath = targetBasePath;
         s.autoStartTime = Date.now();
         s.currentUnit = null;
-        s.completedUnits = [];
         s.pendingQuickTasks = [];
     }
     const hookUnitType = `hook/${hookName}`;
@@ -1026,14 +994,6 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         id: triggerUnitId,
         startedAt: hookStartedAt,
     };
-    writeUnitRuntimeRecord(s.basePath, hookUnitType, triggerUnitId, hookStartedAt, {
-        phase: "dispatched",
-        wrapupWarningSent: false,
-        timeoutAt: null,
-        lastProgressAt: hookStartedAt,
-        progressCount: 0,
-        lastProgressKind: "dispatch",
-    });
     if (hookModel) {
         const availableModels = ctx.modelRegistry.getAvailable();
         const match = resolveModelId(hookModel, availableModels, ctx.model?.provider);
@@ -1051,7 +1011,7 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         }
     }
     const sessionFile = ctx.sessionManager.getSessionFile();
-    writeLock(lockBase(), hookUnitType, triggerUnitId, s.completedUnits.length, sessionFile);
+    writeLock(lockBase(), hookUnitType, triggerUnitId, sessionFile);
     clearUnitTimeout();
     const supervisor = resolveAutoSupervisorConfig();
     const hookHardTimeoutMs = (supervisor.hard_timeout_minutes ?? 30) * 60 * 1000;
@@ -1059,12 +1019,6 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         s.unitTimeoutHandle = null;
         if (!s.active)
             return;
-        if (s.currentUnit) {
-            writeUnitRuntimeRecord(s.basePath, hookUnitType, triggerUnitId, hookStartedAt, {
-                phase: "timeout",
-                timeoutAt: Date.now(),
-            });
-        }
         ctx.ui.notify(`Hook ${hookName} exceeded ${supervisor.hard_timeout_minutes ?? 30}min timeout. Pausing auto-mode.`, "warning");
         resetHookState();
         await pauseAuto(ctx, pi);
@@ -1087,4 +1041,5 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
 // Direct phase dispatch → auto-direct-dispatch.ts
 export { dispatchDirectPhase } from "./auto-direct-dispatch.js";
 // Re-export recovery functions for external consumers
-export { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder, buildLoopRemediationSteps, } from "./auto-recovery.js";
+export { buildLoopRemediationSteps, } from "./auto-recovery.js";
+export { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";

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

@@ -4,6 +4,7 @@ import { findMilestoneIds, nextMilestoneId, claimReservedId, getReservedMileston
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen } from "./dynamic-tools.js";
 import { StringEnum } from "@gsd/pi-ai";
+import { logError } from "../workflow-logger.js";
 /**
  * Register an alias tool that shares the same execute function as its canonical counterpart.
  * The alias description and promptGuidelines direct the LLM to prefer the canonical name.
@@ -45,7 +46,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: gsd_decision_save tool failed: ${msg}\n`);
+            logError("tool", `gsd_decision_save tool failed: ${msg}`, { tool: "gsd_decision_save", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error saving decision: ${msg}` }],
                 details: { operation: "save_decision", error: msg },
@@ -142,7 +143,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: gsd_requirement_update tool failed: ${msg}\n`);
+            logError("tool", `gsd_requirement_update tool failed: ${msg}`, { tool: "gsd_requirement_update", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error updating requirement: ${msg}` }],
                 details: { operation: "update_requirement", id: params.id, error: msg },
@@ -235,7 +236,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: gsd_summary_save tool failed: ${msg}\n`);
+            logError("tool", `gsd_summary_save tool failed: ${msg}`, { tool: "gsd_summary_save", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error saving artifact: ${msg}` }],
                 details: { operation: "save_summary", error: msg },
@@ -394,7 +395,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: plan_milestone tool failed: ${msg}\n`);
+            logError("tool", `plan_milestone tool failed: ${msg}`, { tool: "gsd_plan_milestone", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error planning milestone: ${msg}` }],
                 details: { operation: "plan_milestone", error: msg },
@@ -483,7 +484,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: plan_slice tool failed: ${msg}\n`);
+            logError("tool", `plan_slice tool failed: ${msg}`, { tool: "gsd_plan_slice", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error planning slice: ${msg}` }],
                 details: { operation: "plan_slice", error: msg },
@@ -556,7 +557,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: plan_task tool failed: ${msg}\n`);
+            logError("tool", `plan_task tool failed: ${msg}`, { tool: "gsd_plan_task", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error planning task: ${msg}` }],
                 details: { operation: "plan_task", error: msg },
@@ -622,7 +623,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: complete_task tool failed: ${msg}\n`);
+            logError("tool", `complete_task tool failed: ${msg}`, { tool: "gsd_task_complete", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error completing task: ${msg}` }],
                 details: { operation: "complete_task", error: msg },
@@ -696,7 +697,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: complete_slice tool failed: ${msg}\n`);
+            logError("tool", `complete_slice tool failed: ${msg}`, { tool: "gsd_slice_complete", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error completing slice: ${msg}` }],
                 details: { operation: "complete_slice", error: msg },
@@ -788,7 +789,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: complete_milestone tool failed: ${msg}\n`);
+            logError("tool", `complete_milestone tool failed: ${msg}`, { tool: "gsd_complete_milestone", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error completing milestone: ${msg}` }],
                 details: { operation: "complete_milestone", error: msg },
@@ -804,6 +805,7 @@ export function registerDbTools(pi) {
         promptGuidelines: [
             "Use gsd_complete_milestone when all slices in a milestone are finished and the milestone needs to be recorded.",
             "All slices in the milestone must have status 'complete' — the handler validates this before proceeding.",
+            "verificationPassed must be explicitly set to true — the handler rejects completion if verification did not pass.",
             "On success, returns summaryPath where the MILESTONE-SUMMARY.md was written.",
         ],
         parameters: Type.Object({
@@ -819,6 +821,7 @@ export function registerDbTools(pi) {
             lessonsLearned: Type.Array(Type.String(), { description: "Lessons learned during the milestone" }),
             followUps: Type.Optional(Type.String({ description: "Follow-up items for future milestones" })),
             deviations: Type.Optional(Type.String({ description: "Deviations from the original plan" })),
+            verificationPassed: Type.Boolean({ description: "Must be true — confirms that code change verification, success criteria, and definition of done checks all passed before completion" }),
         }),
         execute: milestoneCompleteExecute,
     };
@@ -854,7 +857,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: validate_milestone tool failed: ${msg}\n`);
+            logError("tool", `validate_milestone tool failed: ${msg}`, { tool: "gsd_validate_milestone", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error validating milestone: ${msg}` }],
                 details: { operation: "validate_milestone", error: msg },
@@ -919,7 +922,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: replan_slice tool failed: ${msg}\n`);
+            logError("tool", `replan_slice tool failed: ${msg}`, { tool: "gsd_replan_slice", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error replanning slice: ${msg}` }],
                 details: { operation: "replan_slice", error: msg },
@@ -992,7 +995,7 @@ export function registerDbTools(pi) {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`gsd-db: reassess_roadmap tool failed: ${msg}\n`);
+            logError("tool", `reassess_roadmap tool failed: ${msg}`, { tool: "gsd_reassess_roadmap", error: String(err) });
             return {
                 content: [{ type: "text", text: `Error reassessing roadmap: ${msg}` }],
                 details: { operation: "reassess_roadmap", error: msg },

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

@@ -4,6 +4,7 @@ import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolve
 import { buildBeforeAgentStartResult } from "./system-context.js";
 import { handleAgentEnd } from "./agent-end-recovery.js";
 import { isDepthVerified, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite } from "./write-gate.js";
+import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
 import { getDiscussionMilestoneId } from "../guided-flow.js";
 import { loadToolApiKeys } from "../commands-config.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
@@ -128,6 +129,23 @@ export function registerHooks(pi) {
         if (loopCheck.block) {
             return { block: true, reason: loopCheck.reason };
         }
+        // ── Single-writer engine: block direct writes to STATE.md ──────────
+        // Covers write, edit, and bash tools to prevent bypass vectors.
+        if (isToolCallEventType("write", event)) {
+            if (isBlockedStateFile(event.input.path)) {
+                return { block: true, reason: BLOCKED_WRITE_ERROR };
+            }
+        }
+        if (isToolCallEventType("edit", event)) {
+            if (isBlockedStateFile(event.input.path)) {
+                return { block: true, reason: BLOCKED_WRITE_ERROR };
+            }
+        }
+        if (isToolCallEventType("bash", event)) {
+            if (isBashWriteToStateFile(event.input.command)) {
+                return { block: true, reason: BLOCKED_WRITE_ERROR };
+            }
+        }
         if (!isToolCallEventType("write", event))
             return;
         const result = shouldBlockContextWrite(event.toolName, event.input.path, getDiscussionMilestoneId(), isDepthVerified(), isQueuePhaseActive());

package/dist/resources/extensions/gsd/commands/context.js

@@ -30,14 +30,10 @@ export async function guardRemoteSession(ctx, pi) {
             `Stop it first with /gsd stop, or use /gsd steer to redirect it.`, "warning");
         return false;
     }
-    const unitsMsg = remote.completedUnits != null
-        ? `${remote.completedUnits} units completed`
-        : "";
     const choice = await showNextAction(ctx, {
         title: `Auto-mode is running in another terminal (PID ${remote.pid})`,
         summary: [
             `Currently executing: ${unitLabel}`,
-            ...(unitsMsg ? [unitsMsg] : []),
             ...(remote.startedAt ? [`Started: ${remote.startedAt}`] : []),
         ],
         actions: [

package/dist/resources/extensions/gsd/commands/handlers/parallel.js

@@ -44,7 +44,7 @@ export async function handleParallelCommand(trimmed, _ctx, pi) {
         }
         const lines = ["# Parallel Workers\n"];
         for (const worker of workers) {
-            lines.push(`- **${worker.milestoneId}** (${worker.title}) — ${worker.state} — ${worker.completedUnits} units — $${worker.cost.toFixed(2)}`);
+            lines.push(`- **${worker.milestoneId}** (${worker.title}) — ${worker.state} — $${worker.cost.toFixed(2)}`);
         }
         const state = getOrchestratorState();
         if (state) {

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

@@ -18,7 +18,7 @@ function lockPath(basePath) {
     return join(gsdRoot(basePath), LOCK_FILE);
 }
 /** Write or update the lock file with current auto-mode state. */
-export function writeLock(basePath, unitType, unitId, completedUnits, sessionFile) {
+export function writeLock(basePath, unitType, unitId, sessionFile) {
     try {
         const data = {
             pid: process.pid,
@@ -26,7 +26,6 @@ export function writeLock(basePath, unitType, unitId, completedUnits, sessionFil
             unitType,
             unitId,
             unitStartedAt: new Date().toISOString(),
-            completedUnits,
             sessionFile,
         };
         const lp = lockPath(basePath);
@@ -90,11 +89,10 @@ export function formatCrashInfo(lock) {
         `Previous auto-mode session was interrupted.`,
         `  Was executing: ${lock.unitType} (${lock.unitId})`,
         `  Started at: ${lock.unitStartedAt}`,
-        `  Units completed before crash: ${lock.completedUnits}`,
         `  PID: ${lock.pid}`,
     ];
     // Add recovery guidance based on what was happening when it crashed
-    if (lock.unitType === "starting" && lock.unitId === "bootstrap" && lock.completedUnits === 0) {
+    if (lock.unitType === "starting" && lock.unitId === "bootstrap") {
         lines.push(`No work was lost. Run /gsd auto to restart.`);
     }
     else if (lock.unitType.includes("research") || lock.unitType.includes("plan")) {

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -81,18 +81,11 @@ export class GSDDashboardOverlay {
         const currentUnit = dashData.currentUnit
             ? `${dashData.currentUnit.type}:${dashData.currentUnit.id}:${dashData.currentUnit.startedAt}`
             : "-";
-        const lastCompleted = dashData.completedUnits.length > 0
-            ? dashData.completedUnits[dashData.completedUnits.length - 1]
-            : null;
-        const completedKey = lastCompleted
-            ? `${dashData.completedUnits.length}:${lastCompleted.type}:${lastCompleted.id}:${lastCompleted.finishedAt}`
-            : "0";
         return [
             base,
             dashData.active ? "1" : "0",
             dashData.paused ? "1" : "0",
             currentUnit,
-            completedKey,
         ].join("|");
     }
     async refreshDashboard(initial = false) {
@@ -393,43 +386,6 @@ export class GSDDashboardOverlay {
         else {
             lines.push(centered(th.fg("dim", "No active milestone.")));
         }
-        if (this.dashData.completedUnits.length > 0) {
-            lines.push(blank());
-            lines.push(hr());
-            lines.push(row(th.fg("text", th.bold("Completed"))));
-            lines.push(blank());
-            // Build ledger lookup for budget indicators (last entry wins for retries)
-            const ledgerLookup = new Map();
-            const currentLedger = getLedger();
-            if (currentLedger) {
-                for (const lu of currentLedger.units) {
-                    ledgerLookup.set(`${lu.type}:${lu.id}`, lu);
-                }
-            }
-            const recent = [...this.dashData.completedUnits].reverse().slice(0, 10);
-            for (const u of recent) {
-                // Budget indicators from ledger — use warning glyph for pressured units
-                const ledgerEntry = ledgerLookup.get(`${u.type}:${u.id}`);
-                const hadPressure = ledgerEntry?.continueHereFired === true;
-                const hadTruncation = (ledgerEntry?.truncationSections ?? 0) > 0;
-                const unitGlyph = hadPressure
-                    ? th.fg(STATUS_COLOR.warning, STATUS_GLYPH.warning)
-                    : th.fg(STATUS_COLOR.done, STATUS_GLYPH.done);
-                const left = `  ${unitGlyph} ${th.fg("muted", unitLabel(u.type))} ${th.fg("muted", u.id)}`;
-                let budgetMarkers = "";
-                if (hadTruncation) {
-                    budgetMarkers += th.fg("warning", ` ▼${ledgerEntry.truncationSections}`);
-                }
-                if (hadPressure) {
-                    budgetMarkers += th.fg("error", " → wrap-up");
-                }
-                const right = th.fg("dim", formatDuration(u.finishedAt - u.startedAt));
-                lines.push(row(joinColumns(`${left}${budgetMarkers}`, right, contentWidth)));
-            }
-            if (this.dashData.completedUnits.length > 10) {
-                lines.push(row(th.fg("dim", `  ...and ${this.dashData.completedUnits.length - 10} more`)));
-            }
-        }
         const ledger = getLedger();
         if (ledger && ledger.units.length > 0) {
             const totals = getProjectTotals(ledger.units);

package/dist/resources/extensions/gsd/db-writer.js

@@ -12,6 +12,7 @@ import { readFileSync, existsSync, statSync } from 'node:fs';
 import { resolveGsdRootFile } from './paths.js';
 import { saveFile } from './files.js';
 import { GSDError, GSD_STALE_STATE, GSD_IO_ERROR } from './errors.js';
+import { logWarning, logError } from './workflow-logger.js';
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
 import { clearParseCache } from './files.js';
@@ -200,7 +201,7 @@ export async function nextDecisionId() {
         return `D${String(next).padStart(3, '0')}`;
     }
     catch (err) {
-        process.stderr.write(`gsd-db: nextDecisionId failed: ${err.message}\n`);
+        logError('manifest', 'nextDecisionId failed', { fn: 'nextDecisionId', error: String(err.message) });
         return 'D001';
     }
 }
@@ -269,7 +270,7 @@ export async function saveDecisionToDb(fields, basePath) {
             await saveFile(filePath, md);
         }
         catch (diskErr) {
-            process.stderr.write(`gsd-db: saveDecisionToDb — disk write failed, rolling back DB row: ${diskErr.message}\n`);
+            logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String(diskErr.message) });
             adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
             throw diskErr;
         }
@@ -281,7 +282,7 @@ export async function saveDecisionToDb(fields, basePath) {
         return { id };
     }
     catch (err) {
-        process.stderr.write(`gsd-db: saveDecisionToDb failed: ${err.message}\n`);
+        logError('manifest', 'saveDecisionToDb failed', { fn: 'saveDecisionToDb', error: String(err.message) });
         throw err;
     }
 }
@@ -333,7 +334,7 @@ export async function updateRequirementInDb(id, updates, basePath) {
             await saveFile(filePath, md);
         }
         catch (diskErr) {
-            process.stderr.write(`gsd-db: updateRequirementInDb — disk write failed, reverting DB row: ${diskErr.message}\n`);
+            logError('manifest', 'disk write failed, reverting DB row', { fn: 'updateRequirementInDb', error: String(diskErr.message) });
             db.upsertRequirement(existing);
             throw diskErr;
         }
@@ -344,7 +345,7 @@ export async function updateRequirementInDb(id, updates, basePath) {
         clearParseCache();
     }
     catch (err) {
-        process.stderr.write(`gsd-db: updateRequirementInDb failed: ${err.message}\n`);
+        logError('manifest', 'updateRequirementInDb failed', { fn: 'updateRequirementInDb', error: String(err.message) });
         throw err;
     }
 }
@@ -371,8 +372,7 @@ export async function saveArtifactToDb(opts, basePath) {
             const existingSize = statSync(fullPath).size;
             const newSize = Buffer.byteLength(opts.content, 'utf-8');
             if (existingSize > 0 && newSize < existingSize * 0.5) {
-                process.stderr.write(`gsd-db: saveArtifactToDb — new content (${newSize}B) is <50% of existing file ` +
-                    `(${existingSize}B) at ${opts.path}. Preserving disk file to prevent data loss.\n`);
+                logWarning('manifest', `new content (${newSize}B) is <50% of existing file (${existingSize}B), preserving disk file`, { fn: 'saveArtifactToDb', path: opts.path });
                 dbContent = readFileSync(fullPath, 'utf-8');
                 skipDiskWrite = true;
             }
@@ -391,7 +391,7 @@ export async function saveArtifactToDb(opts, basePath) {
                 await saveFile(fullPath, opts.content);
             }
             catch (diskErr) {
-                process.stderr.write(`gsd-db: saveArtifactToDb — disk write failed, rolling back DB row: ${diskErr.message}\n`);
+                logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveArtifactToDb', error: String(diskErr.message) });
                 const rollbackAdapter = db._getAdapter();
                 rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
                 throw diskErr;
@@ -404,7 +404,7 @@ export async function saveArtifactToDb(opts, basePath) {
         clearParseCache();
     }
     catch (err) {
-        process.stderr.write(`gsd-db: saveArtifactToDb failed: ${err.message}\n`);
+        logError('manifest', 'saveArtifactToDb failed', { fn: 'saveArtifactToDb', error: String(err.message) });
         throw err;
     }
 }