gsd-pi 2.74.0 → 2.75.0-dev.063e5a3

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/index.ts

@@ -16,6 +16,22 @@ export {
 } from "./bootstrap/write-gate.js";
 
 export default async function registerExtension(pi: ExtensionAPI) {
-  const { registerGsdExtension } = await import("./bootstrap/register-extension.js");
-  registerGsdExtension(pi);
+  // Always register the core /gsd command first, in isolation.
+  // This ensures /gsd is available even if the full bootstrap (shortcuts,
+  // tools, hooks) fails — e.g. due to a Windows-specific import error.
+  const { registerGSDCommand } = await import("./commands/index.js");
+  registerGSDCommand(pi);
+
+  // Full setup (shortcuts, tools, hooks) in a separate try/catch so that
+  // any platform-specific load failure doesn't take out the core command.
+  try {
+    const { registerGsdExtension } = await import("./bootstrap/register-extension.js");
+    registerGsdExtension(pi);
+  } catch (err) {
+    const { logWarning } = await import("./workflow-logger.js");
+    logWarning(
+      "bootstrap",
+      `Extension setup partially failed — /gsd commands are available but shortcuts/tools may be missing: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
 }

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

package/src/resources/extensions/gsd/journal.ts

@@ -15,6 +15,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";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -90,6 +92,34 @@ export function emitJournalEvent(basePath: string, entry: JournalEntry): void {
   } 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/src/resources/extensions/gsd/md-importer.ts

@@ -16,6 +16,7 @@ import {
   insertTask,
   openDatabase,
   transaction,
+  updateSliceStatus,
   _getAdapter,
 } from './gsd-db.js';
 import {
@@ -672,11 +673,8 @@ export function migrateHierarchyToDb(basePath: string): {
           return t.done && existsSync(summaryFile);
         });
         if (allTasksDone && hasSliceSummary) {
-          const adapter = _getAdapter();
-          if (adapter) {
-            adapter.prepare(
-              `UPDATE slices SET status = 'complete' WHERE id = :sid AND milestone_id = :mid`,
-            ).run({ ':sid': sliceEntry.id, ':mid': milestoneId });
+          if (_getAdapter()) {
+            updateSliceStatus(milestoneId, sliceEntry.id, 'complete');
             process.stderr.write(
               `gsd-migrate: ${milestoneId}/${sliceEntry.id} all tasks + slice summary complete — upgrading slice to complete\n`,
             );

package/src/resources/extensions/gsd/memory-store.ts

@@ -3,7 +3,19 @@
 // Storage layer for auto-learned project memories. Follows context-store.ts patterns.
 // All functions degrade gracefully: return empty results when DB unavailable, never throw.
 
-import { isDbAvailable, _getAdapter, transaction } from './gsd-db.js';
+import {
+  isDbAvailable,
+  _getAdapter,
+  transaction,
+  insertMemoryRow,
+  rewriteMemoryId,
+  updateMemoryContentRow,
+  incrementMemoryHitCount,
+  supersedeMemoryRow,
+  markMemoryUnitProcessed,
+  decayMemoriesBefore,
+  supersedeLowestRankedMemories,
+} from './gsd-db.js';
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -170,28 +182,22 @@ export function createMemory(fields: {
     const now = new Date().toISOString();
     // Insert with a temporary placeholder ID — seq is auto-assigned
     const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    adapter.prepare(
-      `INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at)
-       VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at)`,
-    ).run({
-      ':id': placeholder,
-      ':category': fields.category,
-      ':content': fields.content,
-      ':confidence': fields.confidence ?? 0.8,
-      ':source_unit_type': fields.source_unit_type ?? null,
-      ':source_unit_id': fields.source_unit_id ?? null,
-      ':created_at': now,
-      ':updated_at': now,
+    insertMemoryRow({
+      id: placeholder,
+      category: fields.category,
+      content: fields.content,
+      confidence: fields.confidence ?? 0.8,
+      sourceUnitType: fields.source_unit_type ?? null,
+      sourceUnitId: fields.source_unit_id ?? null,
+      createdAt: now,
+      updatedAt: now,
     });
-    // Derive the real ID from the assigned seq
+    // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
     const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
     if (!row) return placeholder; // fallback — should not happen
     const seq = row['seq'] as number;
     const realId = `MEM${String(seq).padStart(3, '0')}`;
-    adapter.prepare('UPDATE memories SET id = :real_id WHERE id = :placeholder').run({
-      ':real_id': realId,
-      ':placeholder': placeholder,
-    });
+    rewriteMemoryId(placeholder, realId);
     return realId;
   } catch {
     return null;
@@ -203,20 +209,9 @@ export function createMemory(fields: {
  */
 export function updateMemoryContent(id: string, content: string, confidence?: number): boolean {
   if (!isDbAvailable()) return false;
-  const adapter = _getAdapter();
-  if (!adapter) return false;
 
   try {
-    const now = new Date().toISOString();
-    if (confidence != null) {
-      adapter.prepare(
-        'UPDATE memories SET content = :content, confidence = :confidence, updated_at = :updated_at WHERE id = :id',
-      ).run({ ':content': content, ':confidence': confidence, ':updated_at': now, ':id': id });
-    } else {
-      adapter.prepare(
-        'UPDATE memories SET content = :content, updated_at = :updated_at WHERE id = :id',
-      ).run({ ':content': content, ':updated_at': now, ':id': id });
-    }
+    updateMemoryContentRow(id, content, confidence, new Date().toISOString());
     return true;
   } catch {
     return false;
@@ -228,13 +223,9 @@ export function updateMemoryContent(id: string, content: string, confidence?: nu
  */
 export function reinforceMemory(id: string): boolean {
   if (!isDbAvailable()) return false;
-  const adapter = _getAdapter();
-  if (!adapter) return false;
 
   try {
-    adapter.prepare(
-      'UPDATE memories SET hit_count = hit_count + 1, updated_at = :updated_at WHERE id = :id',
-    ).run({ ':updated_at': new Date().toISOString(), ':id': id });
+    incrementMemoryHitCount(id, new Date().toISOString());
     return true;
   } catch {
     return false;
@@ -246,13 +237,9 @@ export function reinforceMemory(id: string): boolean {
  */
 export function supersedeMemory(oldId: string, newId: string): boolean {
   if (!isDbAvailable()) return false;
-  const adapter = _getAdapter();
-  if (!adapter) return false;
 
   try {
-    adapter.prepare(
-      'UPDATE memories SET superseded_by = :new_id, updated_at = :updated_at WHERE id = :old_id',
-    ).run({ ':new_id': newId, ':updated_at': new Date().toISOString(), ':old_id': oldId });
+    supersedeMemoryRow(oldId, newId, new Date().toISOString());
     return true;
   } catch {
     return false;
@@ -284,14 +271,9 @@ export function isUnitProcessed(unitKey: string): boolean {
  */
 export function markUnitProcessed(unitKey: string, activityFile: string): boolean {
   if (!isDbAvailable()) return false;
-  const adapter = _getAdapter();
-  if (!adapter) return false;
 
   try {
-    adapter.prepare(
-      `INSERT OR IGNORE INTO memory_processed_units (unit_key, activity_file, processed_at)
-       VALUES (:key, :file, :at)`,
-    ).run({ ':key': unitKey, ':file': activityFile, ':at': new Date().toISOString() });
+    markMemoryUnitProcessed(unitKey, activityFile, new Date().toISOString());
     return true;
   } catch {
     return false;
@@ -310,7 +292,7 @@ export function decayStaleMemories(thresholdUnits = 20): void {
   if (!adapter) return;
 
   try {
-    // Find the timestamp of the Nth most recent processed unit
+    // Find the timestamp of the Nth most recent processed unit (read-only SELECT)
     const row = adapter.prepare(
       `SELECT processed_at FROM memory_processed_units
        ORDER BY processed_at DESC
@@ -320,11 +302,7 @@ export function decayStaleMemories(thresholdUnits = 20): void {
     if (!row) return; // not enough processed units yet
 
     const cutoff = row['processed_at'] as string;
-    adapter.prepare(
-      `UPDATE memories
-       SET confidence = MAX(0.1, confidence - 0.1), updated_at = :now
-       WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`,
-    ).run({ ':now': new Date().toISOString(), ':cutoff': cutoff });
+    decayMemoriesBefore(cutoff, new Date().toISOString());
   } catch {
     // non-fatal
   }
@@ -346,16 +324,7 @@ export function enforceMemoryCap(max = 50): void {
     if (count <= max) return;
 
     const excess = count - max;
-    // Batch update: supersede lowest-ranked active memories in a single statement
-    adapter.prepare(
-      `UPDATE memories SET superseded_by = 'CAP_EXCEEDED', updated_at = :now
-       WHERE id IN (
-         SELECT id FROM memories
-         WHERE superseded_by IS NULL
-         ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
-         LIMIT :limit
-       )`,
-    ).run({ ':now': new Date().toISOString(), ':limit': excess });
+    supersedeLowestRankedMemories(excess, new Date().toISOString());
   } catch {
     // non-fatal
   }

package/src/resources/extensions/gsd/metrics.ts

@@ -19,6 +19,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
@@ -143,6 +145,9 @@ export function snapshotUnitMetrics(
     promptCharCount?: number;
     baselineCharCount?: number;
     autoSessionKey?: string;
+    traceId?: string;
+    turnId?: string;
+    causedBy?: string;
   },
 ): UnitMetrics | null {
   if (!ledger) return null;
@@ -235,6 +240,27 @@ export function snapshotUnitMetrics(
   }
   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/src/resources/extensions/gsd/milestone-validation-gates.ts

@@ -11,7 +11,7 @@
  * dispatch rules, and state derivation. See gate-registry.ts.
  */
 
-import { _getAdapter } from "./gsd-db.js";
+import { isDbAvailable, upsertQualityGate } from "./gsd-db.js";
 import { getGatesForTurn } from "./gate-registry.js";
 
 /**
@@ -31,24 +31,23 @@ export function insertMilestoneValidationGates(
   verdict: string,
   evaluatedAt: string,
 ): void {
-  const db = _getAdapter();
-  if (!db) return;
+  if (!isDbAvailable()) return;
 
   const gateVerdict = verdict === "pass" ? "pass" : "flag";
   const milestoneGates = getGatesForTurn("validate-milestone");
 
   for (const def of milestoneGates) {
-    db.prepare(
-      `INSERT OR REPLACE INTO quality_gates
-       (milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at)
-       VALUES (:mid, :sid, :gid, 'milestone', '', 'complete', :verdict, :rationale, '', :evaluated_at)`,
-    ).run({
-      ":mid": milestoneId,
-      ":sid": sliceId,
-      ":gid": def.id,
-      ":verdict": gateVerdict,
-      ":rationale": `${def.promptSection} — milestone validation verdict: ${verdict}`,
-      ":evaluated_at": evaluatedAt,
+    upsertQualityGate({
+      milestoneId,
+      sliceId,
+      gateId: def.id,
+      scope: "milestone",
+      taskId: "",
+      status: "complete",
+      verdict: gateVerdict,
+      rationale: `${def.promptSection} — milestone validation verdict: ${verdict}`,
+      findings: "",
+      evaluatedAt,
     });
   }
 }

package/src/resources/extensions/gsd/native-git-bridge.ts

@@ -323,7 +323,7 @@ export function nativeIsRepo(basePath: string): boolean {
     return native.gitIsRepo(basePath);
   }
   try {
-    execSync("git rev-parse --git-dir", { cwd: basePath, stdio: "pipe" });
+    execFileSync("git", ["rev-parse", "--git-dir"], { cwd: basePath, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -790,16 +790,15 @@ export function nativeCommit(
 
   // Fallback: use git commit with stdin pipe for safe multi-line messages
   try {
-    const result = execSync(
-      `git commit --no-verify -F -${options?.allowEmpty ? " --allow-empty" : ""}`,
-      {
-        cwd: basePath,
-        stdio: ["pipe", "pipe", "pipe"],
-        encoding: "utf-8",
-        env: GIT_NO_PROMPT_ENV,
-        input: message,
-      },
-    ).trim();
+    const args = ["commit", "--no-verify", "-F", "-"];
+    if (options?.allowEmpty) args.push("--allow-empty");
+    const result = execFileSync("git", args, {
+      cwd: basePath,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+      input: message,
+    }).trim();
     return result;
   } catch (err: unknown) {
     const errObj = err as { stdout?: string; stderr?: string; message?: string };
@@ -940,7 +939,7 @@ export function nativeResetHard(basePath: string): void {
     native.gitResetHard(basePath);
     return;
   }
-  execSync("git reset --hard HEAD", { cwd: basePath, stdio: "pipe" });
+  execFileSync("git", ["reset", "--hard", "HEAD"], { cwd: basePath, stdio: "pipe" });
 }
 
 /**

package/src/resources/extensions/gsd/parallel-orchestrator.ts

@@ -42,6 +42,8 @@ import {
 } 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";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
 
@@ -69,6 +71,10 @@ export interface OrchestratorState {
 
 let state: OrchestratorState | null = null;
 
+function overlapKey(a: string, b: string): string {
+  return a < b ? `${a}::${b}` : `${b}::${a}`;
+}
+
 // ─── Persistence ──────────────────────────────────────────────────────────
 
 const ORCHESTRATOR_STATE_FILE = "orchestrator.json";
@@ -365,6 +371,7 @@ export async function startParallel(
   }
 
   const config = resolveParallelConfig(prefs);
+  const uokFlags = resolveUokFlags(prefs);
 
   // Release any leftover state from a previous session before reassigning
   if (state) {
@@ -418,8 +425,40 @@ export async function startParallel(
   const started: string[] = [];
   const errors: Array<{ mid: string; error: string }> = [];
 
+  let filteredMilestoneIds = milestoneIds;
+  if (uokFlags.executionGraph && milestoneIds.length > 1) {
+    try {
+      const requestedIds = new Set(milestoneIds);
+      const candidates = await analyzeParallelEligibility(basePath);
+      const overlapPairs = new Set<string>();
+      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 as Error).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

package/src/resources/extensions/gsd/preferences-models.ts

@@ -355,7 +355,7 @@ export function resolveAutoSupervisorConfig(): AutoSupervisorConfig {
 
 // ─── Token Profile Resolution ─────────────────────────────────────────────
 
-const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality"]);
+const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
 
 /**
  * Resolve profile defaults for a given token profile tier.
@@ -400,6 +400,22 @@ export function resolveProfileDefaults(profile: TokenProfile): Partial<GSDPrefer
           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,
+        },
+      };
   }
 }
 
@@ -416,7 +432,7 @@ export function resolveEffectiveProfile(): TokenProfile {
 
 /**
  * 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(): InlineLevel {
   const profile = resolveEffectiveProfile();
@@ -424,12 +440,13 @@ export function resolveInlineLevel(): InlineLevel {
     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(): import("./types.js").ContextSelectionMode {