gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.b741afb

package/dist/cli.js

@@ -141,6 +141,91 @@ if (cliFlags.messages[0] === 'update') {
     await runUpdate();
     process.exit(0);
 }
+// ---------------------------------------------------------------------------
+// Graph subcommand — `gsd graph build|status|query|diff`
+// ---------------------------------------------------------------------------
+if (cliFlags.messages[0] === 'graph') {
+    const sub = cliFlags.messages[1];
+    const { buildGraph, writeGraph, graphStatus, graphQuery, graphDiff, resolveGsdRoot } = await import('@gsd-build/mcp-server');
+    const projectDir = process.cwd();
+    const gsdRoot = resolveGsdRoot(projectDir);
+    if (!sub || sub === 'build') {
+        try {
+            const graph = await buildGraph(projectDir);
+            await writeGraph(gsdRoot, graph);
+            process.stdout.write(`Graph built: ${graph.nodes.length} nodes, ${graph.edges.length} edges\n`);
+        }
+        catch (err) {
+            process.stderr.write(`[gsd] graph build failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }
+    else if (sub === 'status') {
+        try {
+            const result = await graphStatus(projectDir);
+            if (!result.exists) {
+                process.stdout.write('Graph: not built yet. Run: gsd graph build\n');
+            }
+            else {
+                process.stdout.write(`Graph status:\n`);
+                process.stdout.write(`  exists:    ${result.exists}\n`);
+                process.stdout.write(`  nodes:     ${result.nodeCount}\n`);
+                process.stdout.write(`  edges:     ${result.edgeCount}\n`);
+                process.stdout.write(`  stale:     ${result.stale}\n`);
+                process.stdout.write(`  ageHours:  ${result.ageHours !== undefined ? result.ageHours.toFixed(2) : 'n/a'}\n`);
+                process.stdout.write(`  lastBuild: ${result.lastBuild ?? 'n/a'}\n`);
+            }
+        }
+        catch (err) {
+            process.stderr.write(`[gsd] graph status failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }
+    else if (sub === 'query') {
+        const term = cliFlags.messages[2];
+        if (!term) {
+            process.stderr.write('Usage: gsd graph query <term>\n');
+            process.exit(1);
+        }
+        try {
+            const result = await graphQuery(projectDir, term);
+            if (result.nodes.length === 0) {
+                process.stdout.write(`No nodes found for term: "${term}"\n`);
+            }
+            else {
+                process.stdout.write(`Query results for "${term}" (${result.nodes.length} nodes, ${result.edges.length} edges):\n`);
+                for (const node of result.nodes) {
+                    process.stdout.write(`  [${node.type}] ${node.label} (${node.confidence})\n`);
+                }
+            }
+        }
+        catch (err) {
+            process.stderr.write(`[gsd] graph query failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }
+    else if (sub === 'diff') {
+        try {
+            const result = await graphDiff(projectDir);
+            process.stdout.write(`Graph diff:\n`);
+            process.stdout.write(`  nodes added:    ${result.nodes.added.length}\n`);
+            process.stdout.write(`  nodes removed:  ${result.nodes.removed.length}\n`);
+            process.stdout.write(`  nodes changed:  ${result.nodes.changed.length}\n`);
+            process.stdout.write(`  edges added:    ${result.edges.added.length}\n`);
+            process.stdout.write(`  edges removed:  ${result.edges.removed.length}\n`);
+        }
+        catch (err) {
+            process.stderr.write(`[gsd] graph diff failed: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+    }
+    else {
+        process.stderr.write(`Unknown graph command: ${sub}\n`);
+        process.stderr.write('Commands: build, status, query <term>, diff\n');
+        process.exit(1);
+    }
+    process.exit(0);
+}
 exitIfManagedResourcesAreNewer(agentDir);
 // Early TTY check — must come before heavy initialization to avoid dangling
 // handles that prevent process.exit() from completing promptly.

package/dist/headless-query.js

@@ -33,7 +33,9 @@ async function loadExtensionModules() {
     const dispatchModule = await jiti.import(gsdExtensionPath('auto-dispatch.ts'), {});
     const sessionModule = await jiti.import(gsdExtensionPath('session-status-io.ts'), {});
     const prefsModule = await jiti.import(gsdExtensionPath('preferences.ts'), {});
+    const autoStartModule = await jiti.import(gsdExtensionPath('auto-start.ts'), {});
     return {
+        openProjectDbIfPresent: autoStartModule.openProjectDbIfPresent,
         deriveState: stateModule.deriveState,
         resolveDispatch: dispatchModule.resolveDispatch,
         readAllSessionStatuses: sessionModule.readAllSessionStatuses,
@@ -42,7 +44,8 @@ async function loadExtensionModules() {
 }
 // ─── Implementation ─────────────────────────────────────────────────────────
 export async function handleQuery(basePath) {
-    const { deriveState, resolveDispatch, readAllSessionStatuses, loadEffectiveGSDPreferences } = await loadExtensionModules();
+    const { openProjectDbIfPresent, deriveState, resolveDispatch, readAllSessionStatuses, loadEffectiveGSDPreferences, } = await loadExtensionModules();
+    await openProjectDbIfPresent(basePath);
     const state = await deriveState(basePath);
     // Derive next dispatch action
     let next;

package/dist/help-text.js

@@ -84,6 +84,28 @@ const SUBCOMMAND_HELP = {
         '  gsd worktree remove old-branch      Remove a specific worktree',
         '  gsd worktree remove old-branch --force  Remove even with unmerged changes',
     ].join('\n'),
+    graph: [
+        'Usage: gsd graph <subcommand> [options]',
+        '',
+        'Manage the GSD project knowledge graph. Reads .gsd/ artifacts and builds',
+        'a queryable graph of milestones, slices, tasks, rules, patterns, and lessons.',
+        '',
+        'Subcommands:',
+        '  build   Parse .gsd/ artifacts (STATE.md, milestone ROADMAPs, slice PLANs,',
+        '          KNOWLEDGE.md) and write .gsd/graphs/graph.json atomically.',
+        '  query   Search graph nodes by term (BFS from seed matches, budget-trimmed).',
+        '          Returns matching nodes and reachable edges within the token budget.',
+        '  status  Show whether graph.json exists, its age, node/edge counts, and',
+        '          whether it is stale (built more than 24 hours ago).',
+        '  diff    Compare current graph.json with .last-build-snapshot.json.',
+        '          Returns added, removed, and changed nodes and edges.',
+        '',
+        'Examples:',
+        '  gsd graph build                        Build the graph from .gsd/ artifacts',
+        '  gsd graph status                       Check graph age and node/edge counts',
+        '  gsd graph query auth                   Find nodes related to "auth"',
+        '  gsd graph diff                         Show changes since last snapshot',
+    ].join('\n'),
     headless: [
         'Usage: gsd headless [flags] [command] [args...]',
         '',
@@ -165,6 +187,7 @@ export function printHelp(version) {
     process.stdout.write('  worktree <cmd>           Manage worktrees (list, merge, clean, remove)\n');
     process.stdout.write('  auto [args]              Run auto-mode without TUI (pipeable)\n');
     process.stdout.write('  headless [cmd] [args]    Run /gsd commands without TUI (default: auto)\n');
+    process.stdout.write('  graph <subcommand>       Manage knowledge graph (build, query, status, diff)\n');
     process.stdout.write('\nRun gsd <subcommand> --help for subcommand-specific help.\n');
 }
 export function printSubcommandHelp(subcommand, version) {

package/dist/resources/extensions/gsd/auto/detect-stuck.js

@@ -3,6 +3,7 @@
  *
  * Leaf node in the import DAG.
  */
+import { summarizeLogs } from "../workflow-logger.js";
 /**
  * Pattern matching ENOENT errors with a file path.
  * Matches: "ENOENT: no such file or directory, access '/path/to/file'"
@@ -22,13 +23,19 @@ const ENOENT_PATH_RE = /ENOENT[^']*'([^']+)'/;
 export function detectStuck(window) {
     if (window.length < 2)
         return null;
+    // Peek (not drain) the workflow-logger buffer so stuck reasons can surface
+    // the underlying diagnostic context (projection failures, DB degradations,
+    // reconcile warnings) that usually explains *why* the loop is stuck. The
+    // auto-loop's finalize step owns the buffer lifecycle — this is read-only.
+    const loggerSummary = summarizeLogs();
+    const suffix = loggerSummary ? ` — ${loggerSummary}` : "";
     const last = window[window.length - 1];
     const prev = window[window.length - 2];
     // Rule 1: Same error repeated consecutively
     if (last.error && prev.error && last.error === prev.error) {
         return {
             stuck: true,
-            reason: `Same error repeated: ${last.error.slice(0, 200)}`,
+            reason: `Same error repeated: ${last.error.slice(0, 200)}${suffix}`,
         };
     }
     // Rule 2: Same unit 3+ consecutive times
@@ -37,7 +44,7 @@ export function detectStuck(window) {
         if (lastThree.every((u) => u.key === last.key)) {
             return {
                 stuck: true,
-                reason: `${last.key} derived 3 consecutive times without progress`,
+                reason: `${last.key} derived 3 consecutive times without progress${suffix}`,
             };
         }
     }
@@ -49,7 +56,7 @@ export function detectStuck(window) {
             w[0].key !== w[1].key) {
             return {
                 stuck: true,
-                reason: `Oscillation detected: ${w[0].key} ↔ ${w[1].key}`,
+                reason: `Oscillation detected: ${w[0].key} ↔ ${w[1].key}${suffix}`,
             };
         }
     }
@@ -67,7 +74,7 @@ export function detectStuck(window) {
         if (count >= 2) {
             return {
                 stuck: true,
-                reason: `Missing file referenced twice: ${filePath} (ENOENT)`,
+                reason: `Missing file referenced twice: ${filePath} (ENOENT)${suffix}`,
             };
         }
         enoentPaths.set(filePath, count);

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

@@ -16,7 +16,7 @@ import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
 import { join, basename, dirname, parse as parsePath } from "node:path";
 import { existsSync, cpSync, readdirSync } from "node:fs";
-import { logWarning, logError } from "../workflow-logger.js";
+import { logWarning, logError, _resetLogs, drainLogs, drainAndSummarize, formatForNotification, hasAnyIssues, } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
 import { verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.js";
@@ -100,6 +100,22 @@ async function closeoutAndStop(ctx, pi, s, deps, reason) {
     }
     await deps.stopAuto(ctx, pi, reason);
 }
+async function emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, errorContext) {
+    ic.deps.emitJournalEvent({
+        ts: new Date().toISOString(),
+        flowId: ic.flowId,
+        seq: ic.nextSeq(),
+        eventType: "unit-end",
+        data: {
+            unitType,
+            unitId,
+            status: "cancelled",
+            artifactVerified: false,
+            ...(errorContext ? { errorContext } : {}),
+        },
+        causedBy: { flowId: ic.flowId, seq: unitStartSeq },
+    });
+}
 // ─── runPreDispatch ───────────────────────────────────────────────────────────
 /**
  * Phase 1: Pre-dispatch — resource guard, health gate, state derivation,
@@ -776,6 +792,10 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.currentUnit.type === unitType &&
         s.currentUnit.id === unitId);
     const previousTier = s.currentUnitRouting?.tier;
+    // Scope workflow-logger buffer to this unit so post-finalize drains are
+    // per-unit. Without this, the module-level _buffer accumulates across every
+    // unit in the same Node process (see workflow-logger.ts module header).
+    _resetLogs();
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
     setCurrentPhase(unitType);
     s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
@@ -975,6 +995,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         // Provider-error pause: pauseAuto already handled cleanup and scheduled
         // recovery. Don't hard-stop — just break out of the loop (#2762).
         if (unitResult.errorContext?.category === "provider") {
+            await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
             debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext.isTransient });
             return { action: "break", reason: "provider-pause" };
         }
@@ -988,9 +1009,16 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             ctx.ui.notify(`Session creation timed out for ${unitType} ${unitId}. Pausing auto-mode (recoverable).`, "warning");
             debugLog("autoLoop", { phase: "session-timeout-pause", unitType, unitId });
             await deps.pauseAuto(ctx, pi);
+            await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
+            await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
             return { action: "break", reason: "session-timeout" };
         }
         // All other cancelled states (structural errors, non-transient failures): hard stop
+        if (s.currentUnit) {
+            await deps.closeoutUnit(ctx, s.basePath, unitType, unitId, s.currentUnit.startedAt, deps.buildSnapshotOpts(unitType, unitId));
+        }
+        await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
+        await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
         ctx.ui.notify(`Session creation failed for ${unitType} ${unitId}: ${unitResult.errorContext?.message ?? "unknown"}. Stopping auto-mode.`, "warning");
         await deps.stopAuto(ctx, pi, `Session creation failed: ${unitResult.errorContext?.message ?? "unknown"}`);
         debugLog("autoLoop", { phase: "exit", reason: "session-failed" });
@@ -1124,6 +1152,9 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
         // cannot mutate state for the next unit (#3757).
         s.currentUnit = null;
         clearCurrentPhase();
+        // Drop any logger entries from the timed-out unit so they don't bleed
+        // into the next iteration's drain.
+        drainLogs();
         loopState.consecutiveFinalizeTimeouts++;
         debugLog("autoLoop", {
             phase: "pre-verification-timeout",
@@ -1199,6 +1230,9 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
         // cannot mutate state for the next unit (#3757).
         s.currentUnit = null;
         clearCurrentPhase();
+        // Drop any logger entries from the timed-out unit so they don't bleed
+        // into the next iteration's drain.
+        drainLogs();
         loopState.consecutiveFinalizeTimeouts++;
         debugLog("autoLoop", {
             phase: "post-verification-timeout",
@@ -1230,5 +1264,15 @@ export async function runFinalize(ic, iterData, loopState, sidecarItem) {
     }
     // Both pre and post verification completed without timeout — reset counter
     loopState.consecutiveFinalizeTimeouts = 0;
+    // Surface accumulated workflow-logger issues for this unit to the user.
+    // Warnings/errors logged during the unit are buffered in the logger and
+    // drained here so the user sees a single consolidated post-unit alert.
+    if (hasAnyIssues()) {
+        const { logs } = drainAndSummarize();
+        if (logs.length > 0) {
+            const severity = logs.some((e) => e.severity === "error") ? "error" : "warning";
+            ctx.ui.notify(formatForNotification(logs), severity);
+        }
+    }
     return { action: "next", data: undefined };
 }

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

@@ -189,6 +189,57 @@ export function buildStepCompleteMessage(nextState) {
     return `Step complete. Next: ${next.label}\n`
         + `Run /clear, then /gsd to continue (or /gsd auto to run continuously).`;
 }
+export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
+    try {
+        let taskContext;
+        if (unitType === "execute-task") {
+            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+            if (mid && sid && tid) {
+                const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+                if (summaryPath) {
+                    try {
+                        const summaryContent = await loadFile(summaryPath);
+                        if (summaryContent) {
+                            const summary = parseSummary(summaryContent);
+                            let ghIssueNumber;
+                            try {
+                                const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+                                ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
+                            }
+                            catch (err) {
+                                logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+                            }
+                            taskContext = {
+                                taskId: `${sid}/${tid}`,
+                                taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
+                                oneLiner: summary.oneLiner || undefined,
+                                keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                                issueNumber: ghIssueNumber,
+                            };
+                        }
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
+                    }
+                }
+            }
+        }
+        _resetHasChangesCache();
+        if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
+            return null;
+        }
+        const commitMsg = autoCommitCurrentBranch(basePath, unitType, unitId, taskContext);
+        if (commitMsg) {
+            ctx?.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+        }
+        return commitMsg;
+    }
+    catch (e) {
+        debugLog("postUnit", { phase: "auto-commit", error: String(e) });
+        ctx?.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
+        return null;
+    }
+}
 /**
  * Pre-verification processing: parallel worker signal check, cache invalidation,
  * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
@@ -224,62 +275,7 @@ export async function postUnitPreVerification(pctx, opts) {
     // Auto-commit
     if (s.currentUnit) {
         const unit = s.currentUnit;
-        try {
-            let taskContext;
-            if (s.currentUnit.type === "execute-task") {
-                const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
-                if (mid && sid && tid) {
-                    const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
-                    if (summaryPath) {
-                        try {
-                            const summaryContent = await loadFile(summaryPath);
-                            if (summaryContent) {
-                                const summary = parseSummary(summaryContent);
-                                // Look up GitHub issue number for commit linking
-                                let ghIssueNumber;
-                                try {
-                                    const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
-                                    ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
-                                }
-                                catch (err) {
-                                    // GitHub sync not available — skip
-                                    logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-                                }
-                                taskContext = {
-                                    taskId: `${sid}/${tid}`,
-                                    taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
-                                    oneLiner: summary.oneLiner || undefined,
-                                    keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
-                                    issueNumber: ghIssueNumber,
-                                };
-                            }
-                        }
-                        catch (e) {
-                            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-                        }
-                    }
-                }
-            }
-            // Invalidate the nativeHasChanges cache before auto-commit (#1853).
-            // The cache has a 10-second TTL and is keyed by basePath.  A stale
-            // `false` result causes autoCommit to skip staging entirely, leaving
-            // code files only in the working tree where they are destroyed by
-            // `git worktree remove --force` during teardown.
-            _resetHasChangesCache();
-            // Skip auto-commit for lifecycle-only units (#2553) — they only touch
-            // `.gsd/` internal state files. Those files are picked up by the next
-            // actual task commit via smartStage().
-            if (!LIFECYCLE_ONLY_UNITS.has(s.currentUnit.type)) {
-                const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
-                if (commitMsg) {
-                    ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
-                }
-            }
-        }
-        catch (e) {
-            debugLog("postUnit", { phase: "auto-commit", error: String(e) });
-            ctx.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
-        }
+        await autoCommitUnit(s.basePath, unit.type, unit.id, ctx);
         // GitHub sync (non-blocking, opt-in)
         await runSafely("postUnit", "github-sync", async () => {
             const { runGitHubSync } = await import("../github-sync/sync.js");

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

@@ -20,6 +20,7 @@ import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { logWarning } from "./workflow-logger.js";
+import { inlineGraphSubgraph } from "./graph-context.js";
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 const MAX_PREAMBLE_CHARS = 30_000;
 function capPreamble(preamble) {
@@ -1040,6 +1041,10 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
     const knowledgeInlineRS = await inlineKnowledgeScoped(base, keywords);
     if (knowledgeInlineRS)
         inlined.push(knowledgeInlineRS);
+    // Knowledge graph: subgraph for this slice (graceful — skipped if no graph.json)
+    const graphBlockRS = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
+    if (graphBlockRS)
+        inlined.push(graphBlockRS);
     inlined.push(inlineTemplate("research", "Research"));
     const depContent = await inlineDependencySummaries(mid, sid, base);
     const activeOverrides = await loadActiveOverrides(base);
@@ -1111,6 +1116,10 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     const knowledgeInlinePS = await inlineKnowledgeScoped(base, keywordsPS);
     if (knowledgeInlinePS)
         inlined.push(knowledgeInlinePS);
+    // Knowledge graph: subgraph for this slice (graceful — skipped if no graph.json)
+    const graphBlockPS = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
+    if (graphBlockPS)
+        inlined.push(graphBlockPS);
     inlined.push(inlineTemplate("plan", "Slice Plan"));
     if (inlineLevel === "full") {
         inlined.push(inlineTemplate("task-plan", "Task Plan"));
@@ -1194,12 +1203,15 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         : null;
     // Only include if it has content (not a "not found" result)
     const knowledgeContent = knowledgeInlineET && !knowledgeInlineET.includes("not found") ? knowledgeInlineET : null;
+    // Knowledge graph: tight subgraph for this task (graceful — skipped if no graph.json)
+    const graphBlockET = await inlineGraphSubgraph(base, `${tid} ${tTitle}`, { budget: 2000 });
     const inlinedTemplates = inlineLevel === "minimal"
         ? inlineTemplate("task-summary", "Task Summary")
         : [
             inlineTemplate("task-summary", "Task Summary"),
             inlineTemplate("decisions", "Decisions"),
             ...(knowledgeContent ? [knowledgeContent] : []),
+            ...(graphBlockET ? [graphBlockET] : []),
         ].join("\n\n---\n\n");
     const taskSummaryPath = join(base, `${relSlicePath(base, mid, sid)}/tasks/${tid}-SUMMARY.md`);
     const activeOverrides = await loadActiveOverrides(base);

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

@@ -36,7 +36,7 @@ import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { deactivateGSD } from "../shared/gsd-phase-state.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
-import { logWarning } from "./workflow-logger.js";
+import { setLogBasePath, logWarning } from "./workflow-logger.js";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -61,7 +61,7 @@ import { clearCmuxSidebar, logCmuxEvent, syncCmuxSidebar } from "../cmux/index.j
 // ── Extracted modules ──────────────────────────────────────────────────────
 import { startUnitSupervision } from "./auto-timers.js";
 import { runPostUnitVerification } from "./auto-verification.js";
-import { postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
+import { autoCommitUnit, postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
 import { bootstrapAutoSession, openProjectDbIfPresent } from "./auto-start.js";
 import { initHealthWidget } from "./health-widget.js";
 import { autoLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto-loop.js";
@@ -884,6 +884,7 @@ function buildLoopDeps() {
         getMainBranch,
         // Unit closeout + runtime records
         closeoutUnit,
+        autoCommitUnit,
         recordOutcome,
         writeLock,
         captureAvailableSkills,
@@ -1081,6 +1082,11 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.stepMode = requestedStepMode;
         s.cmdCtx = ctx;
         s.basePath = base;
+        // Ensure the workflow-logger audit log is pinned to the project root
+        // even when auto-mode is entered via a path that bypasses the
+        // bootstrap/dynamic-tools ensureDbOpen() → setLogBasePath() chain
+        // (e.g. /clear resume, hot-reload).
+        setLogBasePath(base);
         s.unitDispatchCount.clear();
         s.unitLifetimeDispatches.clear();
         if (!getLedger())

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

@@ -1,5 +1,4 @@
 // GSD2 — Extension registration: wires all GSD tools, commands, and hooks into pi
-import { registerGSDCommand } from "../commands.js";
 import { registerExitCommand } from "../exit-command.js";
 import { registerWorktreeCommand } from "../worktree-command.js";
 import { registerDbTools } from "./db-tools.js";
@@ -9,6 +8,7 @@ import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 import { writeCrashLog } from "./crash-log.js";
+import { logWarning } from "../workflow-logger.js";
 export { writeCrashLog } from "./crash-log.js";
 export function handleRecoverableExtensionProcessError(err) {
     if (err.code === "EPIPE") {
@@ -52,7 +52,8 @@ function installEpipeGuard() {
     }
 }
 export function registerGsdExtension(pi) {
-    registerGSDCommand(pi);
+    // Note: registerGSDCommand is called by index.ts before this function,
+    // so we intentionally skip it here to avoid double-registration.
     registerWorktreeCommand(pi);
     registerExitCommand(pi);
     installEpipeGuard();
@@ -62,10 +63,22 @@ export function registerGsdExtension(pi) {
             process.exit(0);
         },
     });
-    registerDynamicTools(pi);
-    registerDbTools(pi);
-    registerJournalTools(pi);
-    registerQueryTools(pi);
-    registerShortcuts(pi);
-    registerHooks(pi);
+    // Wrap non-critical registrations individually so one failure
+    // doesn't prevent the others from loading.
+    const nonCriticalRegistrations = [
+        ["dynamic-tools", () => registerDynamicTools(pi)],
+        ["db-tools", () => registerDbTools(pi)],
+        ["journal-tools", () => registerJournalTools(pi)],
+        ["query-tools", () => registerQueryTools(pi)],
+        ["shortcuts", () => registerShortcuts(pi)],
+        ["hooks", () => registerHooks(pi)],
+    ];
+    for (const [name, register] of nonCriticalRegistrations) {
+        try {
+            register();
+        }
+        catch (err) {
+            logWarning("bootstrap", `Failed to register ${name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
 }

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

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { resolveProjectRoot } from "../worktree.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase|notifications";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -62,6 +62,12 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "rethink", desc: "Conversational project reorganization — reorder, park, discard, add milestones" },
     { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, validate, pause, resume)" },
     { cmd: "codebase", desc: "Generate, refresh, and inspect the codebase map cache (.gsd/CODEBASE.md)" },
+    { cmd: "ship", desc: "Create PR from milestone artifacts and open for review" },
+    { cmd: "do", desc: "Route freeform text to the right GSD command" },
+    { cmd: "session-report", desc: "Session cost, tokens, and work summary" },
+    { cmd: "backlog", desc: "Manage backlog items (add, promote, remove, list)" },
+    { cmd: "pr-branch", desc: "Create clean PR branch filtering .gsd/ commits" },
+    { cmd: "add-tests", desc: "Generate tests for completed slices" },
 ];
 const NESTED_COMPLETIONS = {
     auto: [
@@ -231,6 +237,25 @@ const NESTED_COMPLETIONS = {
         { cmd: "stats", desc: "Show file count, description coverage, and generation time" },
         { cmd: "help", desc: "Show usage and available subcommands" },
     ],
+    ship: [
+        { cmd: "--dry-run", desc: "Preview PR without creating" },
+        { cmd: "--draft", desc: "Open as draft PR" },
+        { cmd: "--base", desc: "Override target branch (default: main)" },
+        { cmd: "--force", desc: "Ship even with pending tasks" },
+    ],
+    "session-report": [
+        { cmd: "--json", desc: "Machine-readable JSON output" },
+        { cmd: "--save", desc: "Save report to .gsd/reports/" },
+    ],
+    backlog: [
+        { cmd: "add", desc: "Add item to backlog" },
+        { cmd: "promote", desc: "Promote backlog item to active slice" },
+        { cmd: "remove", desc: "Remove backlog item" },
+    ],
+    "pr-branch": [
+        { cmd: "--dry-run", desc: "Preview what would be filtered" },
+        { cmd: "--name", desc: "Custom branch name" },
+    ],
 };
 function filterOptions(partial, options, prefix = "") {
     const normalizedPrefix = prefix ? `${prefix} ` : "";

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

@@ -8,6 +8,9 @@ import { handleExport } from "../../export.js";
 import { handleHistory } from "../../history.js";
 import { handleUndo } from "../../undo.js";
 import { handleRemote } from "../../../remote-questions/mod.js";
+import { handleShip } from "../../commands-ship.js";
+import { handleSessionReport } from "../../commands-session-report.js";
+import { handlePrBranch } from "../../commands-pr-branch.js";
 import { projectRoot } from "../context.js";
 export async function handleOpsCommand(trimmed, ctx, pi) {
     if (trimmed === "init") {
@@ -213,5 +216,22 @@ Examples:
         await handleCodebase(trimmed.replace(/^codebase\s*/, "").trim(), ctx, pi);
         return true;
     }
+    if (trimmed === "ship" || trimmed.startsWith("ship ")) {
+        await handleShip(trimmed.replace(/^ship\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "session-report" || trimmed.startsWith("session-report ")) {
+        await handleSessionReport(trimmed.replace(/^session-report\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "pr-branch" || trimmed.startsWith("pr-branch ")) {
+        await handlePrBranch(trimmed.replace(/^pr-branch\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "add-tests" || trimmed.startsWith("add-tests ")) {
+        const { handleAddTests } = await import("../../commands-add-tests.js");
+        await handleAddTests(trimmed.replace(/^add-tests\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     return false;
 }