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

package/src/resources/extensions/gsd/graph-context.ts

@@ -7,13 +7,144 @@
  */
 
 import { logWarning } from "./workflow-logger.js";
-import type { GraphQueryResult, GraphStatusResult } from "@gsd-build/mcp-server";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+interface GraphNode {
+  id: string;
+  label: string;
+  type: string;
+  confidence: string;
+  description?: string;
+}
+
+interface GraphEdge {
+  from: string;
+  to: string;
+  type: string;
+}
+
+interface GraphQueryResult {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+}
+
+interface GraphStatusResult {
+  exists: boolean;
+  stale: boolean;
+  ageHours?: number;
+}
+
+interface GraphApi {
+  graphQuery: (projectDir: string, term: string, budget?: number) => Promise<GraphQueryResult>;
+  graphStatus: (projectDir: string) => Promise<GraphStatusResult>;
+}
+
+interface GraphFileShape {
+  nodes: GraphNode[];
+  edges: GraphEdge[];
+  builtAt?: string;
+}
+
+let cachedGraphApi: GraphApi | null = null;
+let resolvedGraphApi = false;
 
 export interface GraphSubgraphOptions {
   /** Budget in tokens passed to graphQuery (1 node ≈ 20 tokens, 1 edge ≈ 10 tokens) */
   budget: number;
 }
 
+function readGraphFile(projectDir: string): GraphFileShape | null {
+  try {
+    const graphPath = join(projectDir, ".gsd", "graphs", "graph.json");
+    const raw = readFileSync(graphPath, "utf-8");
+    const parsed = JSON.parse(raw) as Partial<GraphFileShape>;
+    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: string, term: string, budget = 3000): Promise<GraphQueryResult> {
+  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] as const));
+
+  // 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: string): Promise<GraphStatusResult> {
+  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: unknown): mod is GraphApi {
+  if (!mod || typeof mod !== "object") return false;
+  const candidate = mod as Record<string, unknown>;
+  return typeof candidate.graphQuery === "function" && typeof candidate.graphStatus === "function";
+}
+
+async function resolveGraphApi(): Promise<GraphApi> {
+  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.
@@ -33,18 +164,14 @@ export async function inlineGraphSubgraph(
   if (!term || !term.trim()) return null;
 
   try {
-    const { graphQuery, graphStatus } = await import("@gsd-build/mcp-server") as {
-      graphQuery: (projectDir: string, term: string, budget?: number) => Promise<GraphQueryResult>;
-      graphStatus: (projectDir: string) => Promise<GraphStatusResult>;
-    };
-
-    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`;
@@ -54,14 +181,14 @@ export async function inlineGraphSubgraph(
     }
 
     // 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: string[] = [

package/src/resources/extensions/gsd/gsd-db.ts

@@ -54,8 +54,8 @@ let loadAttempted = false;
 
 function suppressSqliteWarning(): void {
   const origEmit = process.emit;
-  // @ts-expect-error overriding process.emit for warning filter
-  process.emit = function (event: string, ...args: unknown[]): boolean {
+  // Override via loose cast: Node's overloaded emit signature is not directly assignable.
+  (process as any).emit = function (event: string, ...args: unknown[]): boolean {
     if (
       event === "warning" &&
       args[0] &&
@@ -180,7 +180,7 @@ function openRawDb(path: string): unknown {
   return new Database(path);
 }
 
-const SCHEMA_VERSION = 14;
+const SCHEMA_VERSION = 15;
 
 function indexExists(db: DbAdapter, name: string): boolean {
   return !!db.prepare(
@@ -443,6 +443,70 @@ function initSchema(db: DbAdapter, fileBacked: boolean): void {
       )
     `);
 
+    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)");
 
@@ -456,6 +520,11 @@ function initSchema(db: DbAdapter, fileBacked: boolean): void {
 
     // 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`);
@@ -810,6 +879,78 @@ function migrateSchema(db: DbAdapter): void {
       });
     }
 
+    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) {
     db.exec("ROLLBACK");
@@ -2287,6 +2428,9 @@ export function deleteMilestone(milestoneId: string): void {
     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 });
@@ -2420,6 +2564,30 @@ 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: string, sliceId: string, scope?: GateScope): GateRow[] {
@@ -2513,6 +2681,156 @@ export function getPendingGateCountForTurn(
   return getPendingGatesForTurn(milestoneId, sliceId, turn).length;
 }
 
+export function insertGateRun(entry: {
+  traceId: string;
+  turnId: string;
+  gateId: string;
+  gateType: string;
+  unitType?: string;
+  unitId?: string;
+  milestoneId?: string;
+  sliceId?: string;
+  taskId?: string;
+  outcome: "pass" | "fail" | "retry" | "manual-attention";
+  failureClass: "none" | "policy" | "input" | "execution" | "artifact" | "verification" | "closeout" | "git" | "timeout" | "manual-attention" | "unknown";
+  rationale?: string;
+  findings?: string;
+  attempt: number;
+  maxAttempts: number;
+  retryable: boolean;
+  evaluatedAt: string;
+}): void {
+  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: {
+  traceId: string;
+  turnId: string;
+  unitType?: string;
+  unitId?: string;
+  stage: string;
+  action: "commit" | "snapshot" | "status-only";
+  push: boolean;
+  status: "ok" | "failed";
+  error?: string;
+  metadata?: Record<string, unknown>;
+  updatedAt: string;
+}): void {
+  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: {
+  eventId: string;
+  traceId: string;
+  turnId?: string;
+  causedBy?: string;
+  category: string;
+  type: string;
+  ts: string;
+  payload: Record<string, unknown>;
+}): void {
+  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/src/resources/extensions/gsd/guided-flow.ts

@@ -7,6 +7,7 @@
  */
 
 import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import type { GSDState } from "./types.js";
 import { showNextAction } from "../shared/tui.js";
 import { loadFile, saveFile } from "./files.js";
 import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
@@ -36,6 +37,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";
@@ -83,6 +86,33 @@ function nextMilestoneIdReserved(existingIds: string[], uniqueEnabled: boolean):
   return id;
 }
 
+function needsPlanV2Gate(state: GSDState): boolean {
+  return state.phase === "executing"
+    || state.phase === "summarizing"
+    || state.phase === "validating-milestone"
+    || state.phase === "completing-milestone";
+}
+
+function runPlanV2Gate(
+  ctx: ExtensionContext,
+  basePath: string,
+  state: GSDState,
+): boolean {
+  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. */
@@ -239,10 +269,12 @@ export function checkAutoStartAfterDiscuss(): boolean {
   } catch (e) { logWarning("guided", `CONTEXT-DRAFT.md unlink failed: ${(e as Error).message}`); }
 
   // Cleanup: remove discussion manifest after auto-start (only needed during discussion)
-  try { unlinkSync(manifestPath); } catch (e) { logWarning("guided", `manifest unlink failed: ${(e as Error).message}`); }
+  if (existsSync(manifestPath)) {
+    try { unlinkSync(manifestPath); } catch (e) { logWarning("guided", `manifest unlink failed: ${(e as Error).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;
 }
@@ -1320,6 +1352,8 @@ export async function showSmartEntry(
     logWarning("guided", `STATE.md rebuild failed: ${(err as Error).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/src/resources/extensions/gsd/init-wizard.ts

@@ -33,7 +33,7 @@ interface ProjectPreferences {
   mainBranch: string;
   verificationCommands: string[];
   customInstructions: string[];
-  tokenProfile: "budget" | "balanced" | "quality";
+  tokenProfile: "budget" | "balanced" | "quality" | "burn-max";
   skipResearch: boolean;
   autoPush: boolean;
 }
@@ -413,10 +413,11 @@ async function customizeAdvancedPrefs(
       { 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") {
-    prefs.tokenProfile = profileChoice as "budget" | "balanced" | "quality";
+    prefs.tokenProfile = profileChoice as "budget" | "balanced" | "quality" | "burn-max";
   }
 
   // Skip research