gsd-pi 2.79.0-dev.5c910bb05 → 2.79.0-dev.bbb2f88ce

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-dbdfc4ddfea7fdce
+b873eb2a8c4529c9

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

@@ -1089,7 +1089,12 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     s.lastGitActionFailure = null;
     s.lastGitActionStatus = null;
     s.lastUnitAgentEndMessages = null;
-    setCurrentPhase(unitType);
+    setCurrentPhase(unitType, {
+        basePath: s.basePath,
+        traceId: ic.flowId,
+        turnId: `iter-${ic.iteration}`,
+        causedBy: "unit-start",
+    });
     s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
     const unitStartSeq = ic.nextSeq();
     deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });

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

@@ -128,9 +128,9 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
             }
             return `${relSliceFile(base, mid, sid, "RESEARCH")} (slice research)`;
         case "plan-slice":
-            return `${relSliceFile(base, mid, sid, "PLAN")} (slice plan)`;
+            return `${relSliceFile(base, mid, sid, "PLAN")} plus tasks/T##-PLAN.md files (slice plan and task plans)`;
         case "refine-slice":
-            return `${relSliceFile(base, mid, sid, "PLAN")} (refined slice plan from sketch)`;
+            return `${relSliceFile(base, mid, sid, "PLAN")} plus tasks/T##-PLAN.md files (refined slice plan and task plans)`;
         case "execute-task": {
             return `Task ${tid} marked [x] in ${relSliceFile(base, mid, sid, "PLAN")} + summary written`;
         }

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

@@ -559,6 +559,8 @@ export const DISPATCH_RULES = [
             const hasContext = !!(contextFile && (await loadFile(contextFile)));
             if (hasContext)
                 return null; // fall through to next rule
+            if (prefs?.planning_depth === "deep")
+                return null;
             // H6 fix (#4973): keep the non-deep auto-mode bypass, but do not
             // pre-verify deep planning's user-facing milestone approval gate.
             if (shouldBypassMilestoneDepthGateInAuto(prefs)) {

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

@@ -257,7 +257,7 @@ function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
             if (!commitMessageHasGsdTrailer(message))
                 continue;
             const commitFiles = getChangedFilesForCommit(basePath, hash);
-            if (!commitMatchesMilestone(message, milestoneId, commitFiles))
+            if (!commitMatchesMilestone(basePath, message, milestoneId, commitFiles))
                 continue;
             matched = true;
             for (const file of commitFiles) {
@@ -278,22 +278,37 @@ function getChangedFilesForCommit(basePath, hash) {
 function commitMessageHasGsdTrailer(message) {
     return /^GSD-(?:Task|Unit):\s*\S+/m.test(message);
 }
-function commitMatchesMilestone(message, milestoneId, files) {
+function commitMatchesMilestone(basePath, message, milestoneId, files) {
     if (commitTrailerStartsWithMilestone(message, milestoneId))
         return true;
     // Meaningful execute-task commits currently store task scope as Sxx/Tyy
     // rather than Mxx/Sxx/Tyy. Bind those commits back to the milestone when
     // either the commit touched this milestone's artifacts, or — for projects
     // where .gsd/ is gitignored/external (#5033) — the message explicitly
-    // names the milestone.
+    // names the milestone or local GSD state proves the task belongs here.
     if (/^GSD-Task:\s*S[^/\s]+\/T\S+/m.test(message)) {
         if (files.some((file) => isMilestoneArtifactPath(file, milestoneId)))
             return true;
         if (commitMessageMentionsMilestone(message, milestoneId))
             return true;
+        if (commitTaskTrailerBelongsToMilestone(basePath, message, milestoneId))
+            return true;
     }
     return false;
 }
+function commitTaskTrailerBelongsToMilestone(basePath, message, milestoneId) {
+    const match = message.match(/^GSD-Task:\s*(S[^/\s]+)\/(T[^\s]+)/m);
+    if (!match)
+        return false;
+    const [, sliceId, taskId] = match;
+    if (getTask(milestoneId, sliceId, taskId))
+        return true;
+    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    if (!tasksDir)
+        return false;
+    return existsSync(join(tasksDir, `${taskId}-PLAN.md`))
+        || existsSync(join(tasksDir, `${taskId}-SUMMARY.md`));
+}
 function commitMessageMentionsMilestone(message, milestoneId) {
     if (!MILESTONE_ID_RE.test(milestoneId))
         return false;

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

@@ -486,8 +486,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             // Clear survivor flag — finalization is done
             hasSurvivorBranch = false;
         }
+        const effectivePrefs = loadEffectiveGSDPreferences(base)?.preferences;
         const deepProjectStagePending = !hasSurvivorBranch
-            ? (await import("./auto-dispatch.js")).hasPendingDeepStage(loadEffectiveGSDPreferences(base)?.preferences, base)
+            ? (await import("./auto-dispatch.js")).hasPendingDeepStage(effectivePrefs, base)
             : false;
         if (deepProjectStagePending) {
             // Deep project-level setup runs before the first milestone exists. Let
@@ -526,7 +527,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 const mid = state.activeMilestone.id;
                 const contextFile = resolveMilestoneFile(base, mid, "CONTEXT");
                 const hasContext = !!(contextFile && (await loadFile(contextFile)));
-                if (!hasContext) {
+                if (!hasContext && effectivePrefs?.planning_depth !== "deep") {
                     const { showSmartEntry } = await import("./guided-flow.js");
                     await showSmartEntry(ctx, pi, base, { step: requestedStepMode });
                     // showSmartEntry dispatches via pi.sendMessage() which is fire-and-forget:

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

@@ -177,8 +177,12 @@ export function resolveDir(parentDir, idPrefix) {
         const exact = entries.find(e => e.isDirectory() && e.name === idPrefix);
         if (exact)
             return exact.name;
+        const idLower = idPrefix.toLowerCase();
+        const exactCaseInsensitive = entries.find(e => e.isDirectory() && e.name.toLowerCase() === idLower);
+        if (exactCaseInsensitive)
+            return exactCaseInsensitive.name;
         // Prefix match for legacy descriptor dirs: M001-SOMETHING
-        const prefixed = entries.find(e => e.isDirectory() && e.name.startsWith(idPrefix + "-"));
+        const prefixed = entries.find(e => e.isDirectory() && e.name.toLowerCase().startsWith(idLower + "-"));
         return prefixed ? prefixed.name : null;
     }
     catch {

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

@@ -1,3 +1,4 @@
+// GSD2 UOK Audit Events and DB-First Projection Writes
 import { appendFileSync, closeSync, existsSync, mkdirSync, openSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -5,6 +6,7 @@ import { isStaleWrite } from "../auto/turn-epoch.js";
 import { withFileLockSync } from "../file-lock.js";
 import { gsdRoot } from "../paths.js";
 import { isDbAvailable, insertAuditEvent } from "../gsd-db.js";
+import { CURRENT_UOK_CONTRACT_VERSION, validateAuditEvent } from "./contracts.js";
 function auditLogPath(basePath) {
     return join(gsdRoot(basePath), "audit", "events.jsonl");
 }
@@ -13,6 +15,7 @@ function ensureAuditDir(basePath) {
 }
 export function buildAuditEnvelope(args) {
     return {
+        version: CURRENT_UOK_CONTRACT_VERSION,
         eventId: randomUUID(),
         traceId: args.traceId,
         turnId: args.turnId,
@@ -27,6 +30,25 @@ export function emitUokAuditEvent(basePath, event) {
     // Drop writes from a turn superseded by timeout recovery / cancellation.
     if (isStaleWrite("uok-audit"))
         return;
+    const validation = validateAuditEvent(event);
+    if (!validation.ok) {
+        throw new Error(`Invalid UOK audit event: ${validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+    }
+    const canonical = validation.value;
+    if (isDbAvailable()) {
+        try {
+            insertAuditEvent({
+                ...canonical,
+                payload: {
+                    ...canonical.payload,
+                    contractVersion: canonical.version ?? CURRENT_UOK_CONTRACT_VERSION,
+                },
+            });
+        }
+        catch (err) {
+            throw new Error(`DB authoritative audit write failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     try {
         ensureAuditDir(basePath);
         const path = auditLogPath(basePath);
@@ -39,18 +61,10 @@ export function emitUokAuditEvent(basePath, event) {
         // POSIX O_APPEND atomicity still protects small line writes, so skipping
         // the lock rather than stalling orchestration is the correct tradeoff.
         withFileLockSync(path, () => {
-            appendFileSync(path, `${JSON.stringify(event)}\n`, "utf-8");
+            appendFileSync(path, `${JSON.stringify(canonical)}\n`, "utf-8");
         }, { onLocked: "skip" });
     }
     catch {
         // Best-effort: audit writes must never break orchestration.
     }
-    if (!isDbAvailable())
-        return;
-    try {
-        insertAuditEvent(event);
-    }
-    catch {
-        // Projection failures are non-fatal while legacy readers are still active.
-    }
 }

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

@@ -1 +1,69 @@
-export {};
+// GSD2 UOK Contract Types and Versioning
+export const CURRENT_UOK_CONTRACT_VERSION = "1";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeVersion(value) {
+    return value === CURRENT_UOK_CONTRACT_VERSION ? CURRENT_UOK_CONTRACT_VERSION : "0";
+}
+function requireString(value, key, issues) {
+    if (typeof value[key] !== "string" || value[key] === "") {
+        issues.push({ path: key, message: `${key} must be a non-empty string` });
+    }
+}
+function requireRecord(value, key, issues) {
+    if (!isRecord(value[key])) {
+        issues.push({ path: key, message: `${key} must be an object` });
+    }
+}
+export function normalizeTurnResult(value) {
+    return { ...value, version: normalizeVersion(value.version) };
+}
+export function normalizeDispatchEnvelope(value) {
+    return { ...value, version: normalizeVersion(value.version) };
+}
+export function normalizeAuditEvent(value) {
+    return { ...value, version: normalizeVersion(value.version) };
+}
+export function validateTurnResult(value) {
+    const normalized = normalizeTurnResult(value);
+    const record = normalized;
+    const issues = [];
+    requireString(record, "traceId", issues);
+    requireString(record, "turnId", issues);
+    if (!Number.isInteger(record.iteration)) {
+        issues.push({ path: "iteration", message: "iteration must be an integer" });
+    }
+    requireString(record, "status", issues);
+    requireString(record, "failureClass", issues);
+    if (!Array.isArray(record.phaseResults)) {
+        issues.push({ path: "phaseResults", message: "phaseResults must be an array" });
+    }
+    requireString(record, "startedAt", issues);
+    requireString(record, "finishedAt", issues);
+    return { ok: issues.length === 0, value: normalized, issues };
+}
+export function validateDispatchEnvelope(value) {
+    const normalized = normalizeDispatchEnvelope(value);
+    const record = normalized;
+    const issues = [];
+    requireString(record, "action", issues);
+    requireRecord(record, "reason", issues);
+    if (isRecord(record.reason)) {
+        requireString(record.reason, "reasonCode", issues);
+        requireString(record.reason, "summary", issues);
+    }
+    return { ok: issues.length === 0, value: normalized, issues };
+}
+export function validateAuditEvent(value) {
+    const normalized = normalizeAuditEvent(value);
+    const record = normalized;
+    const issues = [];
+    requireString(record, "eventId", issues);
+    requireString(record, "traceId", issues);
+    requireString(record, "category", issues);
+    requireString(record, "type", issues);
+    requireString(record, "ts", issues);
+    requireRecord(record, "payload", issues);
+    return { ok: issues.length === 0, value: normalized, issues };
+}

package/dist/resources/extensions/gsd/uok/dispatch-envelope.js

@@ -1,5 +1,8 @@
+// GSD2 UOK Dispatch Envelope Builder
+import { CURRENT_UOK_CONTRACT_VERSION } from "./contracts.js";
 export function buildDispatchEnvelope(input) {
     return {
+        version: CURRENT_UOK_CONTRACT_VERSION,
         action: input.action,
         nodeKind: input.node?.kind,
         unitType: input.unitType,

package/dist/resources/extensions/gsd/uok/loop-adapter.js

@@ -1,3 +1,5 @@
+// GSD2 UOK Turn Observer and DB-Backed Lifecycle Emission
+import { CURRENT_UOK_CONTRACT_VERSION, validateTurnResult } from "./contracts.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./audit.js";
 import { writeTurnCloseoutGitRecord, writeTurnGitTransaction } from "./gitops.js";
 import { acquireWriterToken, nextWriteRecord, releaseWriterToken } from "./writer.js";
@@ -115,46 +117,59 @@ export function createTurnObserver(options) {
             }
         },
         onTurnResult(result) {
-            const merged = {
-                ...result,
-                phaseResults: result.phaseResults.length > 0 ? result.phaseResults : [...phaseResults],
+            const cleanup = () => {
+                if (writerToken) {
+                    releaseWriterToken(options.basePath, writerToken);
+                }
+                writerToken = null;
+                current = null;
+                phaseResults.length = 0;
             };
-            if (options.enableAudit) {
-                emitUokAuditEvent(options.basePath, buildAuditEnvelope({
-                    traceId: merged.traceId,
-                    turnId: merged.turnId,
-                    category: "orchestration",
-                    type: "turn-result",
-                    payload: nextSequenceMetadata("audit", "append", {
+            try {
+                const merged = {
+                    ...result,
+                    version: CURRENT_UOK_CONTRACT_VERSION,
+                    phaseResults: Array.isArray(result.phaseResults) && result.phaseResults.length > 0 ? result.phaseResults : [...phaseResults],
+                };
+                const validation = validateTurnResult(merged);
+                if (!validation.ok) {
+                    throw new Error(`Invalid UOK turn result: ${validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`);
+                }
+                if (options.enableAudit) {
+                    emitUokAuditEvent(options.basePath, buildAuditEnvelope({
+                        traceId: validation.value.traceId,
+                        turnId: validation.value.turnId,
+                        category: "orchestration",
+                        type: "turn-result",
+                        payload: nextSequenceMetadata("audit", "append", {
+                            contractVersion: validation.value.version,
+                            unitType: validation.value.unitType,
+                            unitId: validation.value.unitId,
+                            status: validation.value.status,
+                            failureClass: validation.value.failureClass,
+                            error: validation.value.error,
+                            phaseCount: validation.value.phaseResults.length,
+                        }),
+                    }));
+                }
+                if (options.enableGitops) {
+                    const closeout = merged.closeout ?? {
+                        traceId: merged.traceId,
+                        turnId: merged.turnId,
                         unitType: merged.unitType,
                         unitId: merged.unitId,
                         status: merged.status,
                         failureClass: merged.failureClass,
-                        error: merged.error,
-                        phaseCount: merged.phaseResults.length,
-                    }),
-                }));
+                        gitAction: options.gitAction,
+                        gitPushed: options.gitPush,
+                        finishedAt: merged.finishedAt,
+                    };
+                    writeTurnCloseoutGitRecord(options.basePath, closeout, nextSequenceMetadata("gitops", "update", { action: "record" }));
+                }
             }
-            if (options.enableGitops) {
-                const closeout = merged.closeout ?? {
-                    traceId: merged.traceId,
-                    turnId: merged.turnId,
-                    unitType: merged.unitType,
-                    unitId: merged.unitId,
-                    status: merged.status,
-                    failureClass: merged.failureClass,
-                    gitAction: options.gitAction,
-                    gitPushed: options.gitPush,
-                    finishedAt: merged.finishedAt,
-                };
-                writeTurnCloseoutGitRecord(options.basePath, closeout, nextSequenceMetadata("gitops", "update", { action: "record" }));
+            finally {
+                cleanup();
             }
-            if (writerToken) {
-                releaseWriterToken(options.basePath, writerToken);
-            }
-            writerToken = null;
-            current = null;
-            phaseResults.length = 0;
         },
     };
 }

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

@@ -0,0 +1,125 @@
+// GSD2 UOK Timeline Reconstruction from Authoritative DB Records
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { _getAdapter, isDbAvailable } from "../gsd-db.js";
+import { gsdRoot } from "../paths.js";
+function parseJsonRecord(value) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== "string" || value.trim() === "")
+        return {};
+    try {
+        const parsed = JSON.parse(value);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function matchesFilter(entry, filter) {
+    if (filter.traceId && entry.traceId !== filter.traceId)
+        return false;
+    if (filter.turnId && entry.turnId !== filter.turnId)
+        return false;
+    return true;
+}
+function byTimestamp(a, b) {
+    return a.ts.localeCompare(b.ts);
+}
+function readDbTimeline(filter) {
+    const db = _getAdapter();
+    if (!db)
+        return [];
+    const entries = [];
+    const where = [];
+    const params = {};
+    if (filter.traceId) {
+        where.push("trace_id = :trace_id");
+        params[":trace_id"] = filter.traceId;
+    }
+    if (filter.turnId) {
+        where.push("turn_id = :turn_id");
+        params[":turn_id"] = filter.turnId;
+    }
+    const suffix = where.length > 0 ? ` WHERE ${where.join(" AND ")}` : "";
+    const auditRows = db.prepare(`SELECT trace_id, turn_id, type, ts, payload_json FROM audit_events${suffix}`).all(params);
+    for (const row of auditRows) {
+        entries.push({
+            source: "audit_events",
+            ts: row.ts,
+            traceId: row.trace_id,
+            turnId: row.turn_id,
+            type: row.type,
+            payload: parseJsonRecord(row.payload_json),
+        });
+    }
+    const dispatchRows = db.prepare(`SELECT trace_id, turn_id, unit_type, unit_id, status, started_at, ended_at, exit_reason,
+            error_summary, retry_after_ms, attempt_n, max_attempts
+     FROM unit_dispatches${suffix}`).all(params);
+    for (const row of dispatchRows) {
+        entries.push({
+            source: "unit_dispatches",
+            ts: String(row.ended_at ?? row.started_at ?? ""),
+            traceId: String(row.trace_id ?? ""),
+            turnId: typeof row.turn_id === "string" ? row.turn_id : null,
+            type: `dispatch-${String(row.status ?? "unknown")}`,
+            payload: { ...row },
+        });
+    }
+    const gitRows = db.prepare(`SELECT trace_id, turn_id, unit_type, unit_id, stage, action, push, status, error,
+            metadata_json, updated_at
+     FROM turn_git_transactions${suffix}`).all(params);
+    for (const row of gitRows) {
+        entries.push({
+            source: "turn_git_transactions",
+            ts: String(row.updated_at ?? ""),
+            traceId: String(row.trace_id ?? ""),
+            turnId: typeof row.turn_id === "string" ? row.turn_id : null,
+            type: `gitops-${String(row.stage ?? "unknown")}`,
+            payload: {
+                ...row,
+                metadata: parseJsonRecord(row.metadata_json),
+            },
+        });
+    }
+    return entries.filter((entry) => entry.ts !== "").sort(byTimestamp);
+}
+function readJsonlTimeline(basePath, filter) {
+    const path = join(gsdRoot(basePath), "audit", "events.jsonl");
+    if (!existsSync(path))
+        return [];
+    return readFileSync(path, "utf-8")
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+        const event = parseJsonRecord(line);
+        const entry = {
+            source: "audit_jsonl",
+            ts: String(event.ts ?? ""),
+            traceId: typeof event.traceId === "string" ? event.traceId : undefined,
+            turnId: typeof event.turnId === "string" ? event.turnId : null,
+            type: String(event.type ?? "audit"),
+            payload: parseJsonRecord(event.payload),
+        };
+        return entry.ts && matchesFilter(entry, filter) ? entry : null;
+    })
+        .filter((entry) => entry !== null)
+        .sort(byTimestamp);
+}
+export function buildTurnTimeline(basePath, filter = {}) {
+    if (isDbAvailable()) {
+        return {
+            authoritative: "db",
+            degraded: false,
+            entries: readDbTimeline(filter),
+        };
+    }
+    return {
+        authoritative: "degraded-fallback",
+        degraded: true,
+        entries: readJsonlTimeline(basePath, filter),
+    };
+}

package/dist/resources/extensions/shared/gsd-phase-state.js

@@ -1,29 +1,71 @@
 /**
- * GSD Phase State — cross-extension coordination
+ * GSD2 Phase State — cross-extension coordination
  * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
  *
  * Lightweight module-level state that GSD auto-mode writes to and the
  * subagent tool reads from. Both extensions run in the same process so
  * a module variable is sufficient — no file I/O needed.
  */
+import { buildAuditEnvelope, emitUokAuditEvent } from "../gsd/uok/audit.js";
 let _active = false;
 let _currentPhase = null;
+let _auditContext = null;
+function emitPhaseChange(action, previousPhase, nextPhase) {
+    if (!_auditContext)
+        return;
+    emitUokAuditEvent(_auditContext.basePath, buildAuditEnvelope({
+        traceId: _auditContext.traceId,
+        turnId: _auditContext.turnId,
+        causedBy: _auditContext.causedBy,
+        category: "orchestration",
+        type: "phase_changed",
+        payload: {
+            action,
+            active: _active,
+            previousPhase,
+            nextPhase,
+        },
+    }));
+}
+export function configureGSDPhaseAudit(context) {
+    _auditContext = context;
+}
 /** Mark GSD auto-mode as active. */
-export function activateGSD() {
+export function activateGSD(context) {
+    if (context)
+        _auditContext = context;
+    const previousPhase = _currentPhase;
     _active = true;
+    emitPhaseChange("activate", previousPhase, _currentPhase);
 }
 /** Mark GSD auto-mode as inactive and clear the current phase. */
 export function deactivateGSD() {
+    const previousPhase = _currentPhase;
     _active = false;
     _currentPhase = null;
+    emitPhaseChange("deactivate", previousPhase, _currentPhase);
+    _auditContext = null;
 }
 /** Set the currently dispatched GSD phase (e.g. "plan-milestone"). */
-export function setCurrentPhase(phase) {
+export function setCurrentPhase(phase, context) {
+    if (context)
+        _auditContext = context;
+    if (!_active) {
+        process.emitWarning(`Ignoring GSD phase "${phase}" while GSD auto-mode is inactive`, {
+            code: "GSD_PHASE_INACTIVE",
+        });
+        return false;
+    }
+    const previousPhase = _currentPhase;
     _currentPhase = phase;
+    emitPhaseChange("set", previousPhase, _currentPhase);
+    return true;
 }
 /** Clear the current phase (unit completed or aborted). */
 export function clearCurrentPhase() {
+    const previousPhase = _currentPhase;
     _currentPhase = null;
+    emitPhaseChange("clear", previousPhase, _currentPhase);
 }
 /** Returns true if GSD auto-mode is currently active. */
 export function isGSDActive() {