gsd-pi 2.41.0 → 2.42.0-dev.1df898f

package/src/resources/extensions/gsd/auto/phases.ts

@@ -26,6 +26,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 ──────────────────────────────────────────────────
@@ -192,6 +193,7 @@ export async function runPreDispatch(
 
   // ── 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",
@@ -259,9 +261,7 @@ export async function runPreDispatch(
 
     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);
     } else {
@@ -386,6 +386,7 @@ export async function runPreDispatch(
       );
     }
     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" };
   }
 
@@ -454,6 +455,7 @@ export async function runPreDispatch(
     );
     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" };
   }
 
@@ -465,6 +467,7 @@ export async function runPreDispatch(
     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" };
   }
 
@@ -497,6 +500,7 @@ export async function runDispatch(
   });
 
   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" };
@@ -508,6 +512,8 @@ export async function runDispatch(
     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;
@@ -600,6 +606,7 @@ export async function runDispatch(
       `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(
@@ -809,25 +816,27 @@ export async function runUnitPhase(
     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" };
@@ -843,6 +852,8 @@ export async function runUnitPhase(
   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,
@@ -988,7 +999,12 @@ export async function runUnitPhase(
     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,
   });
 
@@ -1115,9 +1131,9 @@ export async function runUnitPhase(
     );
   }
 
-  const isHookUnit = unitType.startsWith("hook/");
+  const skipArtifactVerification = unitType.startsWith("hook/") || unitType === "custom-step";
   const artifactVerified =
-    isHookUnit ||
+    skipArtifactVerification ||
     deps.verifyExpectedArtifact(unitType, unitId, s.basePath);
   if (artifactVerified) {
     s.completedUnits.push({
@@ -1141,6 +1157,8 @@ export async function runUnitPhase(
     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 } };
 }
 

package/src/resources/extensions/gsd/auto/session.ts

@@ -83,6 +83,8 @@ export class AutoSession {
   paused = false;
   stepMode = false;
   verbose = false;
+  activeEngineId: string | null = null;
+  activeRunDir: string | null = null;
   cmdCtx: ExtensionCommandContext | null = null;
 
   // ── Paths ────────────────────────────────────────────────────────────────
@@ -174,6 +176,8 @@ export class AutoSession {
     this.paused = false;
     this.stepMode = false;
     this.verbose = false;
+    this.activeEngineId = null;
+    this.activeRunDir = null;
     this.cmdCtx = null;
 
     // Paths
@@ -226,6 +230,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/src/resources/extensions/gsd/auto/types.ts

@@ -69,6 +69,10 @@ export interface IterationContext {
   deps: LoopDeps;
   prefs: GSDPreferences | undefined;
   iteration: number;
+  /** UUID grouping all journal events for this iteration. */
+  flowId: string;
+  /** Returns the next monotonically increasing sequence number (1-based, reset per iteration). */
+  nextSeq: () => number;
 }
 
 export interface LoopState {

package/src/resources/extensions/gsd/auto-dashboard.ts

@@ -24,6 +24,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 ─────────────────────────────────────────────────────
 
@@ -78,6 +79,7 @@ export function unitVerb(unitType: string): string {
     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;
   }
 }
@@ -96,6 +98,7 @@ export function unitPhaseLabel(unitType: string): string {
     case "rewrite-docs": return "REWRITE";
     case "reassess-roadmap": return "REASSESS";
     case "run-uat": return "UAT";
+    case "custom-step": return "WORKFLOW";
     default: return unitType.toUpperCase();
   }
 }
@@ -460,6 +463,9 @@ export function updateProgressWidget(
   // 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: string[] | undefined;
@@ -572,9 +578,10 @@ export function updateProgressWidget(
         // 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") {

package/src/resources/extensions/gsd/auto-dispatch.ts

@@ -54,9 +54,11 @@ export type DispatchAction =
       unitId: string;
       prompt: string;
       pauseAfterDispatch?: boolean;
+      /** Name of the matched dispatch rule from the unified registry (journal provenance). */
+      matchedRule?: string;
     }
-  | { action: "stop"; reason: string; level: "info" | "warning" | "error" }
-  | { action: "skip" };
+  | { action: "stop"; reason: string; level: "info" | "warning" | "error"; matchedRule?: string }
+  | { action: "skip"; matchedRule?: string };
 
 export interface DispatchContext {
   basePath: string;
@@ -67,7 +69,7 @@ export interface DispatchContext {
   session?: import("./auto/session.js").AutoSession;
 }
 
-interface DispatchRule {
+export interface DispatchRule {
   /** Human-readable name for debugging and test identification */
   name: string;
   /** Return a DispatchAction if this rule matches, null to fall through */
@@ -88,7 +90,7 @@ const MAX_REWRITE_ATTEMPTS = 3;
 
 // ─── Rules ────────────────────────────────────────────────────────────────
 
-const DISPATCH_RULES: DispatchRule[] = [
+export const DISPATCH_RULES: DispatchRule[] = [
   {
     name: "rewrite-docs (override gate)",
     match: async ({ mid, midTitle, state, basePath, session }) => {
@@ -608,18 +610,35 @@ const DISPATCH_RULES: DispatchRule[] = [
   },
 ];
 
+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: DispatchContext,
 ): Promise<DispatchAction> {
+  // 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) return result;
+    if (result) {
+      if (result.action !== "skip") result.matchedRule = rule.name;
+      return result;
+    }
   }
 
   // No rule matched — unhandled phase
@@ -627,6 +646,7 @@ export async function resolveDispatch(
     action: "stop",
     reason: `Unhandled phase "${ctx.state.phase}" — run /gsd doctor to diagnose.`,
     level: "info",
+    matchedRule: "<no-match>",
   };
 }
 

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -59,6 +59,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;
@@ -156,6 +157,13 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
         }
       }
 
+      // 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/src/resources/extensions/gsd/auto-prompts.ts

@@ -420,8 +420,6 @@ export function buildSkillActivationBlock(params: {
     params.sliceTitle,
     params.taskId,
     params.taskTitle,
-    ...(params.extraContext ?? []),
-    params.taskPlanContent ?? undefined,
   );
 
   const visibleSkills = (typeof getLoadedSkills === 'function' ? getLoadedSkills() : []).filter(skill => !skill.disableModelInvocation);
@@ -452,12 +450,6 @@ export function buildSkillActivationBlock(params: {
     }
   }
 
-  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();
@@ -983,11 +975,7 @@ export async function buildPlanSlicePrompt(
   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,
@@ -1485,11 +1473,7 @@ export async function buildReassessRoadmapPrompt(
     // 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,

package/src/resources/extensions/gsd/auto-recovery.ts

@@ -319,10 +319,15 @@ export function verifyExpectedArtifact(
   // 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)) return false;
+    // 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];
@@ -333,8 +338,11 @@ export function verifyExpectedArtifact(
       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)) return false;
+        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/src/resources/extensions/gsd/auto-start.ts

@@ -20,7 +20,7 @@ import {
   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, milestonesDir } from "./paths.js";
@@ -140,8 +140,13 @@ export async function bootstrapAutoSession(
       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);
@@ -162,22 +167,19 @@ export async function bootstrapAutoSession(
     // 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 */
       }
     }
 
@@ -482,7 +484,7 @@ export async function bootstrapAutoSession(
     // Capture integration branch
     if (s.currentMilestoneId) {
       if (getIsolationMode() !== "none") {
-        captureIntegrationBranch(base, s.currentMilestoneId, { commitDocs });
+        captureIntegrationBranch(base, s.currentMilestoneId);
       }
       setActiveMilestoneId(base, s.currentMilestoneId);
     }