gsd-pi 2.41.0 → 2.42.0-dev.1df898f

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

@@ -13,6 +13,7 @@ import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
+import { PROJECT_FILES } from "../detection.js";
 import { join } from "node:path";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
@@ -121,6 +122,7 @@ export async function runPreDispatch(ic, loopState) {
     });
     // ── Milestone transition ────────────────────────────────────────────
     if (mid && s.currentMilestoneId && mid !== s.currentMilestoneId) {
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "milestone-transition", data: { from: s.currentMilestoneId, to: mid } });
         ctx.ui.notify(`Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}: ${midTitle}.`, "info");
         deps.sendDesktopNotification("GSD", `Milestone ${s.currentMilestoneId} complete!`, "success", "milestone");
         deps.logCmuxEvent(prefs, `Milestone ${s.currentMilestoneId} complete. Advancing to ${mid}.`, "success");
@@ -163,9 +165,7 @@ export async function runPreDispatch(ic, loopState) {
         midTitle = state.activeMilestone?.title;
         if (mid) {
             if (deps.getIsolationMode() !== "none") {
-                deps.captureIntegrationBranch(s.basePath, mid, {
-                    commitDocs: prefs?.git?.commit_docs,
-                });
+                deps.captureIntegrationBranch(s.basePath, mid);
             }
             deps.resolver.enterMilestone(mid, ctx.ui);
         }
@@ -248,6 +248,7 @@ export async function runPreDispatch(ic, loopState) {
             await deps.stopAuto(ctx, pi, `No active milestone — ${incomplete.length} incomplete (${ids}), see diagnostic above`);
         }
         debugLog("autoLoop", { phase: "exit", reason: "no-active-milestone" });
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "no-active-milestone" } });
         return { action: "break", reason: "no-active-milestone" };
     }
     if (!midTitle) {
@@ -295,6 +296,7 @@ export async function runPreDispatch(ic, loopState) {
         deps.logCmuxEvent(prefs, `Milestone ${mid} complete.`, "success");
         await closeoutAndStop(ctx, pi, s, deps, `Milestone ${mid} complete`);
         debugLog("autoLoop", { phase: "exit", reason: "milestone-complete" });
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "milestone-complete", milestoneId: mid } });
         return { action: "break", reason: "milestone-complete" };
     }
     // Terminal: blocked
@@ -305,6 +307,7 @@ export async function runPreDispatch(ic, loopState) {
         deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention");
         deps.logCmuxEvent(prefs, blockerMsg, "error");
         debugLog("autoLoop", { phase: "exit", reason: "blocked" });
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "blocked", blockers: state.blockers } });
         return { action: "break", reason: "blocked" };
     }
     return { action: "next", data: { state, mid, midTitle } };
@@ -328,6 +331,7 @@ export async function runDispatch(ic, preData, loopState) {
         session: s,
     });
     if (dispatchResult.action === "stop") {
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-stop", rule: dispatchResult.matchedRule, data: { reason: dispatchResult.reason } });
         await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
         debugLog("autoLoop", { phase: "exit", reason: "dispatch-stop" });
         return { action: "break", reason: "dispatch-stop" };
@@ -337,6 +341,7 @@ export async function runDispatch(ic, preData, loopState) {
         await new Promise((r) => setImmediate(r));
         return { action: "continue" };
     }
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "dispatch-match", rule: dispatchResult.matchedRule, data: { unitType: dispatchResult.unitType, unitId: dispatchResult.unitId } });
     let unitType = dispatchResult.unitType;
     let unitId = dispatchResult.unitId;
     let prompt = dispatchResult.prompt;
@@ -402,6 +407,7 @@ export async function runDispatch(ic, preData, loopState) {
     const preDispatchResult = deps.runPreDispatchHooks(unitType, unitId, prompt, s.basePath);
     if (preDispatchResult.firedHooks.length > 0) {
         ctx.ui.notify(`Pre-dispatch hook${preDispatchResult.firedHooks.length > 1 ? "s" : ""}: ${preDispatchResult.firedHooks.join(", ")}`, "info");
+        deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "pre-dispatch-hook", data: { firedHooks: preDispatchResult.firedHooks, action: preDispatchResult.action } });
     }
     if (preDispatchResult.action === "skip") {
         ctx.ui.notify(`Skipping ${unitType} ${unitId} (pre-dispatch hook).`, "info");
@@ -544,25 +550,27 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         unitType,
         unitId,
     });
-    // ── Worktree health check (#1833) ───────────────────────────────────
+    // ── Worktree health check (#1833, #1843) ────────────────────────────
     // Verify the working directory is a valid git checkout with project
     // files before dispatching work. A broken worktree causes agents to
     // hallucinate summaries since they cannot read or write any files.
+    // Uses the shared PROJECT_FILES list from detection.ts to support all
+    // ecosystems (Rust, Go, Python, Java, etc.), not just JS.
     if (s.basePath && unitType === "execute-task") {
         const gitMarker = join(s.basePath, ".git");
         const hasGit = deps.existsSync(gitMarker);
-        const hasPackageJson = deps.existsSync(join(s.basePath, "package.json"));
-        const hasSrcDir = deps.existsSync(join(s.basePath, "src"));
         if (!hasGit) {
             const msg = `Worktree health check failed: ${s.basePath} has no .git — refusing to dispatch ${unitType} ${unitId}`;
-            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasGit, hasPackageJson, hasSrcDir });
+            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasGit });
             ctx.ui.notify(msg, "error");
             await deps.stopAuto(ctx, pi, msg);
             return { action: "break", reason: "worktree-invalid" };
         }
-        if (!hasPackageJson && !hasSrcDir) {
-            const msg = `Worktree health check failed: ${s.basePath} has no package.json or src/ — refusing to dispatch ${unitType} ${unitId}`;
-            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasGit, hasPackageJson, hasSrcDir });
+        const hasProjectFile = PROJECT_FILES.some((f) => deps.existsSync(join(s.basePath, f)));
+        const hasSrcDir = deps.existsSync(join(s.basePath, "src"));
+        if (!hasProjectFile && !hasSrcDir) {
+            const msg = `Worktree health check failed: ${s.basePath} has no recognized project files — refusing to dispatch ${unitType} ${unitId}`;
+            debugLog("runUnitPhase", { phase: "worktree-health-fail", basePath: s.basePath, hasProjectFile, hasSrcDir });
             ctx.ui.notify(msg, "error");
             await deps.stopAuto(ctx, pi, msg);
             return { action: "break", reason: "worktree-invalid" };
@@ -574,6 +582,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.currentUnit.id === unitId);
     const previousTier = s.currentUnitRouting?.tier;
     s.currentUnit = { type: unitType, id: unitId, startedAt: Date.now() };
+    const unitStartSeq = ic.nextSeq();
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
     deps.captureAvailableSkills();
     deps.writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
         phase: "dispatched",
@@ -683,7 +693,12 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         unitId,
         prefs,
         buildSnapshotOpts: () => deps.buildSnapshotOpts(unitType, unitId),
-        buildRecoveryContext: () => ({}),
+        buildRecoveryContext: () => ({
+            basePath: s.basePath,
+            verbose: s.verbose,
+            currentUnitStartedAt: s.currentUnit?.startedAt ?? Date.now(),
+            unitRecoveryCount: s.unitRecoveryCount,
+        }),
         pauseAuto: deps.pauseAuto,
     });
     // Write preliminary lock (no session path yet — runUnit creates a new session).
@@ -759,8 +774,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     if (s.currentUnitRouting) {
         deps.recordOutcome(unitType, s.currentUnitRouting.tier, true);
     }
-    const isHookUnit = unitType.startsWith("hook/");
-    const artifactVerified = isHookUnit ||
+    const skipArtifactVerification = unitType.startsWith("hook/") || unitType === "custom-step";
+    const artifactVerified = skipArtifactVerification ||
         deps.verifyExpectedArtifact(unitType, unitId, s.basePath);
     if (artifactVerified) {
         s.completedUnits.push({
@@ -783,6 +798,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.unitDispatchCount.delete(`${unitType}/${unitId}`);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
     }
+    deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitResult.status, artifactVerified }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
     return { action: "next", data: { unitStartedAt: s.currentUnit.startedAt } };
 }
 // ─── runFinalize ──────────────────────────────────────────────────────────────

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

@@ -27,6 +27,8 @@ export class AutoSession {
     paused = false;
     stepMode = false;
     verbose = false;
+    activeEngineId = null;
+    activeRunDir = null;
     cmdCtx = null;
     // ── Paths ────────────────────────────────────────────────────────────────
     basePath = "";
@@ -113,6 +115,8 @@ export class AutoSession {
         this.paused = false;
         this.stepMode = false;
         this.verbose = false;
+        this.activeEngineId = null;
+        this.activeRunDir = null;
         this.cmdCtx = null;
         // Paths
         this.basePath = "";
@@ -156,6 +160,8 @@ export class AutoSession {
             paused: this.paused,
             stepMode: this.stepMode,
             basePath: this.basePath,
+            activeEngineId: this.activeEngineId,
+            activeRunDir: this.activeRunDir,
             currentMilestoneId: this.currentMilestoneId,
             currentUnit: this.currentUnit,
             completedUnits: this.completedUnits.length,

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

@@ -18,6 +18,7 @@ import { GLYPH, INDENT } from "../shared/mod.js";
 import { computeProgressScore } from "./progress-score.js";
 import { getActiveWorktreeName } from "./worktree-command.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
+import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
@@ -45,6 +46,7 @@ export function unitVerb(unitType) {
         case "rewrite-docs": return "rewriting";
         case "reassess-roadmap": return "reassessing";
         case "run-uat": return "running UAT";
+        case "custom-step": return "executing workflow step";
         default: return unitType;
     }
 }
@@ -63,6 +65,7 @@ export function unitPhaseLabel(unitType) {
         case "rewrite-docs": return "REWRITE";
         case "reassess-roadmap": return "REASSESS";
         case "run-uat": return "UAT";
+        case "custom-step": return "WORKFLOW";
         default: return unitType.toUpperCase();
     }
 }
@@ -370,6 +373,8 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
     }
     // Pre-fetch last commit for display
     refreshLastCommit(accessors.getBasePath());
+    // Cache the effective service tier at widget creation time (reads preferences)
+    const effectiveServiceTier = getEffectiveServiceTier();
     ctx.ui.setWidget("gsd-progress", (tui, theme) => {
         let pulseBright = true;
         let cachedLines;
@@ -471,9 +476,10 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 // Model display — shown in context section, not stats
                 const modelId = cmdCtx?.model?.id ?? "";
                 const modelProvider = cmdCtx?.model?.provider ?? "";
-                const modelDisplay = modelProvider && modelId
+                const tierIcon = resolveServiceTierIcon(effectiveServiceTier, modelId);
+                const modelDisplay = (modelProvider && modelId
                     ? `${modelProvider}/${modelId}`
-                    : modelId;
+                    : modelId) + (tierIcon ? ` ${tierIcon}` : "");
                 // ── Mode: off — return empty ──────────────────────────────────
                 if (widgetMode === "off") {
                     cachedLines = [];

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

@@ -24,7 +24,7 @@ function missingSliceStop(mid, phase) {
 // ─── Rewrite Circuit Breaker ──────────────────────────────────────────────
 const MAX_REWRITE_ATTEMPTS = 3;
 // ─── Rules ────────────────────────────────────────────────────────────────
-const DISPATCH_RULES = [
+export const DISPATCH_RULES = [
     {
         name: "rewrite-docs (override gate)",
         match: async ({ mid, midTitle, state, basePath, session }) => {
@@ -480,22 +480,39 @@ const DISPATCH_RULES = [
         },
     },
 ];
+import { getRegistry } from "./rule-registry.js";
 // ─── Resolver ─────────────────────────────────────────────────────────────
 /**
  * Evaluate dispatch rules in order. Returns the first matching action,
  * or a "stop" action if no rule matches (unhandled phase).
+ *
+ * Delegates to the RuleRegistry when initialized; falls back to inline
+ * loop over DISPATCH_RULES for backward compatibility (tests that import
+ * resolveDispatch directly without registry initialization).
  */
 export async function resolveDispatch(ctx) {
+    // Delegate to registry when available
+    try {
+        const registry = getRegistry();
+        return await registry.evaluateDispatch(ctx);
+    }
+    catch {
+        // Registry not initialized — fall back to inline loop
+    }
     for (const rule of DISPATCH_RULES) {
         const result = await rule.match(ctx);
-        if (result)
+        if (result) {
+            if (result.action !== "skip")
+                result.matchedRule = rule.name;
             return result;
+        }
     }
     // No rule matched — unhandled phase
     return {
         action: "stop",
         reason: `Unhandled phase "${ctx.state.phase}" — run /gsd doctor to diagnose.`,
         level: "info",
+        matchedRule: "<no-match>",
     };
 }
 /** Exposed for testing — returns the rule names in evaluation order. */

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

@@ -31,6 +31,7 @@ import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { uncheckTaskInPlan } from "./undo.js";
 import { atomicWriteSync } from "./atomic-write.js";
+import { _resetHasChangesCache } from "./native-git-bridge.js";
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 /**
@@ -103,6 +104,12 @@ export async function postUnitPreVerification(pctx, opts) {
                     }
                 }
             }
+            // 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();
             const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
             if (commitMsg) {
                 ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");

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

@@ -337,7 +337,7 @@ function formatSkillActivationBlock(skillNames) {
 }
 export function buildSkillActivationBlock(params) {
     const prefs = params.preferences ?? loadEffectiveGSDPreferences()?.preferences;
-    const contextTokens = tokenizeSkillContext(params.milestoneId, params.milestoneTitle, params.sliceId, params.sliceTitle, params.taskId, params.taskTitle, ...(params.extraContext ?? []), params.taskPlanContent ?? undefined);
+    const contextTokens = tokenizeSkillContext(params.milestoneId, params.milestoneTitle, params.sliceId, params.sliceTitle, params.taskId, params.taskTitle);
     const visibleSkills = (typeof getLoadedSkills === 'function' ? getLoadedSkills() : []).filter(skill => !skill.disableModelInvocation);
     const installedNames = new Set(visibleSkills.map(skill => normalizeSkillReference(skill.name)));
     const avoided = new Set(resolvePreferenceSkillNames(prefs?.avoid_skills ?? [], params.base));
@@ -364,11 +364,6 @@ export function buildSkillActivationBlock(params) {
             // Non-fatal — malformed task plan should not break prompt construction
         }
     }
-    for (const skill of visibleSkills) {
-        if (skillMatchesContext(skill, contextTokens)) {
-            matched.add(normalizeSkillReference(skill.name));
-        }
-    }
     const ordered = [...matched]
         .filter(name => installedNames.has(name) && !avoided.has(name))
         .sort();
@@ -846,11 +841,7 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     // Build executor context constraints from the budget engine
     const executorContextConstraints = formatExecutorConstraints();
     const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
-    const prefs = loadEffectiveGSDPreferences();
-    const commitDocsEnabled = prefs?.preferences?.git?.commit_docs !== false;
-    const commitInstruction = commitDocsEnabled
-        ? `Commit the plan files only: \`git add ${relSlicePath(base, mid, sid)}/ .gsd/DECISIONS.md .gitignore && git commit -m "docs(${sid}): add slice plan"\`. Do not stage .gsd/STATE.md or other runtime files — the system manages those.`
-        : "Do not commit — planning docs are not tracked in git for this project.";
+    const commitInstruction = "Do not commit — .gsd/ planning docs are managed externally and not tracked in git.";
     return loadPrompt("plan-slice", {
         workingDirectory: base,
         milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
@@ -1281,11 +1272,7 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
     catch {
         // Non-fatal — captures module may not be available
     }
-    const reassessPrefs = loadEffectiveGSDPreferences();
-    const reassessCommitDocsEnabled = reassessPrefs?.preferences?.git?.commit_docs !== false;
-    const reassessCommitInstruction = reassessCommitDocsEnabled
-        ? `Commit: \`docs(${mid}): reassess roadmap after ${completedSliceId}\`. Stage only the .gsd/milestones/ files you changed — do not stage .gsd/STATE.md or other runtime files.`
-        : "Do not commit — planning docs are not tracked in git for this project.";
+    const reassessCommitInstruction = "Do not commit — .gsd/ planning docs are managed externally and not tracked in git.";
     return loadPrompt("reassess-roadmap", {
         workingDirectory: base,
         milestoneId: mid,

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

@@ -263,10 +263,15 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // plan has no tasks, creating an infinite skip loop (#699).
     if (unitType === "plan-slice") {
         const planContent = readFileSync(absPath, "utf-8");
-        if (!/^- \[[xX ]\] \*\*T\d+:/m.test(planContent))
+        // Accept checkbox-style (- [x] **T01: ...) or heading-style (### T01 -- / ### T01: / ### T01 —)
+        const hasCheckboxTask = /^- \[[xX ]\] \*\*T\d+:/m.test(planContent);
+        const hasHeadingTask = /^#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
+        if (!hasCheckboxTask && !hasHeadingTask)
             return false;
     }
-    // execute-task must also have its checkbox marked [x] in the slice plan
+    // execute-task must also have its checkbox marked [x] in the slice plan.
+    // Heading-style plans (### T01 -- Title) have no checkbox — the task summary
+    // file existence (checked above via resolveExpectedArtifactPath) is sufficient.
     if (unitType === "execute-task") {
         const parts = unitId.split("/");
         const mid = parts[0];
@@ -277,8 +282,11 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             if (planAbs && existsSync(planAbs)) {
                 const planContent = readFileSync(planAbs, "utf-8");
                 const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                const re = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
-                if (!re.test(planContent))
+                const cbRe = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
+                const hdRe = new RegExp(`^#{2,4}\\s+${escapedTid}\\s*(?:--|—|:)`, "m");
+                // Heading-style entries count as verified (no checkbox to toggle);
+                // checkbox-style entries require [x].
+                if (!cbRe.test(planContent) && !hdRe.test(planContent))
                     return false;
             }
         }

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

@@ -11,7 +11,7 @@
 import { deriveState } from "./state.js";
 import { loadFile, getManifestStatus } from "./files.js";
 import { loadEffectiveGSDPreferences, resolveSkillDiscoveryMode, getIsolationMode, } from "./preferences.js";
-import { ensureGsdSymlink, validateProjectId } from "./repo-identity.js";
+import { ensureGsdSymlink, isInheritedRepo, validateProjectId } from "./repo-identity.js";
 import { migrateToExternalState, recoverFailedMigration } from "./migrate-external.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
 import { gsdRoot, resolveMilestoneFile } from "./paths.js";
@@ -69,8 +69,13 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             ctx.ui.notify(`GSD_PROJECT_ID must contain only alphanumeric characters, hyphens, and underscores. Got: "${customProjectId}"`, "error");
             return releaseLockAndReturn();
         }
-        // Ensure git repo exists
-        if (!nativeIsRepo(base)) {
+        // Ensure git repo exists.
+        // Guard against inherited repos: if `base` is a subdirectory of another
+        // git repo that has no .gsd (i.e. the parent project was never initialised
+        // with GSD), create a fresh git repo at `base` so it gets its own identity
+        // hash. Without this, repoIdentity() resolves to the parent repo's hash
+        // and loads milestones from an unrelated project (#1639).
+        if (!nativeIsRepo(base) || isInheritedRepo(base)) {
             const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
             nativeInit(base, mainBranch);
         }
@@ -88,23 +93,20 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // ensureGitignore checks for git-tracked .gsd/ files and skips the
         // ".gsd" pattern if the project intentionally tracks .gsd/ in git.
         const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
-        const commitDocs = gitPrefs?.commit_docs;
         const manageGitignore = gitPrefs?.manage_gitignore;
-        ensureGitignore(base, { commitDocs, manageGitignore });
+        ensureGitignore(base, { manageGitignore });
         if (manageGitignore !== false)
             untrackRuntimeFiles(base);
         // Bootstrap .gsd/ if it doesn't exist
         const gsdDir = join(base, ".gsd");
         if (!existsSync(gsdDir)) {
             mkdirSync(join(gsdDir, "milestones"), { recursive: true });
-            if (commitDocs !== false) {
-                try {
-                    nativeAddAll(base);
-                    nativeCommit(base, "chore: init gsd");
-                }
-                catch {
-                    /* nothing to commit */
-                }
+            try {
+                nativeAddAll(base);
+                nativeCommit(base, "chore: init gsd");
+            }
+            catch {
+                /* nothing to commit */
             }
         }
         // Initialize GitServiceImpl
@@ -342,7 +344,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // Capture integration branch
         if (s.currentMilestoneId) {
             if (getIsolationMode() !== "none") {
-                captureIntegrationBranch(base, s.currentMilestoneId, { commitDocs });
+                captureIntegrationBranch(base, s.currentMilestoneId);
             }
             setActiveMilestoneId(base, s.currentMilestoneId);
         }