@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

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

@@ -25,7 +25,7 @@ import { checkResourcesStale, autoWorktreeBranch, mergeMilestoneToMain } from ".
 import { getSessionLockStatus } from "../session-lock.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { emitJournalEvent as _emitJournalEvent } from "../journal.js";
-import { loadEffectiveGSDPreferences, getIsolationMode, resolveEffectiveUnitIsolationMode } from "../preferences.js";
+import { loadEffectiveGSDPreferences, loadEffectiveGSDPreferencesWithRegistry, getIsolationMode, resolveEffectiveUnitIsolationMode, resolveProfileAnchorProvider } from "../preferences.js";
 import { detectWorktreeName, getMainBranch, resolveProjectRoot, resolveWorktreeProjectRoot, } from "../worktree.js";
 import { getPriorSliceCompletionBlocker } from "../dispatch-guard.js";
 import { GitServiceImpl } from "../git-service.js";
@@ -51,6 +51,16 @@ import { hasHeldMilestoneLease, reclaimMissingMilestoneLease } from "./milestone
 function now() {
     return Date.now();
 }
+/**
+ * Optional override for the post-settlement markdown projection rebuild
+ * (mergePendingCompleteMilestone). Production leaves this null so the real
+ * rebuild runs; tests inject a throwing function to deterministically exercise
+ * the best-effort failure path (orchestrator.ts:637), which is otherwise only
+ * reachable by driving advance() through a full merge-pending milestone
+ * settlement and then contriving a projection-rebuild fault.
+ * @internal
+ */
+let _projectionRebuildFn = null;
 function noRemainingUnitsOutcome(stateSnapshot) {
     if (stateSnapshot.phase === "complete") {
         return {
@@ -114,7 +124,9 @@ export async function decideOrchestratorDispatch(ctx, pi, dispatchBasePath, sess
     const active = state.activeMilestone;
     const activeSession = input.session ?? session;
     const activeDispatchBasePath = activeSession?.basePath || dispatchBasePath;
-    const prefs = loadEffectiveGSDPreferences(activeDispatchBasePath)?.preferences;
+    const prefs = loadEffectiveGSDPreferencesWithRegistry(ctx.modelRegistry, activeDispatchBasePath, resolveProfileAnchorProvider(ctx.model?.provider, session?.autoModeStartModel?.provider), activeSession?.autoModeStartModel
+        ? `${activeSession.autoModeStartModel.provider}/${activeSession.autoModeStartModel.id}`
+        : undefined)?.preferences;
     if (!active) {
         if (state.phase !== "pre-planning")
             return null;
@@ -386,7 +398,9 @@ export class AutoOrchestrator {
     // ── UokGateAdapter (folded) ──────────────────────────────────────────────
     async emitUokGate(input) {
         const activeBasePath = this.getLiveDispatchBasePath();
-        const prefs = loadEffectiveGSDPreferences(activeBasePath)?.preferences;
+        const prefs = loadEffectiveGSDPreferencesWithRegistry(this.ctx.modelRegistry, activeBasePath, resolveProfileAnchorProvider(this.ctx.model?.provider, this.s.autoModeStartModel?.provider), this.s.autoModeStartModel
+            ? `${this.s.autoModeStartModel.provider}/${this.s.autoModeStartModel.id}`
+            : undefined)?.preferences;
         const uokFlags = resolveUokFlags(prefs);
         if (!uokFlags.gates)
             return;
@@ -493,8 +507,16 @@ export class AutoOrchestrator {
         this.s.milestoneSettlement = { ok: true, reason: "settled" };
         try {
             const projectRoot = this.s.originalBasePath || this.s.canonicalProjectRoot || this.runtimeBasePath;
-            const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.js");
-            await rebuildMarkdownProjectionsFromDb(projectRoot);
+            // Test seam: when _projectionRebuildFn is injected, route the rebuild
+            // through it so the best-effort failure path (:637) is deterministically
+            // reachable. Production leaves it null → real rebuildMarkdownProjectionsFromDb.
+            if (_projectionRebuildFn) {
+                await _projectionRebuildFn(projectRoot);
+            }
+            else {
+                const { rebuildMarkdownProjectionsFromDb } = await import("../commands-maintenance.js");
+                await rebuildMarkdownProjectionsFromDb(projectRoot);
+            }
         }
         catch (err) {
             logWarning("engine", `markdown projection rebuild after settlement merge failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -714,12 +736,17 @@ export class AutoOrchestrator {
     async start(_sessionContext) {
         this.lastAdvanceKey = null;
         this.lastFinalizedUnitKey = null;
-        // #482: the DB dispatch ledger is the source of truth across sessions.
-        // Discard any in-memory window and rebuild it from the ledger so a unit
-        // that was re-dispatched in previous sessions is detected as stuck here
-        // instead of silently re-dispatching forever.
+        // #852: a fresh user-triggered session must start with a clean stuck window.
+        // Cross-session rehydration at start() was removed because it caused false
+        // stuck-loop verdicts when prior sessions left consecutive finalize-retry
+        // entries in unit_dispatches — the new session would be killed before its
+        // first dispatch ran. Within-session stuck detection (accumulated through
+        // recordDispatch() calls during advance()) remains fully active and catches
+        // genuine stuck patterns after STUCK_WINDOW_SIZE dispatches.
+        //
+        // resume() retains cross-session rehydration: an interrupted session resuming
+        // after a crash should see the dispatch history it had been accumulating.
         this.dispatchHistory.clearOnRecovery();
-        this.dispatchHistory.rehydrate();
         this.lastStuckRecoveryKey = null;
         this.lastDerivedPhase = null;
         this.status.phase = "running";
@@ -1225,3 +1252,16 @@ export function resolveLiveOrchestratorBasePath(input) {
 export function createAutoOrchestrator(context) {
     return new AutoOrchestrator(context);
 }
+/**
+ * Inject an override for the post-settlement markdown projection rebuild,
+ * returning a function that restores the default (real rebuild) behavior. Used
+ * by tests to deterministically exercise the best-effort rebuild-failure path
+ * (orchestrator.ts:637) — otherwise only reachable by driving advance() through
+ * a full merge-pending milestone settlement and then contriving a projection
+ * fault. No production caller.
+ * @internal
+ */
+export function _setProjectionRebuildFnForTests(fn) {
+    _projectionRebuildFn = fn;
+    return () => { _projectionRebuildFn = null; };
+}

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

@@ -22,6 +22,10 @@ function classifyBlocker(blocker) {
     if (normalized.includes("needs-remediation") && normalized.includes("all slices are complete")) {
         return "needs-remediation-dead-end";
     }
+    if (normalized.includes("completed closeout dispatch history") ||
+        normalized.includes("completed complete-milestone dispatch history")) {
+        return "completed-milestone-reopened";
+    }
     return "other";
 }
 function sanitizeBlockerForUser(blocker) {
@@ -40,6 +44,10 @@ function formatBlockedResumeMessage(blockers) {
     if (hasNeedsRemediationDeadEnd) {
         return "Blocked: milestone validation requires remediation but all slices are complete. Run /gsd dispatch reassess to add remediation slices, then /gsd auto to continue.";
     }
+    const completedMilestoneReopened = classifiedBlockers.find((classifiedBlocker) => classifiedBlocker.kind === "completed-milestone-reopened");
+    if (completedMilestoneReopened) {
+        return completedMilestoneReopened.blocker;
+    }
     return `Blocked: ${classifiedBlockers.map((classifiedBlocker) => classifiedBlocker.blocker).join(", ")}. Fix and run /gsd auto to resume.`;
 }
 /**

package/dist/resources/extensions/gsd/auto/workflow-kernel.js

@@ -76,6 +76,15 @@ const COMPLETE_AND_BREAK_REASONS = [
 function isCompleteAndBreakReason(reason) {
     return COMPLETE_AND_BREAK_REASONS.includes(reason);
 }
+/** Strip per-attempt counter suffixes so detect-stuck Rule 1 can match repeats. */
+const FAILURE_DETAIL_ATTEMPT_SUFFIX_RE = /\s*\(attempt\s+\d+(?:\/\d+)?\)\.?$/i;
+function failureDetailForLedger(detail) {
+    const trimmed = detail?.trim();
+    if (!trimmed)
+        return undefined;
+    const normalized = trimmed.replace(FAILURE_DETAIL_ATTEMPT_SUFFIX_RE, "").trim();
+    return normalized || undefined;
+}
 export function decideFinalizeResult(input) {
     if (input.action === "break") {
         const reason = input.reason ?? "unknown";
@@ -90,9 +99,14 @@ export function decideFinalizeResult(input) {
         };
     }
     if (input.action === "continue") {
+        // Carry the specific verification failure (e.g. "roadmap has zero slices",
+        // "15-SUMMARY.md was not found on disk") into the ledger summary so the
+        // stuck-loop kill message is actionable. The `finalize-retry` prefix is
+        // preserved so legacy ledger filters and dashboards still match (#852).
+        const detail = failureDetailForLedger(input.failureDetail);
         return {
             action: "retry",
-            ledgerErrorSummary: "finalize-retry",
+            ledgerErrorSummary: detail ? `finalize-retry: ${detail}` : "finalize-retry",
         };
     }
     return { action: "complete" };

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -5,27 +5,92 @@
 // resolveExpectedArtifactPath and diagnoseExpectedArtifact moved here from
 // auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
 // function was removed entirely — callers now query WorkflowEngine directly.
-import { gsdRoot, gsdProjectionRoot, resolveDir, resolveFile, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, } from "./paths.js";
+import { gsdRoot, resolveDir, resolveFile, resolveMilestonePath, resolveMilestoneFile, resolveSliceFile, relMilestoneFile, relSliceFile, buildTaskFileName, resolveSlicePath, resolveTasksDir, dirIsMetaOnlyLegacyMilestone, } from "./paths.js";
+import { milestoneIdToPhaseNum } from "./layout-policy.js";
 import { parseUnitId } from "./unit-id.js";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 function resolveMilestoneArtifactPath(base, mid, suffix) {
     const existing = resolveProjectedMilestoneFile(base, mid, suffix) ?? resolveProjectMilestoneFile(base, mid, suffix);
     if (existing)
         return existing;
-    const dir = resolveProjectedMilestonePath(base, mid) ?? resolveProjectMilestonePath(base, mid);
-    return dir ? join(dir, buildMilestoneFileName(mid, suffix)) : null;
+    // Try projected (worktree) path, then project-root path. Both can return
+    // either a legacy (milestones/<MID>/) or flat-phase (phases/NN-slug/) dir.
+    const dir = resolveProjectedMilestonePath(base, mid) ?? resolveProjectMilestonePath(base, mid) ?? resolveMilestonePath(base, mid);
+    if (dir) {
+        // The filename depends on the LAYOUT of the resolved directory, not on
+        // which resolver found it. A flat-phase dir (phases/NN-slug/) uses the
+        // phase-number prefix (15-CONTEXT.md); a legacy dir (milestones/<MID>/)
+        // uses the milestone-id prefix (M015-CONTEXT.md). Building the wrong
+        // filename for the resolved dir produces existsSync-false paths that trap
+        // the unit in a finalize-retry loop (#852).
+        //
+        // Layout is determined structurally from the resolved directory's parent
+        // segment name, NOT by comparing against a root-anchored legacyMilestonesDir
+        // base path. On a canonical worktree (<project>/.gsd-worktrees/M001/),
+        // legacyMilestonesDir uses gsdProjectionRoot (the worktree .gsd) while
+        // resolveProjectMilestonePath uses gsdRoot (the project .gsd) — two
+        // different roots. A dir returned by resolveProjectMilestonePath would
+        // fail the startsWith check against the worktree root and incorrectly
+        // produce a flat-phase filename for a legacy directory (#bugbot c5ee8eba).
+        const parentDir = dirname(dir);
+        const isLegacy = parentDir.endsWith("/milestones") || parentDir.endsWith("\\milestones");
+        const phaseNum = milestoneIdToPhaseNum(mid);
+        const filename = isLegacy
+            ? `${mid}-${suffix}.md`
+            : `${String(phaseNum).padStart(2, "0")}-${suffix}.md`;
+        return join(dir, filename);
+    }
+    return null;
+}
+/**
+ * Build the layout-aware filename for a milestone artifact suffix.
+ * Exported so other callers (e.g. verification diagnostics) use the same
+ * naming policy: flat-phase dirs use the phase-number prefix (15-CONTEXT.md),
+ * legacy dirs use the milestone-id prefix (M015-CONTEXT.md).
+ *
+ * Layout is determined structurally: dirs whose immediate parent is named
+ * "milestones" are legacy; all others are flat-phase. This avoids the
+ * root-path ambiguity between gsdProjectionRoot (worktree .gsd) and gsdRoot
+ * (project .gsd) that caused wrong filenames on canonical worktrees.
+ */
+export function buildMilestoneArtifactFilename(mid, suffix, dir) {
+    const parentDir = dirname(dir);
+    const isLegacy = parentDir.endsWith("/milestones") || parentDir.endsWith("\\milestones");
+    const phaseNum = milestoneIdToPhaseNum(mid);
+    return isLegacy
+        ? `${mid}-${suffix}.md`
+        : `${String(phaseNum).padStart(2, "0")}-${suffix}.md`;
 }
 function resolveSliceArtifactPath(base, mid, sid, suffix) {
     const existing = resolveProjectedSliceFile(base, mid, sid, suffix) ?? resolveProjectSliceFile(base, mid, sid, suffix);
     if (existing)
         return existing;
-    const dir = resolveProjectedSlicePath(base, mid, sid) ?? resolveProjectSlicePath(base, mid, sid);
-    return dir ? join(dir, buildSliceFileName(sid, suffix)) : null;
+    // Flat-phase: plan files live at phases/NN-slug/NN-MM-SUFFIX.md — resolveSliceFile handles both layouts.
+    const flatPhase = resolveSliceFile(base, mid, sid, suffix);
+    if (flatPhase)
+        return flatPhase;
+    // File doesn't exist yet — use relSliceFile for the layout-aware canonical path.
+    // buildSliceFileName(sid) only has sliceId → MM-SUFFIX.md, wrong for both layouts.
+    return join(base, relSliceFile(base, mid, sid, suffix));
 }
 function resolveProjectMilestonePath(base, mid) {
     const milestonesDir = join(gsdRoot(base), "milestones");
     const dir = resolveDir(milestonesDir, mid);
-    return dir ? join(milestonesDir, dir) : null;
+    if (!dir)
+        return null;
+    // git-service.ts creates milestones/<MID>/ for integration-branch metadata
+    // (<MID>-META.json) even in flat-phase projects. A dir that holds ONLY
+    // *-META.json files must not be treated as a real legacy milestone dir —
+    // otherwise this early-return resolves CONTEXT/ROADMAP/SUMMARY to the legacy
+    // path (milestones/<MID>/<MID>-<SUFFIX>.md) before the flat-phase fallback
+    // can run, trapping the unit in a finalize-retry loop (#852 follow-up).
+    //
+    // We use dirIsMetaOnlyLegacyMilestone rather than !dirIsContentBearingLegacyMilestone
+    // so that an EMPTY dir (a new milestone before any content is written) is NOT
+    // blocked — it is a valid legacy target that write-paths should resolve to.
+    if (dirIsMetaOnlyLegacyMilestone(join(milestonesDir, dir)))
+        return null;
+    return join(milestonesDir, dir);
 }
 function resolveProjectMilestoneFile(base, mid, suffix) {
     const dir = resolveProjectMilestonePath(base, mid);
@@ -50,16 +115,10 @@ function resolveProjectSliceFile(base, mid, sid, suffix) {
     return file ? join(dir, file) : null;
 }
 function resolveProjectedMilestonePath(base, mid) {
-    const milestonesDir = join(gsdProjectionRoot(base), "milestones");
-    const dir = resolveDir(milestonesDir, mid);
-    return dir ? join(milestonesDir, dir) : null;
+    return resolveMilestonePath(base, mid);
 }
 function resolveProjectedMilestoneFile(base, mid, suffix) {
-    const dir = resolveProjectedMilestonePath(base, mid);
-    if (!dir)
-        return null;
-    const file = resolveFile(dir, mid, suffix);
-    return file ? join(dir, file) : null;
+    return resolveMilestoneFile(base, mid, suffix);
 }
 function resolveProjectedSlicePath(base, mid, sid) {
     const milestoneDir = resolveProjectedMilestonePath(base, mid);
@@ -128,10 +187,13 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             return resolveSliceArtifactPath(base, mid, sid, "ASSESSMENT");
         }
         case "execute-task": {
-            const dir = resolveProjectedSlicePath(base, mid, sid) ?? resolveProjectSlicePath(base, mid, sid);
-            return dir && tid
-                ? join(dir, "tasks", buildTaskFileName(tid, "SUMMARY"))
-                : null;
+            const slicePath = resolveProjectedSlicePath(base, mid, sid)
+                ?? resolveProjectSlicePath(base, mid, sid)
+                ?? resolveSlicePath(base, mid, sid);
+            if (!slicePath || !tid)
+                return null;
+            const tasksDir = resolveTasksDir(base, mid, sid) ?? slicePath;
+            return join(tasksDir, buildTaskFileName(tid, "SUMMARY"));
         }
         case "complete-slice": {
             return resolveSliceArtifactPath(base, mid, sid, "SUMMARY");

package/dist/resources/extensions/gsd/auto-closeout-messaging.js

@@ -0,0 +1,90 @@
+// Project/App: gsd-pi
+// File Purpose: Rewrite premature unit "complete" chat lines before GSD post-unit verification.
+/**
+ * Auto-mode owns the authoritative "unit complete" signal (finalize/stopAuto).
+ * Agents may still emit legacy closeout lines after completion tools succeed;
+ * rewrite those for transcript clarity until post-unit verification passes.
+ */
+const CLOSEOUT_LINE_REWRITES = [
+    {
+        pattern: /^Milestone\s+(M\d+[A-Z0-9-]*)\s+complete\.?$/i,
+        replacement: "Milestone $1 closeout submitted.",
+    },
+    {
+        pattern: /^Milestone\s+(M\d+[A-Z0-9-]*)\s+is\s+already\s+complete\.?$/i,
+        replacement: "Milestone $1 closeout already recorded.",
+    },
+    {
+        pattern: /^Slice\s+(S\d+[A-Z0-9-]*)\s+complete\.?$/i,
+        replacement: "Slice $1 closeout submitted.",
+    },
+    {
+        pattern: /^Task\s+(T\d+[A-Z0-9-]*)\s+complete\.?$/i,
+        replacement: "Task $1 closeout submitted.",
+    },
+    {
+        pattern: /^UAT\s+(S\d+[A-Z0-9-]*)\s+complete\.?$/i,
+        replacement: "UAT $1 results submitted.",
+    },
+    {
+        pattern: /^Quick\s+task\s+(\d+)\s+complete\.?$/i,
+        replacement: "Quick task $1 closeout submitted.",
+    },
+    {
+        pattern: /^Triage\s+complete\.?$/i,
+        replacement: "Triage closeout submitted.",
+    },
+];
+export function rewritePrematureCloseoutLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return line;
+    for (const { pattern, replacement } of CLOSEOUT_LINE_REWRITES) {
+        if (pattern.test(trimmed)) {
+            return trimmed.replace(pattern, replacement);
+        }
+    }
+    return line;
+}
+export function rewritePrematureCloseoutText(text) {
+    if (!text)
+        return text;
+    const lines = text.split("\n");
+    let changed = false;
+    const rewritten = lines.map((line) => {
+        const next = rewritePrematureCloseoutLine(line);
+        if (next !== line)
+            changed = true;
+        return next;
+    });
+    return changed ? rewritten.join("\n") : text;
+}
+function rewriteAssistantMessageContent(content) {
+    if (typeof content === "string") {
+        const rewritten = rewritePrematureCloseoutText(content);
+        return rewritten !== content;
+    }
+    if (!Array.isArray(content))
+        return false;
+    let changed = false;
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        const part = block;
+        if (part.type !== "text" || typeof part.text !== "string")
+            continue;
+        const rewritten = rewritePrematureCloseoutText(part.text);
+        if (rewritten !== part.text) {
+            part.text = rewritten;
+            changed = true;
+        }
+    }
+    return changed;
+}
+/** Rewrite assistant closeout lines on message_end during auto-mode. */
+export function sanitizePrematureCloseoutMessageEnd(event) {
+    const message = event?.message;
+    if (!message || message.role !== "assistant")
+        return;
+    rewriteAssistantMessageContent(message.content);
+}