gsd-pi 2.74.0-dev.b741afb → 2.74.0-dev.b7c5f96

package/dist/resources/extensions/gsd/git-service.js

@@ -15,7 +15,7 @@ import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { detectWorktreeName, } from "./worktree.js";
 import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
-import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeResetSoft, nativeCommitSubject, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeResetSoft, nativeCommitSubject, _resetHasChangesCache, } from "./native-git-bridge.js";
 import { GSDError, GSD_MERGE_CONFLICT, GSD_GIT_ERROR } from "./errors.js";
 import { getErrorMessage } from "./error-utils.js";
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
@@ -641,6 +641,54 @@ export function createGitService(basePath) {
     const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
     return new GitServiceImpl(basePath, gitPrefs);
 }
+function buildTurnSnapshotLabel(unitType, unitId) {
+    const raw = `${unitType}/${unitId}`.trim();
+    if (!raw)
+        return "turn";
+    return raw
+        .replace(/[^a-zA-Z0-9._/-]/g, "-")
+        .replace(/\/{2,}/g, "/")
+        .replace(/-{2,}/g, "-")
+        .replace(/^[-/]+|[-/]+$/g, "") || "turn";
+}
+export function runTurnGitAction(args) {
+    try {
+        // Force fresh working-tree status per turn; nativeHasChanges caches briefly.
+        _resetHasChangesCache();
+        if (args.action === "status-only") {
+            return {
+                action: args.action,
+                status: "ok",
+                dirty: nativeHasChanges(args.basePath),
+            };
+        }
+        const git = createGitService(args.basePath);
+        if (args.action === "snapshot") {
+            const label = buildTurnSnapshotLabel(args.unitType, args.unitId);
+            git.createSnapshot(label);
+            return {
+                action: args.action,
+                status: "ok",
+                snapshotLabel: label,
+                dirty: nativeHasChanges(args.basePath),
+            };
+        }
+        const commitMessage = git.autoCommit(args.unitType, args.unitId, [], args.taskContext) ?? undefined;
+        return {
+            action: args.action,
+            status: "ok",
+            commitMessage,
+            dirty: nativeHasChanges(args.basePath),
+        };
+    }
+    catch (err) {
+        return {
+            action: args.action,
+            status: "failed",
+            error: getErrorMessage(err),
+        };
+    }
+}
 // ─── Commit Type Inference ─────────────────────────────────────────────────
 /**
  * Infer a conventional commit type from a title (and optional one-liner).

package/dist/resources/extensions/gsd/graph-context.js

@@ -6,6 +6,97 @@
  * or the query yields no results — callers must handle null.
  */
 import { logWarning } from "./workflow-logger.js";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+let cachedGraphApi = null;
+let resolvedGraphApi = false;
+function readGraphFile(projectDir) {
+    try {
+        const graphPath = join(projectDir, ".gsd", "graphs", "graph.json");
+        const raw = readFileSync(graphPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+        const edges = Array.isArray(parsed.edges) ? parsed.edges : [];
+        return { nodes, edges, builtAt: typeof parsed.builtAt === "string" ? parsed.builtAt : undefined };
+    }
+    catch {
+        return null;
+    }
+}
+async function fallbackGraphQuery(projectDir, term, budget = 3000) {
+    const graph = readGraphFile(projectDir);
+    if (!graph)
+        return { nodes: [], edges: [] };
+    const needle = term.trim().toLowerCase();
+    const matches = graph.nodes.filter((node) => {
+        const hay = [node.id, node.label, node.description].filter(Boolean).join(" ").toLowerCase();
+        return hay.includes(needle);
+    });
+    const maxNodes = Math.max(1, Math.floor(Math.max(1, budget) / 20));
+    const selectedIds = new Set(matches.slice(0, maxNodes).map((node) => node.id));
+    const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+    // Pull one-hop neighbors so relation context survives even when the term
+    // matches only one side of an edge.
+    for (const edge of graph.edges) {
+        if (selectedIds.size >= maxNodes)
+            break;
+        const touchesSelection = selectedIds.has(edge.from) || selectedIds.has(edge.to);
+        if (!touchesSelection)
+            continue;
+        if (selectedIds.has(edge.from) && !selectedIds.has(edge.to) && nodeById.has(edge.to)) {
+            selectedIds.add(edge.to);
+        }
+        else if (selectedIds.has(edge.to) && !selectedIds.has(edge.from) && nodeById.has(edge.from)) {
+            selectedIds.add(edge.from);
+        }
+    }
+    const nodes = graph.nodes.filter((node) => selectedIds.has(node.id));
+    const remainingBudget = Math.max(0, budget - nodes.length * 20);
+    const maxEdges = Math.floor(remainingBudget / 10);
+    const edges = graph.edges
+        .filter((edge) => selectedIds.has(edge.from) && selectedIds.has(edge.to))
+        .slice(0, maxEdges);
+    return { nodes, edges };
+}
+async function fallbackGraphStatus(projectDir) {
+    const graph = readGraphFile(projectDir);
+    if (!graph)
+        return { exists: false, stale: false };
+    if (!graph.builtAt)
+        return { exists: true, stale: false };
+    const builtAtMs = Date.parse(graph.builtAt);
+    if (!Number.isFinite(builtAtMs))
+        return { exists: true, stale: false };
+    const ageHours = (Date.now() - builtAtMs) / (1000 * 60 * 60);
+    return { exists: true, stale: ageHours > 24, ageHours };
+}
+function isGraphApi(mod) {
+    if (!mod || typeof mod !== "object")
+        return false;
+    const candidate = mod;
+    return typeof candidate.graphQuery === "function" && typeof candidate.graphStatus === "function";
+}
+async function resolveGraphApi() {
+    if (resolvedGraphApi && cachedGraphApi)
+        return cachedGraphApi;
+    resolvedGraphApi = true;
+    try {
+        const imported = await import("@gsd-build/mcp-server");
+        if (isGraphApi(imported)) {
+            cachedGraphApi = imported;
+            return cachedGraphApi;
+        }
+        logWarning("prompt", "@gsd-build/mcp-server graph exports unavailable; using local graph fallback");
+    }
+    catch {
+        // Fall back to local reader implementation.
+    }
+    cachedGraphApi = {
+        graphQuery: fallbackGraphQuery,
+        graphStatus: fallbackGraphStatus,
+    };
+    return cachedGraphApi;
+}
 /**
  * Query the knowledge graph for nodes related to the given term and format
  * the result as an inlined context block.
@@ -21,14 +112,14 @@ export async function inlineGraphSubgraph(projectDir, term, opts) {
     if (!term || !term.trim())
         return null;
     try {
-        const { graphQuery, graphStatus } = await import("@gsd-build/mcp-server");
-        const result = await graphQuery(projectDir, term, opts.budget);
+        const graphApi = await resolveGraphApi();
+        const result = await graphApi.graphQuery(projectDir, term, opts.budget);
         if (result.nodes.length === 0)
             return null;
         // Check staleness for annotation
         let staleAnnotation = "";
         try {
-            const status = await graphStatus(projectDir);
+            const status = await graphApi.graphStatus(projectDir);
             if (status.exists && status.stale && status.ageHours !== undefined) {
                 const hours = Math.round(status.ageHours);
                 staleAnnotation = `\n> ⚠ Graph last built ${hours}h ago — context may be outdated`;
@@ -38,13 +129,13 @@ export async function inlineGraphSubgraph(projectDir, term, opts) {
             // Non-fatal — skip annotation on error
         }
         // Format nodes as a compact list
-        const nodeLines = result.nodes.map((n) => {
-            const desc = n.description ? ` — ${n.description}` : "";
-            return `- **${n.label}** (\`${n.type}\`, ${n.confidence})${desc}`;
+        const nodeLines = result.nodes.map((node) => {
+            const desc = node.description ? ` — ${node.description}` : "";
+            return `- **${node.label}** (\`${node.type}\`, ${node.confidence})${desc}`;
         });
         // Format edges as relations (only if present)
         const edgeLines = result.edges.length > 0
-            ? result.edges.map((e) => `- \`${e.from}\` →[${e.type}]→ \`${e.to}\``)
+            ? result.edges.map((edge) => `- \`${edge.from}\` →[${edge.type}]→ \`${edge.to}\``)
             : [];
         const sections = [
             `### Knowledge Graph Context (term: "${term}")`,

package/dist/resources/extensions/gsd/gsd-db.js

@@ -31,7 +31,7 @@ let providerModule = null;
 let loadAttempted = false;
 function suppressSqliteWarning() {
     const origEmit = process.emit;
-    // @ts-expect-error overriding process.emit for warning filter
+    // Override via loose cast: Node's overloaded emit signature is not directly assignable.
     process.emit = function (event, ...args) {
         if (event === "warning" &&
             args[0] &&
@@ -135,7 +135,7 @@ function openRawDb(path) {
     const Database = providerModule;
     return new Database(path);
 }
-const SCHEMA_VERSION = 14;
+const SCHEMA_VERSION = 15;
 function indexExists(db, name) {
     return !!db.prepare("SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = ?").get(name);
 }
@@ -383,6 +383,66 @@ function initSchema(db, fileBacked) {
         FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id),
         FOREIGN KEY (milestone_id, depends_on_slice_id) REFERENCES slices(milestone_id, id)
       )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS gate_runs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        trace_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        gate_id TEXT NOT NULL,
+        gate_type TEXT NOT NULL DEFAULT '',
+        unit_type TEXT DEFAULT NULL,
+        unit_id TEXT DEFAULT NULL,
+        milestone_id TEXT DEFAULT NULL,
+        slice_id TEXT DEFAULT NULL,
+        task_id TEXT DEFAULT NULL,
+        outcome TEXT NOT NULL DEFAULT 'pass',
+        failure_class TEXT NOT NULL DEFAULT 'none',
+        rationale TEXT NOT NULL DEFAULT '',
+        findings TEXT NOT NULL DEFAULT '',
+        attempt INTEGER NOT NULL DEFAULT 1,
+        max_attempts INTEGER NOT NULL DEFAULT 1,
+        retryable INTEGER NOT NULL DEFAULT 0,
+        evaluated_at TEXT NOT NULL DEFAULT ''
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS turn_git_transactions (
+        trace_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        unit_type TEXT DEFAULT NULL,
+        unit_id TEXT DEFAULT NULL,
+        stage TEXT NOT NULL DEFAULT 'turn-start',
+        action TEXT NOT NULL DEFAULT 'status-only',
+        push INTEGER NOT NULL DEFAULT 0,
+        status TEXT NOT NULL DEFAULT 'ok',
+        error TEXT DEFAULT NULL,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        updated_at TEXT NOT NULL DEFAULT '',
+        PRIMARY KEY (trace_id, turn_id, stage)
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS audit_events (
+        event_id TEXT PRIMARY KEY,
+        trace_id TEXT NOT NULL,
+        turn_id TEXT DEFAULT NULL,
+        caused_by TEXT DEFAULT NULL,
+        category TEXT NOT NULL,
+        type TEXT NOT NULL,
+        ts TEXT NOT NULL,
+        payload_json TEXT NOT NULL DEFAULT '{}'
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS audit_turn_index (
+        trace_id TEXT NOT NULL,
+        turn_id TEXT NOT NULL,
+        first_ts TEXT NOT NULL,
+        last_ts TEXT NOT NULL,
+        event_count INTEGER NOT NULL DEFAULT 0,
+        PRIMARY KEY (trace_id, turn_id)
+      )
     `);
         db.exec("CREATE INDEX IF NOT EXISTS idx_memories_active ON memories(superseded_by)");
         db.exec("CREATE INDEX IF NOT EXISTS idx_replan_history_milestone ON replan_history(milestone_id, created_at)");
@@ -395,6 +455,11 @@ function initSchema(db, fileBacked) {
         ensureVerificationEvidenceDedupIndex(db);
         // v14 index — slice dependency lookups
         db.exec("CREATE INDEX IF NOT EXISTS idx_slice_deps_target ON slice_dependencies(milestone_id, depends_on_slice_id)");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_gate_runs_turn ON gate_runs(trace_id, turn_id)");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_gate_runs_lookup ON gate_runs(milestone_id, slice_id, task_id, gate_id)");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_turn_git_tx_turn ON turn_git_transactions(trace_id, turn_id)");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_audit_events_trace ON audit_events(trace_id, ts)");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_audit_events_turn ON audit_events(trace_id, turn_id, ts)");
         db.exec(`CREATE VIEW IF NOT EXISTS active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL`);
         db.exec(`CREATE VIEW IF NOT EXISTS active_requirements AS SELECT * FROM requirements WHERE superseded_by IS NULL`);
         db.exec(`CREATE VIEW IF NOT EXISTS active_memories AS SELECT * FROM memories WHERE superseded_by IS NULL`);
@@ -725,6 +790,77 @@ function migrateSchema(db) {
                 ":applied_at": new Date().toISOString(),
             });
         }
+        if (currentVersion < 15) {
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS gate_runs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          trace_id TEXT NOT NULL,
+          turn_id TEXT NOT NULL,
+          gate_id TEXT NOT NULL,
+          gate_type TEXT NOT NULL DEFAULT '',
+          unit_type TEXT DEFAULT NULL,
+          unit_id TEXT DEFAULT NULL,
+          milestone_id TEXT DEFAULT NULL,
+          slice_id TEXT DEFAULT NULL,
+          task_id TEXT DEFAULT NULL,
+          outcome TEXT NOT NULL DEFAULT 'pass',
+          failure_class TEXT NOT NULL DEFAULT 'none',
+          rationale TEXT NOT NULL DEFAULT '',
+          findings TEXT NOT NULL DEFAULT '',
+          attempt INTEGER NOT NULL DEFAULT 1,
+          max_attempts INTEGER NOT NULL DEFAULT 1,
+          retryable INTEGER NOT NULL DEFAULT 0,
+          evaluated_at TEXT NOT NULL DEFAULT ''
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS turn_git_transactions (
+          trace_id TEXT NOT NULL,
+          turn_id TEXT NOT NULL,
+          unit_type TEXT DEFAULT NULL,
+          unit_id TEXT DEFAULT NULL,
+          stage TEXT NOT NULL DEFAULT 'turn-start',
+          action TEXT NOT NULL DEFAULT 'status-only',
+          push INTEGER NOT NULL DEFAULT 0,
+          status TEXT NOT NULL DEFAULT 'ok',
+          error TEXT DEFAULT NULL,
+          metadata_json TEXT NOT NULL DEFAULT '{}',
+          updated_at TEXT NOT NULL DEFAULT '',
+          PRIMARY KEY (trace_id, turn_id, stage)
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS audit_events (
+          event_id TEXT PRIMARY KEY,
+          trace_id TEXT NOT NULL,
+          turn_id TEXT DEFAULT NULL,
+          caused_by TEXT DEFAULT NULL,
+          category TEXT NOT NULL,
+          type TEXT NOT NULL,
+          ts TEXT NOT NULL,
+          payload_json TEXT NOT NULL DEFAULT '{}'
+        )
+      `);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS audit_turn_index (
+          trace_id TEXT NOT NULL,
+          turn_id TEXT NOT NULL,
+          first_ts TEXT NOT NULL,
+          last_ts TEXT NOT NULL,
+          event_count INTEGER NOT NULL DEFAULT 0,
+          PRIMARY KEY (trace_id, turn_id)
+        )
+      `);
+            db.exec("CREATE INDEX IF NOT EXISTS idx_gate_runs_turn ON gate_runs(trace_id, turn_id)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_gate_runs_lookup ON gate_runs(milestone_id, slice_id, task_id, gate_id)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_turn_git_tx_turn ON turn_git_transactions(trace_id, turn_id)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_audit_events_trace ON audit_events(trace_id, ts)");
+            db.exec("CREATE INDEX IF NOT EXISTS idx_audit_events_turn ON audit_events(trace_id, turn_id, ts)");
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 15,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -1939,6 +2075,7 @@ export function deleteMilestone(milestoneId) {
     transaction(() => {
         currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
         currentDb.prepare(`DELETE FROM quality_gates WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
+        currentDb.prepare(`DELETE FROM gate_runs WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
         currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
         currentDb.prepare(`DELETE FROM slice_dependencies WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
         currentDb.prepare(`DELETE FROM slices WHERE milestone_id = :mid`).run({ ":mid": milestoneId });
@@ -2024,6 +2161,28 @@ export function saveGateResult(g) {
         ":findings": g.findings,
         ":evaluated_at": new Date().toISOString(),
     });
+    const outcome = g.verdict === "pass"
+        ? "pass"
+        : g.verdict === "omitted"
+            ? "manual-attention"
+            : "fail";
+    insertGateRun({
+        traceId: `quality-gate:${g.milestoneId}:${g.sliceId}`,
+        turnId: `gate:${g.gateId}:${g.taskId ?? "slice"}`,
+        gateId: g.gateId,
+        gateType: "quality-gate",
+        milestoneId: g.milestoneId,
+        sliceId: g.sliceId,
+        taskId: g.taskId ?? undefined,
+        outcome,
+        failureClass: outcome === "fail" ? "verification" : outcome === "manual-attention" ? "manual-attention" : "none",
+        rationale: g.rationale,
+        findings: g.findings,
+        attempt: 1,
+        maxAttempts: 1,
+        retryable: false,
+        evaluatedAt: new Date().toISOString(),
+    });
 }
 export function getPendingGates(milestoneId, sliceId, scope) {
     if (!currentDb)
@@ -2104,6 +2263,105 @@ export function getPendingGatesForTurn(milestoneId, sliceId, turn, taskId) {
 export function getPendingGateCountForTurn(milestoneId, sliceId, turn) {
     return getPendingGatesForTurn(milestoneId, sliceId, turn).length;
 }
+export function insertGateRun(entry) {
+    if (!currentDb)
+        return;
+    currentDb.prepare(`INSERT INTO gate_runs (
+      trace_id, turn_id, gate_id, gate_type, unit_type, unit_id, milestone_id, slice_id, task_id,
+      outcome, failure_class, rationale, findings, attempt, max_attempts, retryable, evaluated_at
+    ) VALUES (
+      :trace_id, :turn_id, :gate_id, :gate_type, :unit_type, :unit_id, :milestone_id, :slice_id, :task_id,
+      :outcome, :failure_class, :rationale, :findings, :attempt, :max_attempts, :retryable, :evaluated_at
+    )`).run({
+        ":trace_id": entry.traceId,
+        ":turn_id": entry.turnId,
+        ":gate_id": entry.gateId,
+        ":gate_type": entry.gateType,
+        ":unit_type": entry.unitType ?? null,
+        ":unit_id": entry.unitId ?? null,
+        ":milestone_id": entry.milestoneId ?? null,
+        ":slice_id": entry.sliceId ?? null,
+        ":task_id": entry.taskId ?? null,
+        ":outcome": entry.outcome,
+        ":failure_class": entry.failureClass,
+        ":rationale": entry.rationale ?? "",
+        ":findings": entry.findings ?? "",
+        ":attempt": entry.attempt,
+        ":max_attempts": entry.maxAttempts,
+        ":retryable": entry.retryable ? 1 : 0,
+        ":evaluated_at": entry.evaluatedAt,
+    });
+}
+export function upsertTurnGitTransaction(entry) {
+    if (!currentDb)
+        return;
+    currentDb.prepare(`INSERT OR REPLACE INTO turn_git_transactions (
+      trace_id, turn_id, unit_type, unit_id, stage, action, push, status, error, metadata_json, updated_at
+    ) VALUES (
+      :trace_id, :turn_id, :unit_type, :unit_id, :stage, :action, :push, :status, :error, :metadata_json, :updated_at
+    )`).run({
+        ":trace_id": entry.traceId,
+        ":turn_id": entry.turnId,
+        ":unit_type": entry.unitType ?? null,
+        ":unit_id": entry.unitId ?? null,
+        ":stage": entry.stage,
+        ":action": entry.action,
+        ":push": entry.push ? 1 : 0,
+        ":status": entry.status,
+        ":error": entry.error ?? null,
+        ":metadata_json": JSON.stringify(entry.metadata ?? {}),
+        ":updated_at": entry.updatedAt,
+    });
+}
+export function insertAuditEvent(entry) {
+    if (!currentDb)
+        return;
+    transaction(() => {
+        currentDb.prepare(`INSERT OR IGNORE INTO audit_events (
+        event_id, trace_id, turn_id, caused_by, category, type, ts, payload_json
+      ) VALUES (
+        :event_id, :trace_id, :turn_id, :caused_by, :category, :type, :ts, :payload_json
+      )`).run({
+            ":event_id": entry.eventId,
+            ":trace_id": entry.traceId,
+            ":turn_id": entry.turnId ?? null,
+            ":caused_by": entry.causedBy ?? null,
+            ":category": entry.category,
+            ":type": entry.type,
+            ":ts": entry.ts,
+            ":payload_json": JSON.stringify(entry.payload ?? {}),
+        });
+        if (entry.turnId) {
+            const row = currentDb.prepare(`SELECT event_count, first_ts, last_ts
+         FROM audit_turn_index
+         WHERE trace_id = :trace_id AND turn_id = :turn_id`).get({
+                ":trace_id": entry.traceId,
+                ":turn_id": entry.turnId,
+            });
+            if (row) {
+                currentDb.prepare(`UPDATE audit_turn_index
+           SET first_ts = CASE WHEN :ts < first_ts THEN :ts ELSE first_ts END,
+               last_ts = CASE WHEN :ts > last_ts THEN :ts ELSE last_ts END,
+               event_count = event_count + 1
+           WHERE trace_id = :trace_id AND turn_id = :turn_id`).run({
+                    ":trace_id": entry.traceId,
+                    ":turn_id": entry.turnId,
+                    ":ts": entry.ts,
+                });
+            }
+            else {
+                currentDb.prepare(`INSERT INTO audit_turn_index (trace_id, turn_id, first_ts, last_ts, event_count)
+           VALUES (:trace_id, :turn_id, :first_ts, :last_ts, :event_count)`).run({
+                    ":trace_id": entry.traceId,
+                    ":turn_id": entry.turnId,
+                    ":first_ts": entry.ts,
+                    ":last_ts": entry.ts,
+                    ":event_count": 1,
+                });
+            }
+        }
+    });
+}
 // ─── Single-writer bypass wrappers ───────────────────────────────────────
 // These wrappers exist so modules outside this file never need to call
 // `_getAdapter()` for writes. Each one is a byte-equivalent replacement for

package/dist/resources/extensions/gsd/guided-flow.js

@@ -26,6 +26,8 @@ import { nativeIsRepo, nativeInit } from "./native-git-bridge.js";
 import { isInheritedRepo } from "./repo-identity.js";
 import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { resolveUokFlags } from "./uok/flags.js";
+import { ensurePlanV2Graph } from "./uok/plan-v2.js";
 import { detectProjectState } from "./detection.js";
 import { showProjectInit, offerMigration } from "./init-wizard.js";
 import { validateDirectory } from "./validate-directory.js";
@@ -53,6 +55,25 @@ function nextMilestoneIdReserved(existingIds, uniqueEnabled) {
     reserveMilestoneId(id);
     return id;
 }
+function needsPlanV2Gate(state) {
+    return state.phase === "executing"
+        || state.phase === "summarizing"
+        || state.phase === "validating-milestone"
+        || state.phase === "completing-milestone";
+}
+function runPlanV2Gate(ctx, basePath, state) {
+    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    const uokFlags = resolveUokFlags(prefs);
+    if (!uokFlags.planV2 || !needsPlanV2Gate(state))
+        return true;
+    const compiled = ensurePlanV2Graph(basePath, state);
+    if (!compiled.ok) {
+        const reason = compiled.reason ?? "plan-v2 compilation failed";
+        ctx.ui.notify(`Plan gate failed-closed: ${reason}. Complete plan/discuss artifacts before execution.`, "error");
+        return false;
+    }
+    return true;
+}
 // ─── Commit Instruction Helpers ──────────────────────────────────────────────
 /** Build commit instruction for planning prompts. .gsd/ is managed externally and always gitignored. */
 function buildDocsCommitInstruction(_message) {
@@ -191,14 +212,16 @@ export function checkAutoStartAfterDiscuss() {
         logWarning("guided", `CONTEXT-DRAFT.md unlink failed: ${e.message}`);
     }
     // Cleanup: remove discussion manifest after auto-start (only needed during discussion)
-    try {
-        unlinkSync(manifestPath);
-    }
-    catch (e) {
-        logWarning("guided", `manifest unlink failed: ${e.message}`);
+    if (existsSync(manifestPath)) {
+        try {
+            unlinkSync(manifestPath);
+        }
+        catch (e) {
+            logWarning("guided", `manifest unlink failed: ${e.message}`);
+        }
     }
     pendingAutoStartMap.delete(basePath);
-    ctx.ui.notify(`Milestone ${milestoneId} ready.`, "info");
+    ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
     startAutoDetached(ctx, pi, basePath, false, { step });
     return true;
 }
@@ -1110,6 +1133,8 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     catch (err) {
         logWarning("guided", `STATE.md rebuild failed: ${err.message}`);
     }
+    if (!runPlanV2Gate(ctx, basePath, state))
+        return;
     if (!state.activeMilestone?.id) {
         // Guard: if a discuss session is already in flight, don't re-inject the prompt.
         // Both /gsd and /gsd auto reach this branch when no milestone exists yet.

package/dist/resources/extensions/gsd/init-wizard.js

@@ -336,6 +336,7 @@ async function customizeAdvancedPrefs(ctx, prefs) {
             { id: "balanced", label: "Balanced", description: "Good trade-off (default)", recommended: true },
             { id: "budget", label: "Budget", description: "Minimize token usage" },
             { id: "quality", label: "Quality", description: "Maximize thoroughness" },
+            { id: "burn-max", label: "Burn Max", description: "Maximum depth, no phase skips" },
         ],
     });
     if (profileChoice !== "not_yet") {

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

@@ -14,6 +14,8 @@
 import { appendFileSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 // ─── Emit ─────────────────────────────────────────────────────────────────────
 /**
  * Append a journal event to the daily JSONL file.
@@ -34,6 +36,31 @@ export function emitJournalEvent(basePath, entry) {
     catch {
         // Silent failure — journal must never break auto-mode
     }
+    if (!isUnifiedAuditEnabled())
+        return;
+    try {
+        const causedBy = entry.causedBy
+            ? `${entry.causedBy.flowId}:${entry.causedBy.seq}`
+            : undefined;
+        const turnId = typeof entry.data?.turnId === "string"
+            ? entry.data.turnId
+            : undefined;
+        emitUokAuditEvent(basePath, buildAuditEnvelope({
+            traceId: entry.flowId,
+            turnId,
+            causedBy,
+            category: "orchestration",
+            type: `journal-${entry.eventType}`,
+            payload: {
+                seq: entry.seq,
+                rule: entry.rule,
+                data: entry.data ?? {},
+            },
+        }));
+    }
+    catch {
+        // Best-effort: audit projection must never block journal writes.
+    }
 }
 // ─── Query ────────────────────────────────────────────────────────────────────
 /**

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

@@ -17,6 +17,8 @@ import { gsdRoot } from "./paths.js";
 import { getAndClearSkills } from "./skill-telemetry.js";
 import { loadJsonFile, loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
 import { parseUnitId } from "./unit-id.js";
+import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
+import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 // Re-export from shared — import directly from format-utils to avoid pulling
 // in the full barrel (mod.js → ui.js → @gsd/pi-tui) which breaks when loaded
 // outside jiti's alias resolution (e.g. dynamic import in auto-loop reports).
@@ -152,6 +154,23 @@ export function snapshotUnitMetrics(ctx, unitType, unitId, startedAt, model, opt
         ledger.units.push(unit);
     }
     saveLedger(basePath, ledger);
+    if (isUnifiedAuditEnabled()) {
+        emitUokAuditEvent(basePath, buildAuditEnvelope({
+            traceId: opts?.traceId ?? `metrics:${unitType}:${unitId}`,
+            turnId: opts?.turnId,
+            causedBy: opts?.causedBy,
+            category: "metrics",
+            type: "unit-metrics-snapshot",
+            payload: {
+                unitType,
+                unitId,
+                model,
+                tokens: unit.tokens,
+                cost: unit.cost,
+                toolCalls: unit.toolCalls,
+            },
+        }));
+    }
     return unit;
 }
 /**