gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Runtime state derivation from GSD workflow database and legacy files.
 // GSD Extension — State Derivation
 // DB-authoritative runtime derivation with explicit legacy filesystem fallback.
 // Pure TypeScript, zero Pi dependencies.
@@ -15,6 +17,7 @@ import { logWarning } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
 import { detectPendingEscalation } from './escalation.js';
 import { isTerminalMilestoneSummaryContent } from './milestone-summary-classifier.js';
+import { incrementLegacyTelemetry } from './legacy-telemetry.js';
 import { isDbAvailable, wasDbOpenAttempted, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, getRequirementCounts, getLatestAssessmentByScope, getPendingGateCountForTurn, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
@@ -239,6 +242,7 @@ export async function deriveState(basePath, opts) {
         }
         result = await _deriveStateImpl(basePath, opts);
         _telemetry.markdownDeriveCount++;
+        incrementLegacyTelemetry("legacy.markdownFallbackUsed");
     }
     else {
         if (wasDbOpenAttempted()) {

package/dist/resources/extensions/gsd/tool-contract.js

@@ -0,0 +1,50 @@
+// Project/App: GSD-2
+// File Purpose: ADR-015 Tool Contract module for Unit prompt, policy, and tool parity.
+import { resolveManifest, } from "./unit-context-manifest.js";
+import { getRequiredWorkflowToolsForAutoUnit } from "./workflow-mcp.js";
+export function compileUnitToolContract(unitType) {
+    const manifest = resolveManifest(unitType);
+    if (!manifest) {
+        return {
+            ok: false,
+            reason: "unknown-unit-type",
+            detail: `No Unit manifest is registered for ${unitType}`,
+        };
+    }
+    const requiredWorkflowTools = getRequiredWorkflowToolsForAutoUnit(unitType);
+    const closeoutTools = requiredWorkflowTools.filter((tool) => /^gsd_(?:task|slice|milestone|complete|validate|save|summary)/.test(tool));
+    if (requiresCloseoutTool(unitType) && closeoutTools.length === 0) {
+        return {
+            ok: false,
+            reason: "missing-closeout-tool",
+            detail: `${unitType} has no closeout workflow tool`,
+        };
+    }
+    return {
+        ok: true,
+        contract: {
+            unitType,
+            contextMode: manifest.contextMode,
+            toolsPolicy: manifest.tools,
+            requiredWorkflowTools,
+            promptObligations: [
+                `context-mode:${manifest.contextMode}`,
+                `tools-policy:${manifest.tools.mode}`,
+            ],
+            validationRules: [
+                "unit-manifest-present",
+                "workflow-tool-surface-present",
+                ...(requiresCloseoutTool(unitType) ? ["closeout-tool-present"] : []),
+            ],
+            closeoutTools,
+            artifacts: {
+                inline: manifest.artifacts.inline,
+                excerpt: manifest.artifacts.excerpt,
+                onDemand: manifest.artifacts.onDemand,
+            },
+        },
+    };
+}
+function requiresCloseoutTool(unitType) {
+    return /^(execute-task|reactive-execute|complete-slice|validate-milestone|complete-milestone|run-uat|gate-evaluate)$/.test(unitType);
+}

package/dist/resources/extensions/gsd/tools/complete-milestone.js

@@ -1,3 +1,4 @@
+// GSD2 complete-milestone tool handler
 /**
  * complete-milestone handler — the core operation behind gsd_complete_milestone.
  *
@@ -16,8 +17,7 @@ import { renderAllProjections, stripIdPrefix } from "../workflow-projections.js"
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
-function renderMilestoneSummaryMarkdown(params) {
-    const now = new Date().toISOString();
+function renderMilestoneSummaryMarkdown(params, completedAt) {
     const displayTitle = stripIdPrefix(params.title, params.milestoneId);
     // Apply defaults for optional enrichment fields (#2771)
     const keyDecisions = params.keyDecisions ?? [];
@@ -36,7 +36,7 @@ function renderMilestoneSummaryMarkdown(params) {
 id: ${params.milestoneId}
 title: "${displayTitle}"
 status: complete
-completed_at: ${now}
+completed_at: ${completedAt}
 key_decisions:
 ${keyDecisionsYaml}
 key_files:
@@ -55,15 +55,15 @@ ${params.narrative}
 
 ## Success Criteria Results
 
-${params.successCriteriaResults ?? "Not provided."}
+${params.successCriteriaResults || "Not provided."}
 
 ## Definition of Done Results
 
-${params.definitionOfDoneResults ?? "Not provided."}
+${params.definitionOfDoneResults || "Not provided."}
 
 ## Requirement Outcomes
 
-${params.requirementOutcomes ?? "Not provided."}
+${params.requirementOutcomes || "Not provided."}
 
 ## Deviations
 
@@ -89,6 +89,7 @@ export async function handleCompleteMilestone(params, basePath) {
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
     let guardError = null;
+    let alreadyComplete = false;
     transaction(() => {
         // State machine preconditions (inside txn for atomicity)
         const milestone = getMilestone(params.milestoneId);
@@ -97,7 +98,7 @@ export async function handleCompleteMilestone(params, basePath) {
             return;
         }
         if (isClosedStatus(milestone.status)) {
-            guardError = `milestone ${params.milestoneId} is already complete`;
+            alreadyComplete = true;
             return;
         }
         // Verify all slices are complete
@@ -129,7 +130,7 @@ export async function handleCompleteMilestone(params, basePath) {
         return { error: guardError };
     }
     // ── Filesystem operations (outside transaction) ─────────────────────────
-    const summaryMd = renderMilestoneSummaryMarkdown(params);
+    const summaryMd = renderMilestoneSummaryMarkdown(params, completedAt);
     let summaryPath;
     const milestoneDir = resolveMilestonePath(basePath, params.milestoneId);
     if (milestoneDir) {
@@ -177,14 +178,16 @@ export async function handleCompleteMilestone(params, basePath) {
         logWarning("tool", `complete-milestone manifest warning: ${mfErr.message}`);
     }
     try {
-        appendEvent(basePath, {
-            cmd: "complete-milestone",
-            params: { milestoneId: params.milestoneId },
-            ts: new Date().toISOString(),
-            actor: "agent",
-            actor_name: params.actorName,
-            trigger_reason: params.triggerReason,
-        });
+        if (!alreadyComplete) {
+            appendEvent(basePath, {
+                cmd: "complete-milestone",
+                params: { milestoneId: params.milestoneId },
+                ts: new Date().toISOString(),
+                actor: "agent",
+                actor_name: params.actorName,
+                trigger_reason: params.triggerReason,
+            });
+        }
     }
     catch (eventErr) {
         logError("tool", `complete-milestone event log FAILED — completion invisible to reconciliation`, { error: eventErr.message });
@@ -193,5 +196,6 @@ export async function handleCompleteMilestone(params, basePath) {
         milestoneId: params.milestoneId,
         summaryPath,
         ...(projectionStale ? { stale: true } : {}),
+        ...(alreadyComplete ? { alreadyComplete: true } : {}),
     };
 }

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Complete-task tool handler for GSD workflow state and summaries.
 /**
  * complete-task handler — the core operation behind gsd_complete_task.
  *
@@ -44,7 +46,7 @@ function taskGateFieldForId(id, params) {
  * Normalize a list parameter that may arrive as a string (newline-delimited
  * bullet list from the LLM) into a string array (#3361).
  */
-function normalizeListParam(value) {
+export function normalizeListParam(value) {
     if (Array.isArray(value))
         return value.map(String);
     if (typeof value === "string" && value.trim()) {

package/dist/resources/extensions/gsd/tools/context-mode-tool-result.js

@@ -0,0 +1,15 @@
+// Project/App: GSD-2
+// File Purpose: Shared Context Mode tool result helpers.
+export function contextModeDisabledResult(operation) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${operation} is disabled by \`context_mode.enabled: false\` in preferences. ` +
+                    "Remove that override or set it to true to re-enable Context Mode tools.",
+            },
+        ],
+        details: { operation, error: "context_mode_disabled" },
+        isError: true,
+    };
+}

package/dist/resources/extensions/gsd/tools/exec-search-tool.js

@@ -3,7 +3,12 @@
 // Scans .gsd/exec/*.meta.json and returns a ranked summary so agents can
 // re-discover past runs without re-executing. Read-only; no DB writes.
 import { searchExecHistory } from "../exec-history.js";
+import { isContextModeEnabled } from "../preferences-types.js";
+import { contextModeDisabledResult } from "./context-mode-tool-result.js";
 export function executeExecSearch(params, opts) {
+    if (!isContextModeEnabled(opts.preferences)) {
+        return contextModeDisabledResult("gsd_exec_search");
+    }
     const searchOpts = {
         query: typeof params.query === "string" ? params.query : undefined,
         runtime: params.runtime,

package/dist/resources/extensions/gsd/tools/exec-tool.js

@@ -5,6 +5,7 @@
 // for MCP return.
 import { EXEC_DEFAULTS, runExecSandbox, } from "../exec-sandbox.js";
 import { isContextModeEnabled } from "../preferences-types.js";
+import { contextModeDisabledResult } from "./context-mode-tool-result.js";
 export function buildExecOptions(baseDir, cfg, extras) {
     const allowlist = Array.isArray(cfg?.exec_env_allowlist) ? cfg.exec_env_allowlist : EXEC_DEFAULTS.envAllowlist;
     const stdoutCap = clampNumber(cfg?.exec_stdout_cap_bytes, EXEC_DEFAULTS.stdoutCapBytes, 4_096, 16_777_216);
@@ -33,19 +34,6 @@ function clampNumber(value, fallback, min, max) {
 function isEnabled(prefs) {
     return isContextModeEnabled(prefs);
 }
-function disabledResult() {
-    return {
-        content: [
-            {
-                type: "text",
-                text: "gsd_exec is disabled by `context_mode.enabled: false` in preferences. Remove that " +
-                    "override (or set it to true) to re-enable sandboxed tool-output execution.",
-            },
-        ],
-        details: { operation: "gsd_exec", error: "context_mode_disabled" },
-        isError: true,
-    };
-}
 function paramError(message) {
     return {
         content: [{ type: "text", text: `Error: ${message}` }],
@@ -55,7 +43,7 @@ function paramError(message) {
 }
 export async function executeGsdExec(params, deps) {
     if (!isEnabled(deps.preferences))
-        return disabledResult();
+        return contextModeDisabledResult("gsd_exec");
     const runtime = params.runtime;
     if (runtime !== "bash" && runtime !== "node" && runtime !== "python") {
         return paramError(`invalid runtime "${String(runtime)}" — must be bash | node | python`);
@@ -67,7 +55,7 @@ export async function executeGsdExec(params, deps) {
     if (Buffer.byteLength(script, "utf8") > 200_000) {
         return paramError("script exceeds the 200 KB length limit");
     }
-    const opts = buildExecOptions(deps.baseDir, deps.preferences?.context_mode, { now: deps.now, generateId: deps.generateId });
+    const opts = buildExecOptions(deps.baseDir, deps.preferences?.context_mode, { env: deps.env, now: deps.now, generateId: deps.generateId });
     const run = deps.run ?? runExecSandbox;
     try {
         const result = await run({

package/dist/resources/extensions/gsd/tools/memory-tools.js

@@ -256,6 +256,7 @@ function includeSupersededMemories(rankedActive) {
                 scope: row["scope"] ?? "project",
                 tags,
                 structured_fields: structuredFields,
+                last_hit_at: row["last_hit_at"] ?? null,
             };
         });
     }

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -8,6 +8,7 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { validatePlanningPathScope } from "../planning-path-scope.js";
 function validateTasks(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -91,6 +92,14 @@ export async function handlePlanSlice(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
+    const pathScopeError = validatePlanningPathScope(basePath, params.tasks.flatMap((task, index) => [
+        { field: `tasks[${index}].files`, values: task.files },
+        { field: `tasks[${index}].inputs`, values: task.inputs },
+        { field: `tasks[${index}].expectedOutput`, values: task.expectedOutput },
+    ]));
+    if (pathScopeError) {
+        return { error: `validation failed: ${pathScopeError}` };
+    }
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     // Guards must be inside the transaction so the state they check cannot
     // change between the read and the write (#2723).

package/dist/resources/extensions/gsd/tools/plan-task.js

@@ -8,6 +8,7 @@ import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
+import { validatePlanningPathScope } from "../planning-path-scope.js";
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -41,6 +42,14 @@ export async function handlePlanTask(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
+    const pathScopeError = validatePlanningPathScope(basePath, [
+        { field: "files", values: params.files },
+        { field: "inputs", values: params.inputs },
+        { field: "expectedOutput", values: params.expectedOutput },
+    ]);
+    if (pathScopeError) {
+        return { error: `validation failed: ${pathScopeError}` };
+    }
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     // Guards must be inside the transaction so the state they check cannot
     // change between the read and the write (#2723).

package/dist/resources/extensions/gsd/tools/resume-tool.js

@@ -2,7 +2,12 @@
 // agents can re-orient after compaction or session resume without
 // re-deriving project memory state.
 import { readCompactionSnapshot } from "../compaction-snapshot.js";
+import { isContextModeEnabled } from "../preferences-types.js";
+import { contextModeDisabledResult } from "./context-mode-tool-result.js";
 export function executeResume(_params, opts) {
+    if (!isContextModeEnabled(opts.preferences)) {
+        return contextModeDisabledResult("gsd_resume");
+    }
     const snapshot = readCompactionSnapshot(opts.baseDir);
     if (snapshot == null) {
         return {

package/dist/resources/extensions/gsd/tools/workflow-tool-executors.js

@@ -376,12 +376,17 @@ export async function executeCompleteMilestone(params, basePath = process.cwd())
                 isError: true,
             };
         }
+        const message = result.alreadyComplete
+            ? `Milestone ${result.milestoneId} is already complete. Summary available at ${result.summaryPath}`
+            : `Completed milestone ${result.milestoneId}. Summary written to ${result.summaryPath}`;
         return {
-            content: [{ type: "text", text: `Completed milestone ${result.milestoneId}. Summary written to ${result.summaryPath}` }],
+            content: [{ type: "text", text: message }],
             details: {
                 operation: "complete_milestone",
                 milestoneId: result.milestoneId,
                 summaryPath: result.summaryPath,
+                ...(result.alreadyComplete ? { alreadyComplete: true } : {}),
+                ...(result.stale ? { stale: true } : {}),
             },
         };
     }
@@ -675,7 +680,7 @@ export async function executeMilestoneStatus(params, basePath = process.cwd()) {
             };
             return {
                 content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
-                details: { operation: "milestone_status", milestoneId: milestone.id, sliceCount: slices.length },
+                details: { operation: "milestone_status", ...result },
             };
         });
     }

package/dist/resources/extensions/gsd/tui/render-kit.js

@@ -0,0 +1,74 @@
+// Project/App: GSD-2
+// File Purpose: Shared terminal rendering helpers for GSD extension TUI surfaces.
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+export function safeLine(text, width, ellipsis = "…") {
+    if (width <= 0)
+        return "";
+    return truncateToWidth(text, width, ellipsis);
+}
+export function padRightVisible(text, width) {
+    if (width <= 0)
+        return "";
+    const truncated = safeLine(text, width);
+    const pad = Math.max(0, width - visibleWidth(truncated));
+    return truncated + " ".repeat(pad);
+}
+export function rightAlign(left, right, width) {
+    if (width <= 0)
+        return "";
+    if (!right)
+        return safeLine(left, width);
+    if (!left)
+        return safeLine(" ".repeat(Math.max(0, width - visibleWidth(right))) + right, width);
+    const gap = Math.max(1, width - visibleWidth(left) - visibleWidth(right));
+    return safeLine(left + " ".repeat(gap) + right, width);
+}
+export function wrapVisibleText(text, width) {
+    if (width <= 0)
+        return [text];
+    return wrapTextWithAnsi(text, width).map((line) => visibleWidth(line) > width ? truncateToWidth(line, width, "…") : line);
+}
+export function renderBar(theme, width, color = "muted") {
+    return safeLine(theme.fg(color, "─".repeat(Math.max(0, width))), width, "");
+}
+export function renderKeyHints(theme, hints, width) {
+    return safeLine(theme.fg("dim", hints.filter(Boolean).join("  │  ")), width);
+}
+export function renderProgressBar(theme, done, total, width, options = {}) {
+    const barWidth = Math.max(0, width);
+    const pct = total > 0 ? Math.max(0, Math.min(1, done / total)) : 0;
+    const filled = Math.round(pct * barWidth);
+    const filledChar = options.filledChar ?? "█";
+    const emptyChar = options.emptyChar ?? "░";
+    return (theme.fg(options.filledColor ?? "success", filledChar.repeat(filled)) +
+        theme.fg(options.emptyColor ?? "dim", emptyChar.repeat(barWidth - filled)));
+}
+export function statusGlyph(theme, level) {
+    switch (level) {
+        case "active": return theme.fg("success", "●");
+        case "success": return theme.fg("success", "✓");
+        case "warning": return theme.fg("warning", "!");
+        case "error": return theme.fg("error", "x");
+        case "idle":
+        default: return theme.fg("dim", "○");
+    }
+}
+export function renderFrame(theme, inner, width, options = {}) {
+    if (width < 4)
+        return inner.map((line) => safeLine(line, width));
+    const borderColor = options.borderColor ?? "borderAccent";
+    const paddingX = Math.max(0, options.paddingX ?? 1);
+    const contentWidth = Math.max(0, width - 2 - paddingX * 2);
+    const border = (text) => theme.fg(borderColor, text);
+    const pad = " ".repeat(paddingX);
+    const lines = [border("╭" + "─".repeat(width - 2) + "╮")];
+    for (const line of inner) {
+        lines.push(border("│") +
+            pad +
+            padRightVisible(line, contentWidth) +
+            pad +
+            border("│"));
+    }
+    lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
+    return lines.map((line) => safeLine(line, width, ""));
+}

package/dist/resources/extensions/gsd/unit-context-composer.js

@@ -80,7 +80,15 @@ const CONTEXT_MODE_LANE_LABELS = {
     orchestration: "orchestration",
     docs: "documentation",
 };
-const CONTEXT_MODE_GUIDANCE = "Use `gsd_exec` for noisy scans, builds, and tests so full output stays out of prompt context; call `gsd_exec_search` before repeating prior runs; call `gsd_resume` after compaction or resume to recover stored execution context.";
+const CONTEXT_MODE_GUIDANCE_BY_LANE = {
+    interview: "Use `gsd_resume` to restore prior discussion, `gsd_exec` for noisy discovery, and `gsd_exec_search` before repeating scans.",
+    research: "Use `gsd_exec` for noisy research scans, `gsd_exec_search` before reruns, and `gsd_resume` to restore prior findings.",
+    planning: "Use `gsd_resume` for planning continuity, `gsd_exec` for noisy checks, and `gsd_exec_search` before rerunning diagnostics.",
+    execution: "Use `gsd_exec` for builds, tests, and diagnostics, `gsd_exec_search` before reruns, and `gsd_resume` after compaction or resume.",
+    verification: "Use `gsd_exec` for verification commands, `gsd_exec_search` to reuse prior evidence, and `gsd_resume` after compaction or resume.",
+    orchestration: "Use `gsd_resume` before resuming orchestration, `gsd_exec_search` to reuse prior runs, and `gsd_exec` for noisy coordination checks.",
+    docs: "Use `gsd_resume` for prior context, `gsd_exec_search` for saved evidence, and `gsd_exec` for noisy doc validation commands.",
+};
 /**
  * Render the Context Mode instruction lane for a unit type. Unknown unit
  * types, disabled config, and explicit `contextMode: "none"` all omit the
@@ -93,14 +101,15 @@ export function composeContextModeInstructions(unitType, opts) {
     if (!manifest || manifest.contextMode === "none")
         return "";
     const lane = CONTEXT_MODE_LANE_LABELS[manifest.contextMode];
+    const guidance = CONTEXT_MODE_GUIDANCE_BY_LANE[manifest.contextMode];
     if (opts.renderMode === "nested") {
-        return `Context Mode (${lane} lane): ${CONTEXT_MODE_GUIDANCE}`;
+        return `Context Mode (${lane} lane): ${guidance}`;
     }
     return [
         "## Context Mode",
         "",
         `Lane: **${lane} lane**.`,
-        CONTEXT_MODE_GUIDANCE,
+        guidance,
     ].join("\n");
 }
 const SECTION_SEPARATOR = "\n\n---\n\n";

package/dist/resources/extensions/gsd/unit-runtime.js

@@ -4,6 +4,8 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { gsdRoot, relSliceFile, relTaskFile, resolveSliceFile, resolveTaskFile, } from "./paths.js";
 import { loadFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
 import { parseUnitId } from "./unit-id.js";
+import { getTask, isDbAvailable, refreshOpenDatabaseFromDisk } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 // Per-record advisory lock — prevents read-modify-write races between
 // concurrent writers updating disjoint fields of the same runtime record.
 // Within a single Node process this is moot (writeUnitRuntimeRecord is sync),
@@ -67,6 +69,17 @@ function withRecordLock(recordPath, fn) {
         catch { /* best-effort */ }
     }
 }
+export const IN_FLIGHT_RUNTIME_PHASES = new Set([
+    "dispatched",
+    "wrapup-warning-sent",
+    "timeout",
+    "finalize-timeout",
+    "crashed",
+    "paused",
+]);
+export function isInFlightRuntimePhase(phase) {
+    return IN_FLIGHT_RUNTIME_PHASES.has(phase);
+}
 function runtimeDir(basePath) {
     return join(gsdRoot(basePath), "runtime", "units");
 }
@@ -154,6 +167,12 @@ export async function inspectExecuteTaskDurability(basePath, unitId) {
     const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const taskChecked = !!planContent && new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m").test(planContent);
     const nextActionAdvanced = !new RegExp(`Execute ${tid}\\b`).test(stateContent);
+    let dbComplete = false;
+    if (isDbAvailable()) {
+        refreshOpenDatabaseFromDisk();
+        const task = getTask(mid, sid, tid);
+        dbComplete = !!task && isClosedStatus(task.status);
+    }
     // Must-have coverage: load task plan and count mentions in summary
     let mustHaveCount = 0;
     let mustHavesMentionedInSummary = 0;
@@ -177,11 +196,14 @@ export async function inspectExecuteTaskDurability(basePath, unitId) {
         summaryExists,
         taskChecked,
         nextActionAdvanced,
+        dbComplete,
         mustHaveCount,
         mustHavesMentionedInSummary,
     };
 }
 export function formatExecuteTaskRecoveryStatus(status) {
+    if (status.dbComplete)
+        return "DB task status is closed";
     const missing = [];
     if (!status.summaryExists)
         missing.push(`summary missing (${status.summaryPath})`);

package/dist/resources/extensions/gsd/uok/kernel.js

@@ -5,6 +5,7 @@ import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
 import { setUnifiedAuditEnabled } from "./audit-toggle.js";
 import { resolveUokFlags } from "./flags.js";
 import { createTurnObserver } from "./loop-adapter.js";
+import { incrementLegacyTelemetry } from "../legacy-telemetry.js";
 function parityLogPath(basePath) {
     return join(gsdRoot(basePath), "runtime", "uok-parity.jsonl");
 }
@@ -27,9 +28,13 @@ export async function runAutoLoopWithUok(args) {
     const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
     const flags = resolveUokFlags(prefs);
     setUnifiedAuditEnabled(flags.auditUnified);
+    const pathLabel = resolveKernelPathLabel(flags);
+    if (pathLabel !== "uok-kernel") {
+        incrementLegacyTelemetry("legacy.uokFallbackUsed");
+    }
     writeParityEvent(s.basePath, {
         ts: new Date().toISOString(),
-        path: resolveKernelPathLabel(flags),
+        path: pathLabel,
         flags,
         phase: "enter",
     });
@@ -65,7 +70,7 @@ export async function runAutoLoopWithUok(args) {
         }
         writeParityEvent(s.basePath, {
             ts: new Date().toISOString(),
-            path: resolveKernelPathLabel(flags),
+            path: pathLabel,
             flags,
             phase: "exit",
             status: "ok",
@@ -74,7 +79,7 @@ export async function runAutoLoopWithUok(args) {
     catch (err) {
         writeParityEvent(s.basePath, {
             ts: new Date().toISOString(),
-            path: resolveKernelPathLabel(flags),
+            path: pathLabel,
             flags,
             phase: "exit",
             status: "error",

package/dist/resources/extensions/gsd/uok/plan-v2.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: UOK plan v2 graph compilation from GSD workflow state.
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot, resolveMilestoneFile, resolveSliceFile } from "../paths.js";