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

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) {
@@ -198,7 +219,7 @@ export function checkAutoStartAfterDiscuss() {
         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 +1131,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;
 }
 /**

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -20,8 +20,13 @@ import { writeSessionStatus, readAllSessionStatuses, readSessionStatus, removeSe
 import { analyzeParallelEligibility, } from "./parallel-eligibility.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning } from "./workflow-logger.js";
+import { resolveUokFlags } from "./uok/flags.js";
+import { selectConflictFreeBatch } from "./uok/execution-graph.js";
 // ─── Module State ──────────────────────────────────────────────────────────
 let state = null;
+function overlapKey(a, b) {
+    return a < b ? `${a}::${b}` : `${b}::${a}`;
+}
 // ─── Persistence ──────────────────────────────────────────────────────────
 const ORCHESTRATOR_STATE_FILE = "orchestrator.json";
 const TMP_SUFFIX = ".tmp";
@@ -277,6 +282,7 @@ export async function startParallel(basePath, milestoneIds, prefs) {
         return { started: [], errors: [{ mid: "all", error: "Cannot start parallel from within a parallel worker" }] };
     }
     const config = resolveParallelConfig(prefs);
+    const uokFlags = resolveUokFlags(prefs);
     // Release any leftover state from a previous session before reassigning
     if (state) {
         for (const w of state.workers.values()) {
@@ -324,8 +330,34 @@ export async function startParallel(basePath, milestoneIds, prefs) {
     };
     const started = [];
     const errors = [];
+    let filteredMilestoneIds = milestoneIds;
+    if (uokFlags.executionGraph && milestoneIds.length > 1) {
+        try {
+            const requestedIds = new Set(milestoneIds);
+            const candidates = await analyzeParallelEligibility(basePath);
+            const overlapPairs = new Set();
+            for (const overlap of candidates.fileOverlaps) {
+                if (!requestedIds.has(overlap.mid1) || !requestedIds.has(overlap.mid2))
+                    continue;
+                overlapPairs.add(overlapKey(overlap.mid1, overlap.mid2));
+            }
+            filteredMilestoneIds = selectConflictFreeBatch({
+                orderedIds: milestoneIds,
+                maxParallel: milestoneIds.length,
+                hasConflict: (candidate, existing) => overlapPairs.has(overlapKey(candidate, existing)),
+            });
+            if (filteredMilestoneIds.length < milestoneIds.length) {
+                const skipped = milestoneIds.filter((mid) => !filteredMilestoneIds.includes(mid));
+                logWarning("parallel", `uok execution graph filtered ${skipped.length} conflicting milestone(s): ${skipped.join(", ")}`);
+            }
+        }
+        catch (e) {
+            logWarning("parallel", `uok execution graph overlap analysis failed; using legacy milestone selection: ${e.message}`);
+            filteredMilestoneIds = milestoneIds;
+        }
+    }
     // Cap to max_workers
-    const toStart = milestoneIds.slice(0, config.max_workers);
+    const toStart = filteredMilestoneIds.slice(0, config.max_workers);
     for (const mid of toStart) {
         // Check budget ceiling before each spawn
         if (isBudgetExceeded()) {

package/dist/resources/extensions/gsd/preferences-models.js

@@ -321,7 +321,7 @@ export function resolveAutoSupervisorConfig() {
     };
 }
 // ─── Token Profile Resolution ─────────────────────────────────────────────
-const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality"]);
+const VALID_TOKEN_PROFILES = new Set(["budget", "balanced", "quality", "burn-max"]);
 /**
  * Resolve profile defaults for a given token profile tier.
  * Returns a partial GSDPreferences that is used as the base layer --
@@ -365,6 +365,22 @@ export function resolveProfileDefaults(profile) {
                     skip_reassess: true,
                 },
             };
+        case "burn-max":
+            return {
+                // Quality-first profile: keep user-selected models, disable downgrade routing.
+                // Policy constraints still apply at dispatch time.
+                dynamic_routing: {
+                    enabled: false,
+                },
+                context_selection: "full",
+                phases: {
+                    skip_research: false,
+                    skip_slice_research: false,
+                    skip_reassess: false,
+                    skip_milestone_validation: false,
+                    reassess_after_slice: true,
+                },
+            };
     }
 }
 /**
@@ -380,7 +396,7 @@ export function resolveEffectiveProfile() {
 }
 /**
  * Resolve the inline level from the active token profile.
- * budget -> minimal, balanced -> standard, quality -> full.
+ * budget -> minimal, balanced -> standard, quality/burn-max -> full.
  */
 export function resolveInlineLevel() {
     const profile = resolveEffectiveProfile();
@@ -388,11 +404,12 @@ export function resolveInlineLevel() {
         case "budget": return "minimal";
         case "balanced": return "standard";
         case "quality": return "full";
+        case "burn-max": return "full";
     }
 }
 /**
  * Resolve the context selection mode from the active token profile.
- * budget -> "smart", balanced/quality -> "full".
+ * budget -> "smart", balanced/quality/burn-max -> "full".
  * Explicit preference always wins.
  */
 export function resolveContextSelection() {

package/dist/resources/extensions/gsd/preferences-types.js

@@ -53,6 +53,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "post_unit_hooks",
     "pre_dispatch_hooks",
     "dynamic_routing",
+    "uok",
     "token_profile",
     "phases",
     "auto_visualize",