gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.4ea7d80e7

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

@@ -219,6 +219,169 @@ export async function inlineFileSmart(absPath, relPath, label, query, threshold
     const truncated = truncateAtSectionBoundary(content, threshold).content;
     return `### ${label}\nSource: \`${relPath}\`\n\n${truncated}`;
 }
+function inlineCompactTemplate(name, label) {
+    const compact = {
+        plan: [
+            "# {{sliceId}}: {{sliceTitle}}",
+            "",
+            "**Goal:** {{goal}}",
+            "**Demo:** {{demo}}",
+            "",
+            "## Must-Haves",
+            "- {{mustHave}}",
+            "",
+            "## Threat Surface",
+            "- Abuse: {{abuseScenarios}}",
+            "- Data exposure: {{sensitiveDataAccessible}}",
+            "- Input trust: {{untrustedInput}}",
+            "",
+            "## Requirement Impact",
+            "- Requirements touched: {{requirementIds}}",
+            "- Re-verify: {{whatMustBeRetested}}",
+            "- Decisions revisited: {{decisionIds}}",
+            "",
+            "## Proof Level",
+            "- This slice proves: {{contract | integration | operational | final-assembly}}",
+            "- Real runtime required: {{yes/no}}",
+            "- Human/UAT required: {{yes/no}}",
+            "",
+            "## Verification",
+            "- {{testFileOrCommand}}",
+            "",
+            "## Observability / Diagnostics",
+            "- Runtime signals: {{signalOrNone}}",
+            "- Inspection surfaces: {{surfaceOrNone}}",
+            "- Failure visibility: {{failureSignalOrNone}}",
+            "- Redaction constraints: {{secretOrPiiBoundaryOrNone}}",
+            "",
+            "## Integration Closure",
+            "- Upstream surfaces consumed: {{filesModulesContracts}}",
+            "- New wiring introduced: {{entrypointOrNone}}",
+            "- Remaining end-to-end work: {{listOrNothing}}",
+            "",
+            "## Tasks",
+            "- [ ] **T01: {{taskTitle}}** `est:{{estimate}}`",
+            "  - Why: {{whyThisTaskExists}}",
+            "  - Files: `{{filePath}}`",
+            "  - Do: {{specificImplementationStepsAndConstraints}}",
+            "  - Verify: {{testCommandOrRuntimeCheck}}",
+            "  - Done when: {{measurableAcceptanceCondition}}",
+            "",
+            "## Files Likely Touched",
+            "- `{{filePath}}`",
+        ].join("\n"),
+        "task-summary": [
+            "---",
+            "id: {{taskId}}",
+            "parent: {{sliceId}}",
+            "milestone: {{milestoneId}}",
+            "provides: [{{whatThisTaskProvides}}]",
+            "key_files: [{{filePath}}]",
+            "key_decisions: [{{decision}}]",
+            "patterns_established: [{{pattern}}]",
+            "observability_surfaces: [{{diagnosticOrNone}}]",
+            "duration: {{duration}}",
+            "verification_result: passed",
+            "completed_at: {{date}}",
+            "blocker_discovered: false",
+            "---",
+            "",
+            "# {{taskId}}: {{taskTitle}}",
+            "**{{oneLiner}}**",
+            "",
+            "## What Happened",
+            "{{narrative}}",
+            "",
+            "## Verification",
+            "{{whatWasVerifiedAndHow}}",
+            "",
+            "## Verification Evidence",
+            "| # | Command | Exit Code | Verdict | Duration |",
+            "|---|---------|-----------|---------|----------|",
+            "| {{row}} | {{command}} | {{exitCode}} | {{verdict}} | {{duration}} |",
+            "",
+            "## Diagnostics",
+            "{{diagnosticsOrNone}}",
+            "",
+            "## Deviations",
+            "{{deviationsFromPlan_OR_none}}",
+            "",
+            "## Known Issues",
+            "{{issuesDiscoveredButNotFixed_OR_none}}",
+            "",
+            "## Files Created/Modified",
+            "- `{{filePath}}` - {{description}}",
+        ].join("\n"),
+        "slice-summary": [
+            "---",
+            "id: {{sliceId}}",
+            "parent: {{milestoneId}}",
+            "milestone: {{milestoneId}}",
+            "provides: [{{whatThisSliceProvides}}]",
+            "requires: []",
+            "affects: []",
+            "key_files: [{{filePath}}]",
+            "key_decisions: [{{decision}}]",
+            "patterns_established: [{{pattern}}]",
+            "observability_surfaces: [{{diagnosticOrNone}}]",
+            "drill_down_paths: [{{pathToTaskSummary}}]",
+            "duration: {{duration}}",
+            "verification_result: passed",
+            "completed_at: {{date}}",
+            "---",
+            "",
+            "# {{sliceId}}: {{sliceTitle}}",
+            "**{{oneLiner}}**",
+            "",
+            "## What Happened",
+            "{{narrative}}",
+            "",
+            "## Verification",
+            "{{whatWasVerifiedAcrossAllTasks}}",
+            "",
+            "## Requirements Advanced",
+            "- {{requirementId}} - {{howThisSliceAdvancedIt}}",
+            "",
+            "## Requirements Validated",
+            "- {{requirementId}} - {{whatProofNowMakesItValidated}}",
+            "",
+            "## New Requirements Surfaced",
+            "- {{newRequirementOr_none}}",
+            "",
+            "## Requirements Invalidated or Re-scoped",
+            "- {{requirementIdOr_none}} - {{whatChanged}}",
+            "",
+            "## Operational Readiness",
+            "- Health signal: {{healthSignalOrNA}}",
+            "- Failure signal: {{failureSignalOrNA}}",
+            "- Recovery: {{recoveryOrNA}}",
+            "- Monitoring gaps: {{gapsOrNone}}",
+            "",
+            "## Deviations",
+            "{{deviationsFromPlan_OR_none}}",
+            "",
+            "## Known Limitations",
+            "{{whatDoesntWorkYet_OR_whatWasDeferredToLaterSlices}}",
+            "",
+            "## Follow-ups",
+            "{{workDeferredOrDiscoveredDuringExecution_OR_none}}",
+            "",
+            "## Files Created/Modified",
+            "- `{{filePath}}` - {{description}}",
+            "",
+            "## Forward Intelligence",
+            "### What the next slice should know",
+            "- {{insightThatWouldHelpDownstreamWork}}",
+            "### What's fragile",
+            "- {{fragileAreaOrThinImplementation}} - {{whyItMatters}}",
+            "### Authoritative diagnostics",
+            "- {{whereAFutureAgentShouldLookFirst}} - {{whyThisSignalIsTrustworthy}}",
+            "### What assumptions changed",
+            "- {{originalAssumption}} - {{whatActuallyHappened}}",
+        ].join("\n"),
+    };
+    return `${compact[name]}\n\n### Output Template: ${label}\nSource: \`templates/${name}.md\``;
+}
 /**
  * Compact slice-summary excerpt for milestone-level closers (#4780).
  *
@@ -1493,7 +1656,7 @@ async function renderSlicePrompt(options) {
     const graphBlock = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
     if (graphBlock)
         inlined.push(graphBlock);
-    inlined.push(inlineTemplate("plan", "Slice Plan"));
+    inlined.push(level === "minimal" ? inlineCompactTemplate("plan", "Slice Plan") : inlineTemplate("plan", "Slice Plan"));
     if (level === "full") {
         inlined.push(inlineTemplate("task-plan", "Task Plan"));
     }
@@ -1648,7 +1811,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     // 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")
+        ? inlineCompactTemplate("task-summary", "Task Summary")
         : [
             inlineTemplate("task-summary", "Task Summary"),
             inlineTemplate("decisions", "Decisions"),
@@ -1782,7 +1945,9 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
                 return blocks.length > 0 ? blocks.join("\n\n---\n\n") : null;
             }
             case "templates": {
-                const parts = [inlineTemplate("slice-summary", "Slice Summary")];
+                const parts = [inlineLevel === "minimal"
+                        ? inlineCompactTemplate("slice-summary", "Slice Summary")
+                        : inlineTemplate("slice-summary", "Slice Summary")];
                 if (inlineLevel !== "minimal") {
                     parts.push(inlineTemplate("uat", "UAT"));
                 }

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

@@ -12,7 +12,7 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -110,17 +110,32 @@ export function hasImplementationArtifacts(basePath, milestoneId) {
         // milestone commits instead of treating the self-diff as proof of no work.
         if (changedFiles.length === 0) {
             if (milestoneId && currentBranch === integrationBranch) {
-                const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
-                if (!tagged.ok)
+                const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+                if (!milestoneEvidence.ok)
                     return "unknown";
-                if (tagged.matched)
-                    return classifyImplementationFiles(tagged.files);
+                if (milestoneEvidence.matched)
+                    return classifyImplementationFiles(milestoneEvidence.files);
             }
             if (currentBranch && currentBranch !== "HEAD")
                 return "absent";
             return "unknown";
         }
-        return classifyImplementationFiles(changedFiles);
+        const branchClassification = classifyImplementationFiles(changedFiles);
+        if (branchClassification === "present")
+            return "present";
+        // A completing milestone branch can have a non-empty diff containing only
+        // .gsd/ closeout files after implementation commits already landed on the
+        // recorded integration branch. In that topology, the branch diff alone is
+        // insufficient; use the same milestone-tagged evidence fallback as the
+        // self-diff retry path before declaring the milestone implementation-free.
+        if (milestoneId) {
+            const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+            if (!milestoneEvidence.ok)
+                return "unknown";
+            if (milestoneEvidence.matched)
+                return classifyImplementationFiles(milestoneEvidence.files);
+        }
+        return "absent";
     }
     catch (e) {
         // Non-fatal — if git operations fail, return unknown so callers can decide
@@ -148,6 +163,9 @@ function classifyImplementationFiles(files) {
 function isImplementationPath(file) {
     return !file.startsWith(".gsd/") && !file.startsWith(".gsd\\");
 }
+function normalizeRepoPath(file) {
+    return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
 /**
  * Detect the main/master branch name.
  */
@@ -217,7 +235,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     ]);
     if (!scoped.ok)
         return scoped;
-    if (scoped.matched)
+    if (scoped.matched && classifyImplementationFiles(scoped.files) === "present")
         return scoped;
     // Fallback (#5033): when .gsd/ is gitignored / external / untracked, the
     // path-scoped scan matches no commits even though GSD-tagged commits
@@ -228,9 +246,137 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // Intentionally unbounded — symmetric with the primary scan, and avoids
     // reintroducing the rolling-depth failure class removed in #4699 where
     // milestone evidence aged out behind unrelated activity.
-    return scanGsdTaggedCommits(basePath, milestoneId, [
+    const unscoped = scanGsdTaggedCommits(basePath, milestoneId, [
         "log", "--format=%H%x1f%B%x1e", "HEAD",
     ]);
+    if (!unscoped.ok)
+        return scoped.matched ? scoped : unscoped;
+    if (!unscoped.matched)
+        return scoped;
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...scoped.files, ...unscoped.files])],
+    };
+}
+function getChangedFilesFromMilestoneEvidence(basePath, milestoneId) {
+    const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
+    if (!tagged.ok)
+        return tagged;
+    if (tagged.matched && classifyImplementationFiles(tagged.files) === "present")
+        return tagged;
+    const attributed = getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId);
+    if (!attributed.ok)
+        return tagged.matched ? tagged : attributed;
+    if (attributed.matched && classifyImplementationFiles(attributed.files) === "present")
+        return attributed;
+    const backfilled = backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId);
+    if (!backfilled.ok)
+        return tagged.matched ? tagged : attributed.matched ? attributed : backfilled;
+    if (!backfilled.matched) {
+        if (tagged.matched)
+            return tagged;
+        return attributed.matched ? attributed : backfilled;
+    }
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...tagged.files, ...attributed.files, ...backfilled.files])],
+    };
+}
+function getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const shas = getMilestoneCommitAttributionShas(milestoneId);
+        if (shas.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const files = new Set();
+        let matched = false;
+        for (const sha of shas) {
+            if (!isFullCommitSha(sha))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, sha);
+            if (commitFiles.length === 0)
+                continue;
+            matched = true;
+            for (const file of commitFiles)
+                files.add(file);
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution scan failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const milestone = getMilestone(milestoneId);
+        const milestoneStartedAt = milestone?.created_at ? Math.floor(Date.parse(milestone.created_at) / 1000) * 1000 : NaN;
+        if (!Number.isFinite(milestoneStartedAt))
+            return { ok: true, matched: false, files: [] };
+        const taskFileHints = getCompletedMilestoneTaskFileHints(milestoneId);
+        if (taskFileHints.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const hintSet = new Set(taskFileHints.map(normalizeRepoPath).filter(Boolean));
+        if (hintSet.size === 0)
+            return { ok: true, matched: false, files: [] };
+        const records = getCommitRecords(basePath);
+        const files = new Set();
+        let matched = false;
+        for (const record of records) {
+            if (!isFullCommitSha(record.hash))
+                continue;
+            if (Date.parse(record.committedAt) < milestoneStartedAt)
+                continue;
+            if (record.parents.trim().split(/\s+/).filter(Boolean).length > 1)
+                continue;
+            if (commitMessageHasGsdTrailer(record.message))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, record.hash);
+            const implementationFiles = commitFiles.map(normalizeRepoPath).filter(isImplementationPath);
+            if (implementationFiles.length === 0)
+                continue;
+            if (!implementationFiles.some((file) => hintSet.has(file)))
+                continue;
+            matched = true;
+            for (const file of implementationFiles)
+                files.add(file);
+            recordMilestoneCommitAttribution({
+                commitSha: record.hash,
+                milestoneId,
+                source: "backfill",
+                confidence: 0.8,
+                files: implementationFiles,
+                createdAt: new Date().toISOString(),
+            });
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution backfill failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function getCommitRecords(basePath) {
+    const logOutput = execFileSync("git", ["log", "--format=%H%x1f%P%x1f%cI%x1f%B%x1e", "HEAD"], {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+    });
+    return logOutput
+        .split("\x1e")
+        .map((record) => record.trim())
+        .filter(Boolean)
+        .flatMap((record) => {
+        const parts = record.split("\x1f");
+        if (parts.length < 4)
+            return [];
+        const [hash, parents, committedAt, ...messageParts] = parts;
+        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message: messageParts.join("\x1f") }];
+    });
+}
+function isFullCommitSha(value) {
+    return /^[0-9a-f]{40}$/i.test(value);
 }
 function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
     try {
@@ -510,66 +656,32 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             return false;
         }
     }
-    // plan-slice must produce a plan with actual task entries, not just a scaffold.
-    // The plan file may exist from a prior discussion/context step with only headings
-    // but no tasks. Without this check the artifact is considered "complete" and the
-    // unit gets skipped — but deriveState still returns phase:"planning" because the
-    // plan has no tasks, creating an infinite skip loop (#699).
-    if (unitType === "plan-slice") {
-        const planContent = readFileSync(absPath, "utf-8");
-        // 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) {
-            logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
-            return false;
-        }
-    }
-    // execute-task: DB status is authoritative. Fall back to checked-checkbox
-    // detection when the DB is unavailable (unmigrated projects), or when the
-    // disk artifacts already reflect completion but the DB replay is one beat
-    // behind the completion write.
-    if (unitType === "execute-task") {
-        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-        if (mid && sid && tid) {
-            const dbTask = getTask(mid, sid, tid);
-            if (dbTask) {
-                if (dbTask.status !== "complete" && dbTask.status !== "done" && !hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) {
-                    return false;
-                }
-            }
-            else if (!isDbAvailable()) {
-                // LEGACY: Pre-migration fallback for projects without DB.
-                // Require a CHECKED checkbox — a bare heading or unchecked checkbox
-                // does not prove gsd_complete_task ran. Summary file on disk alone
-                // is not sufficient evidence (could be a rogue write) (#3607).
-                if (!hasCheckedTaskCompletionOnDisk(base, mid, sid, tid))
-                    return false;
-            }
-            else {
-                // DB available but task row not found — completion tool never ran (#3607)
-                return false;
-            }
-        }
-    }
-    // plan-slice must also produce individual task plan files for every task listed
-    // in the slice plan. Without this check, a plan-slice that wrote S{sid}-PLAN.md
-    // but omitted T{tid}-PLAN.md files would be marked complete, causing execute-task
-    // to dispatch with a missing task plan (see issue #739).
+    // plan-slice verification is DB-primary. The slice plan is a projection, so
+    // DB task rows prove the slice was planned even if the rendered markdown no
+    // longer uses legacy checkbox/heading syntax.
     if (unitType === "plan-slice") {
         const { milestone: mid, slice: sid } = parseUnitId(unitId);
         if (mid && sid) {
             try {
-                // DB primary path — get task IDs to verify task plan files exist
                 let taskIds = null;
                 if (isDbAvailable()) {
-                    const tasks = getSliceTasks(mid, sid);
-                    if (tasks.length > 0)
-                        taskIds = tasks.map(t => t.id);
+                    const refreshed = refreshOpenDatabaseFromDisk();
+                    if (refreshed) {
+                        const tasks = getSliceTasks(mid, sid);
+                        if (tasks.length > 0)
+                            taskIds = tasks.map(t => t.id);
+                    }
                 }
                 if (!taskIds) {
-                    // LEGACY: DB unavailable or no tasks in DB — parse plan file for task IDs
+                    // LEGACY: DB unavailable or no tasks in DB. Require actual task
+                    // entries so an empty scaffold cannot advance the pipeline (#699).
                     const planContent = readFileSync(absPath, "utf-8");
+                    const hasCheckboxTask = /^\s*- \[[xX ]\] \*\*T\d+:/m.test(planContent);
+                    const hasHeadingTask = /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
+                    if (!hasCheckboxTask && !hasHeadingTask) {
+                        logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
+                        return false;
+                    }
                     const plan = parseLegacyPlan(planContent);
                     if (plan.tasks.length > 0)
                         taskIds = plan.tasks.map((t) => t.id);
@@ -595,6 +707,33 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             }
         }
     }
+    // execute-task: DB status is authoritative. Fall back to checked-checkbox
+    // detection when the DB is unavailable (unmigrated projects), or when the
+    // disk artifacts already reflect completion but the DB replay is one beat
+    // behind the completion write.
+    if (unitType === "execute-task") {
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+        if (mid && sid && tid) {
+            const dbTask = getTask(mid, sid, tid);
+            if (dbTask) {
+                if (dbTask.status !== "complete" && dbTask.status !== "done" && !hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) {
+                    return false;
+                }
+            }
+            else if (!isDbAvailable()) {
+                // LEGACY: Pre-migration fallback for projects without DB.
+                // Require a CHECKED checkbox — a bare heading or unchecked checkbox
+                // does not prove gsd_complete_task ran. Summary file on disk alone
+                // is not sufficient evidence (could be a rogue write) (#3607).
+                if (!hasCheckedTaskCompletionOnDisk(base, mid, sid, tid))
+                    return false;
+            }
+            else {
+                // DB available but task row not found — completion tool never ran (#3607)
+                return false;
+            }
+        }
+    }
     // complete-slice: DB status is authoritative for whether the slice is done.
     // Fall back to file-based check (roadmap [x]) when DB is unavailable.
     if (unitType === "complete-slice") {

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -3,11 +3,15 @@ import { AutoSession } from "./auto/session.js";
 import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationError, markToolEnd as markTrackedToolEnd, markToolStart as markTrackedToolStart, } from "./auto-tool-tracking.js";
 export const autoSession = new AutoSession();
 export function getAutoRuntimeSnapshot() {
+    const orchestrationStatus = autoSession.orchestration?.getStatus();
     return {
         active: autoSession.active,
         paused: autoSession.paused,
         currentUnit: autoSession.currentUnit ? { ...autoSession.currentUnit } : null,
         basePath: autoSession.basePath,
+        orchestrationPhase: orchestrationStatus?.phase,
+        orchestrationTransitionCount: orchestrationStatus?.transitionCount,
+        orchestrationLastTransitionAt: orchestrationStatus?.lastTransitionAt,
     };
 }
 export function isAutoActive() {

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

@@ -487,9 +487,8 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             hasSurvivorBranch = false;
         }
         const effectivePrefs = loadEffectiveGSDPreferences(base)?.preferences;
-        const deepProjectStagePending = !hasSurvivorBranch
-            ? (await import("./auto-dispatch.js")).hasPendingDeepStage(effectivePrefs, base)
-            : false;
+        const { shouldRunDeepProjectSetup } = await import("./auto-dispatch.js");
+        const deepProjectStagePending = shouldRunDeepProjectSetup(state, effectivePrefs, base, { hasSurvivorBranch });
         if (deepProjectStagePending) {
             // Deep project-level setup runs before the first milestone exists. Let
             // the auto loop dispatch workflow-preferences / project / requirements

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

@@ -1,14 +1,5 @@
-/**
- * Post-unit verification gate for auto-mode.
- *
- * Runs typecheck/lint/test checks, captures runtime errors, performs
- * dependency audits, handles auto-fix retry logic, and writes
- * verification evidence JSON.
- *
- * Extracted from the pre-loop agent_end handler in auto.ts. Returns a
- * sentinel value instead of calling return/pauseAuto directly — the
- * caller checks the result and handles control flow.
- */
+// Project/App: GSD-2
+// File Purpose: Post-unit verification gate for GSD auto-mode units.
 import { mkdirSync, writeFileSync } from "node:fs";
 import { resolveSlicePath, resolveMilestoneFile } from "./paths.js";
 import { parseUnitId } from "./unit-id.js";