@izkac/forgekit 0.1.0

package/src/paths.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * Resolve forgekit asset roots (skills, templates).
+ *
+ * Search order for assets:
+ *   1. FORGEKIT_ROOT env (dev / linked monorepo)
+ *   2. Monorepo root (packages/cli/../../..)
+ *   3. Vendored copy inside the published package (packages/cli/vendor)
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** @returns {string} Absolute path to packages/cli */
+export function cliPackageRoot() {
+  return path.resolve(__dirname, '..');
+}
+
+/**
+ * Candidate forgekit roots that may contain skills/ and templates/.
+ * @returns {string[]}
+ */
+export function forgekitRootCandidates() {
+  const roots = [];
+  if (process.env.FORGEKIT_ROOT) roots.push(process.env.FORGEKIT_ROOT);
+  // Monorepo: packages/cli/src → ../../../
+  roots.push(path.resolve(__dirname, '..', '..', '..'));
+  // Published package: vendor/ next to src/
+  roots.push(path.join(cliPackageRoot(), 'vendor'));
+  return [...new Set(roots.map((r) => path.resolve(r)))];
+}
+
+/**
+ * @param {string} relativePath e.g. 'skills/forge' or 'templates/project'
+ * @param {{ requireFile?: string }} [opts] file that must exist under the candidate
+ * @returns {string}
+ */
+export function resolveAsset(relativePath, opts = {}) {
+  const requireFile = opts.requireFile;
+  const tried = [];
+  for (const root of forgekitRootCandidates()) {
+    const candidate = path.join(root, relativePath);
+    tried.push(candidate);
+    const check = requireFile ? path.join(candidate, requireFile) : candidate;
+    if (fs.existsSync(check)) return candidate;
+  }
+  throw new Error(
+    `Asset not found: ${relativePath}${requireFile ? ` (${requireFile})` : ''}.\nTried:\n  ${tried.join('\n  ')}`,
+  );
+}
+
+/**
+ * @returns {string} package version from packages/cli/package.json
+ */
+export function packageVersion() {
+  const pkgPath = path.join(cliPackageRoot(), 'package.json');
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  return pkg.version ?? '0.0.0';
+}
+
+/**
+ * Stable content hash of a directory (sorted relative paths + file bytes).
+ * @param {string} dir
+ * @returns {string} sha256 hex
+ */
+export function hashDirectory(dir) {
+  const hash = createHash('sha256');
+  /** @type {string[]} */
+  const files = [];
+  const walk = (d, prefix = '') => {
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+      if (entry.name === '.forgekit.json') continue;
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const full = path.join(d, entry.name);
+      if (entry.isDirectory()) walk(full, rel);
+      else files.push(rel);
+    }
+  };
+  walk(dir);
+  files.sort();
+  for (const rel of files) {
+    hash.update(rel);
+    hash.update('\0');
+    hash.update(fs.readFileSync(path.join(dir, ...rel.split('/'))));
+    hash.update('\0');
+  }
+  return hash.digest('hex');
+}

package/src/plan-engine.mjs

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+/**
+ * Planning engine resolution + scaffolding for forgekit.
+ *
+ * Engines:
+ *   openspec — vendor OpenSpec CLI (`openspec/changes/<name>/`)
+ *   specs    — built-in markdown engine (`specs/changes/<name>/`), same inner
+ *              layout as OpenSpec so phases / archive→ADR / later migration
+ *              stay compatible.
+ *
+ * User default:  ~/.forgekit/config.json  → { plan: { engine } }
+ * Project:       <repo>/.forge/config.json → { plan: { engine, dir } }
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import {
+  loadProjectConfig,
+  loadUserConfig,
+  saveProjectConfig,
+  saveUserConfig,
+} from './config.mjs';
+
+export const PLAN_ENGINES = Object.freeze(['openspec', 'specs']);
+export const DEFAULT_SPECS_DIR = 'specs';
+
+export const OPENSPEC_PACKAGE = '@fission-ai/openspec';
+export const OPENSPEC_INSTALL_CMD = `npm install -g ${OPENSPEC_PACKAGE}`;
+
+/**
+ * @param {unknown} value
+ * @returns {{ engine?: string, dir?: string } | null}
+ */
+function asPlan(value) {
+  if (!value || typeof value !== 'object') return null;
+  return /** @type {{ engine?: string, dir?: string }} */ (value);
+}
+
+/**
+ * @param {string} engine
+ */
+export function assertPlanEngine(engine) {
+  if (!PLAN_ENGINES.includes(engine)) {
+    throw new Error(`Unknown plan engine: ${engine}. Known: ${PLAN_ENGINES.join(', ')}`);
+  }
+  return engine;
+}
+
+/**
+ * @param {string} cwd
+ * @returns {boolean}
+ */
+export function hasOpenSpecConfig(cwd) {
+  return fs.existsSync(path.join(cwd, 'openspec', 'config.yaml'));
+}
+
+/**
+ * @param {string} [home]
+ * @returns {string | null}
+ */
+export function loadUserPlanEngine(home = os.homedir()) {
+  const cfg = loadUserConfig(home);
+  const engine = asPlan(cfg.plan)?.engine;
+  return PLAN_ENGINES.includes(engine) ? engine : null;
+}
+
+/**
+ * Merge { plan: { engine } } into ~/.forgekit/config.json, preserving other keys.
+ * @param {string} engine
+ * @param {string} [home]
+ */
+export function saveUserPlanEngine(engine, home = os.homedir()) {
+  assertPlanEngine(engine);
+  return saveUserConfig({ plan: { engine } }, home);
+}
+
+/**
+ * Merge { plan: { engine, dir? } } into <cwd>/.forge/config.json, preserving adr etc.
+ * @param {string} cwd
+ * @param {{ engine: string, dir?: string }} plan
+ */
+export function writeProjectPlanConfig(cwd, plan) {
+  assertPlanEngine(plan.engine);
+  const current = loadProjectConfig(cwd);
+  const curPlan = asPlan(current.plan);
+  /** @type {{ engine: string, dir?: string }} */
+  const nextPlan = { engine: plan.engine };
+  if (plan.engine === 'specs') {
+    nextPlan.dir = plan.dir ?? curPlan?.dir ?? DEFAULT_SPECS_DIR;
+  }
+  return saveProjectConfig(cwd, { plan: nextPlan }, { replaceKeys: ['plan'] });
+}
+
+/**
+ * Effective plan engine for a project.
+ *
+ * Precedence: project config → openspec/config.yaml detection → user default
+ * → 'openspec'.
+ *
+ * @param {string} cwd
+ * @param {{ home?: string, useUserDefault?: boolean }} [opts]
+ * @returns {{ engine: string, dir: string, source: string }}
+ */
+export function resolveProjectPlanEngine(cwd, opts = {}) {
+  const project = loadProjectConfig(cwd);
+  const projectPlan = asPlan(project.plan);
+  if (projectPlan && PLAN_ENGINES.includes(projectPlan.engine)) {
+    return {
+      engine: /** @type {string} */ (projectPlan.engine),
+      dir: projectPlan.dir ?? DEFAULT_SPECS_DIR,
+      source: 'project',
+    };
+  }
+  if (hasOpenSpecConfig(cwd)) {
+    return { engine: 'openspec', dir: DEFAULT_SPECS_DIR, source: 'detected' };
+  }
+  if (opts.useUserDefault !== false) {
+    const userEngine = loadUserPlanEngine(opts.home);
+    if (userEngine) {
+      return { engine: userEngine, dir: DEFAULT_SPECS_DIR, source: 'user' };
+    }
+  }
+  return { engine: 'openspec', dir: DEFAULT_SPECS_DIR, source: 'default' };
+}
+
+const SPECS_README = (dir) => `# \`${dir}/\` — Forge specs (built-in planning engine)
+
+OpenSpec-compatible change tracking without the OpenSpec CLI. Managed by the
+Forge workflow (see the \`forge\` skill, \`phases/plan-specs.md\`).
+
+\`\`\`
+${dir}/
+  changes/<change-name>/
+    proposal.md   # Why / What Changes / Impact
+    design.md     # optional — context, decisions, risks
+    tasks.md      # ## groups with - [ ] task checkboxes
+  changes/archive/YYYY-MM-DD-<change-name>/   # archived on finish
+\`\`\`
+
+Conventions (kept identical to OpenSpec so migration stays trivial):
+
+- One change per unit of substantial work; kebab-case change names.
+- \`tasks.md\` uses \`##\` section groups and \`- [ ]\` checkboxes; Forge counts
+  and reviews per group.
+- On finish, move the change dir into \`changes/archive/\` with a date prefix,
+  then follow the project ADR policy if enabled.
+
+Migrating to OpenSpec later: run \`openspec init\`, then move
+\`${dir}/changes/*\` into \`openspec/changes/\`.
+`;
+
+/**
+ * Scaffold the specs engine directory structure.
+ * @param {string} cwd
+ * @param {{ dir?: string, force?: boolean }} [opts]
+ */
+export function scaffoldSpecs(cwd, opts = {}) {
+  const dir = opts.dir ?? DEFAULT_SPECS_DIR;
+  /** @type {{ file: string, status: string }[]} */
+  const files = [];
+
+  const ensureDir = (rel) => {
+    fs.mkdirSync(path.join(cwd, ...rel.split('/')), { recursive: true });
+  };
+  const writeFile = (rel, body) => {
+    const dest = path.join(cwd, ...rel.split('/'));
+    if (fs.existsSync(dest) && !opts.force) {
+      files.push({ file: rel, status: 'skipped' });
+      return;
+    }
+    fs.writeFileSync(dest, body, 'utf8');
+    files.push({ file: rel, status: 'written' });
+  };
+
+  ensureDir(`${dir}/changes/archive`);
+  writeFile(`${dir}/README.md`, SPECS_README(dir));
+  writeFile(`${dir}/changes/archive/.gitkeep`, '');
+
+  return { dir, files };
+}
+
+/**
+ * @returns {{ ok: boolean, version: string | null }}
+ */
+export function checkOpenSpecCliQuick(runCommand) {
+  const run =
+    runCommand ??
+    ((cmd, args) => {
+      let result = spawnSync(cmd, args, { encoding: 'utf8', shell: false });
+      if (result.error && process.platform === 'win32') {
+        result = spawnSync([cmd, ...args].join(' '), { encoding: 'utf8', shell: true });
+      }
+      return { status: result.status, stdout: result.stdout || '' };
+    });
+  const attempt = run('openspec', ['--version']);
+  if (attempt.status === 0) {
+    return {
+      ok: true,
+      version: String(attempt.stdout || '').trim().split(/\r?\n/)[0] || 'unknown',
+    };
+  }
+  return { ok: false, version: null };
+}
+
+/**
+ * Install the OpenSpec CLI (if missing) and run `openspec init` in the project.
+ * Interactive: inherits stdio so `openspec init` can prompt.
+ *
+ * @param {string} cwd
+ * @param {{ runCommand?: Function, interactive?: boolean }} [opts]
+ * @returns {{ ok: boolean, steps: { step: string, ok: boolean, detail?: string }[] }}
+ */
+export function setupOpenSpec(cwd, opts = {}) {
+  /** @type {{ step: string, ok: boolean, detail?: string }[]} */
+  const steps = [];
+
+  const runInherit =
+    opts.runCommand ??
+    ((cmd, args) => {
+      let result = spawnSync(cmd, args, { stdio: 'inherit', shell: false, cwd });
+      if (result.error && process.platform === 'win32') {
+        result = spawnSync([cmd, ...args].join(' '), {
+          stdio: 'inherit',
+          shell: true,
+          cwd,
+        });
+      }
+      return { status: result.status, error: result.error };
+    });
+
+  const cli = checkOpenSpecCliQuick(opts.runCommand);
+  if (!cli.ok) {
+    const install = runInherit('npm', ['install', '-g', OPENSPEC_PACKAGE]);
+    const ok = install.status === 0;
+    steps.push({
+      step: OPENSPEC_INSTALL_CMD,
+      ok,
+      detail: ok ? undefined : String(install.error ?? `exit ${install.status}`),
+    });
+    if (!ok) return { ok: false, steps };
+  } else {
+    steps.push({ step: `openspec CLI present (${cli.version})`, ok: true });
+  }
+
+  if (hasOpenSpecConfig(cwd)) {
+    steps.push({ step: 'openspec/config.yaml already present', ok: true });
+    return { ok: true, steps };
+  }
+
+  const init = runInherit('openspec', ['init']);
+  const initOk = init.status === 0;
+  steps.push({
+    step: 'openspec init',
+    ok: initOk,
+    detail: initOk ? undefined : String(init.error ?? `exit ${init.status}`),
+  });
+  return { ok: initOk && hasOpenSpecConfig(cwd), steps };
+}

package/src/plan-engine.test.mjs

@@ -0,0 +1,245 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  DEFAULT_SPECS_DIR,
+  PLAN_ENGINES,
+  hasOpenSpecConfig,
+  loadUserPlanEngine,
+  resolveProjectPlanEngine,
+  saveUserPlanEngine,
+  scaffoldSpecs,
+  setupOpenSpec,
+  writeProjectPlanConfig,
+} from './plan-engine.mjs';
+import { loadProjectConfig, loadUserConfig, saveUserConfig } from './adr.mjs';
+import { parseArgs as parseInstallArgs } from './install.mjs';
+import { parseArgs as parseInitArgs, initProject } from './init.mjs';
+import { runDoctorChecks } from './doctor.mjs';
+
+function tmpdir(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+test('user plan engine round-trip preserves adr config', () => {
+  const home = tmpdir('forgekit-plan-user-');
+  try {
+    saveUserConfig({ adr: { enabled: true, dir: 'docs/adr' } }, home);
+    saveUserPlanEngine('specs', home);
+    assert.equal(loadUserPlanEngine(home), 'specs');
+    assert.equal(loadUserConfig(home).adr.enabled, true);
+    saveUserPlanEngine('openspec', home);
+    assert.equal(loadUserPlanEngine(home), 'openspec');
+    assert.throws(() => saveUserPlanEngine('bogus', home), /Unknown plan engine/);
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('writeProjectPlanConfig preserves adr block and sets dir for specs', () => {
+  const cwd = tmpdir('forgekit-plan-proj-');
+  try {
+    fs.mkdirSync(path.join(cwd, '.forge'), { recursive: true });
+    fs.writeFileSync(
+      path.join(cwd, '.forge', 'config.json'),
+      JSON.stringify({ adr: { enabled: true, dir: 'docs/adr' } }),
+      'utf8',
+    );
+    writeProjectPlanConfig(cwd, { engine: 'specs' });
+    const cfg = loadProjectConfig(cwd);
+    assert.equal(cfg.plan.engine, 'specs');
+    assert.equal(cfg.plan.dir, DEFAULT_SPECS_DIR);
+    assert.equal(cfg.adr.enabled, true);
+
+    writeProjectPlanConfig(cwd, { engine: 'openspec' });
+    assert.equal(loadProjectConfig(cwd).plan.engine, 'openspec');
+    assert.equal(loadProjectConfig(cwd).plan.dir, undefined);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('resolveProjectPlanEngine precedence: project > detection > user > default', () => {
+  const cwd = tmpdir('forgekit-plan-res-');
+  const home = tmpdir('forgekit-plan-res-home-');
+  try {
+    // default
+    assert.equal(
+      resolveProjectPlanEngine(cwd, { home }).engine,
+      'openspec',
+    );
+    assert.equal(resolveProjectPlanEngine(cwd, { home }).source, 'default');
+
+    // user default
+    saveUserPlanEngine('specs', home);
+    const viaUser = resolveProjectPlanEngine(cwd, { home });
+    assert.equal(viaUser.engine, 'specs');
+    assert.equal(viaUser.source, 'user');
+
+    // useUserDefault=false ignores user config
+    assert.equal(
+      resolveProjectPlanEngine(cwd, { home, useUserDefault: false }).source,
+      'default',
+    );
+
+    // openspec detection beats user default
+    fs.mkdirSync(path.join(cwd, 'openspec'), { recursive: true });
+    fs.writeFileSync(path.join(cwd, 'openspec', 'config.yaml'), 'name: x\n', 'utf8');
+    assert.equal(hasOpenSpecConfig(cwd), true);
+    const detected = resolveProjectPlanEngine(cwd, { home });
+    assert.equal(detected.engine, 'openspec');
+    assert.equal(detected.source, 'detected');
+
+    // project config beats detection
+    writeProjectPlanConfig(cwd, { engine: 'specs', dir: 'specs' });
+    const viaProject = resolveProjectPlanEngine(cwd, { home });
+    assert.equal(viaProject.engine, 'specs');
+    assert.equal(viaProject.source, 'project');
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('scaffoldSpecs writes README + changes/archive', () => {
+  const cwd = tmpdir('forgekit-specs-scaffold-');
+  try {
+    const result = scaffoldSpecs(cwd, { force: true });
+    assert.equal(result.dir, DEFAULT_SPECS_DIR);
+    assert.ok(fs.existsSync(path.join(cwd, 'specs', 'README.md')));
+    assert.ok(fs.existsSync(path.join(cwd, 'specs', 'changes', 'archive')));
+    const readme = fs.readFileSync(path.join(cwd, 'specs', 'README.md'), 'utf8');
+    assert.match(readme, /changes\/<change-name>/);
+    assert.match(readme, /tasks\.md/);
+
+    // second run without force skips
+    const again = scaffoldSpecs(cwd);
+    assert.ok(again.files.some((f) => f.status === 'skipped'));
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('setupOpenSpec runs install + init via injected runner', () => {
+  const cwd = tmpdir('forgekit-openspec-setup-');
+  try {
+    /** @type {string[]} */
+    const calls = [];
+    const runCommand = (cmd, args) => {
+      const line = [cmd, ...args].join(' ');
+      calls.push(line);
+      if (line === 'openspec --version') return { status: 1, stdout: '' };
+      if (line.startsWith('npm install -g')) return { status: 0, stdout: '' };
+      if (line === 'openspec init') {
+        fs.mkdirSync(path.join(cwd, 'openspec'), { recursive: true });
+        fs.writeFileSync(path.join(cwd, 'openspec', 'config.yaml'), 'x: 1\n', 'utf8');
+        return { status: 0, stdout: '' };
+      }
+      return { status: 1, stdout: '' };
+    };
+    const result = setupOpenSpec(cwd, { runCommand });
+    assert.equal(result.ok, true);
+    assert.ok(calls.some((c) => c.startsWith('npm install -g')));
+    assert.ok(calls.includes('openspec init'));
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('setupOpenSpec reports failure when install fails', () => {
+  const cwd = tmpdir('forgekit-openspec-fail-');
+  try {
+    const runCommand = () => ({ status: 1, stdout: '' });
+    const result = setupOpenSpec(cwd, { runCommand });
+    assert.equal(result.ok, false);
+    assert.ok(result.steps.some((s) => !s.ok));
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('install parseArgs --openspec / --no-openspec', () => {
+  assert.equal(parseInstallArgs(['--openspec']).openspec, true);
+  assert.equal(parseInstallArgs(['--no-openspec']).openspec, false);
+  assert.equal(parseInstallArgs([]).openspec, null);
+});
+
+test('init parseArgs --openspec / --no-openspec', () => {
+  assert.equal(parseInitArgs(['--openspec']).openspec, true);
+  assert.equal(parseInitArgs(['--no-openspec']).openspec, false);
+  assert.equal(parseInitArgs([]).openspec, null);
+});
+
+test('initProject planEngine=specs scaffolds and writes config', () => {
+  const cwd = tmpdir('forgekit-init-specs-');
+  try {
+    const report = initProject(['codex'], {
+      cwd,
+      force: true,
+      planEngine: 'specs',
+    });
+    assert.equal(report.plan.engine, 'specs');
+    assert.ok(fs.existsSync(path.join(cwd, 'specs', 'README.md')));
+    assert.equal(loadProjectConfig(cwd).plan.engine, 'specs');
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('initProject planEngine=openspec records engine without scaffolding specs', () => {
+  const cwd = tmpdir('forgekit-init-os-');
+  try {
+    const report = initProject(['codex'], {
+      cwd,
+      force: true,
+      planEngine: 'openspec',
+    });
+    assert.equal(report.plan.engine, 'openspec');
+    assert.equal(report.plan.configured, false);
+    assert.ok(!fs.existsSync(path.join(cwd, 'specs')));
+    assert.equal(loadProjectConfig(cwd).plan.engine, 'openspec');
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('doctor: specs engine checks specs layout instead of OpenSpec CLI', () => {
+  const cwd = tmpdir('forgekit-doctor-specs-');
+  try {
+    writeProjectPlanConfig(cwd, { engine: 'specs' });
+
+    const missing = runDoctorChecks({ cwd });
+    assert.equal(missing.engine, 'specs');
+    assert.equal(missing.ok, false);
+    assert.match(missing.checks.project.message, /specs\/changes/);
+    assert.equal(missing.checks.cli.ok, true);
+    assert.equal(missing.checks.cli.skipped, true);
+
+    scaffoldSpecs(cwd);
+    const present = runDoctorChecks({ cwd });
+    assert.equal(present.ok, true);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('doctor: openspec engine unchanged for openspec projects', () => {
+  const cwd = tmpdir('forgekit-doctor-os-');
+  try {
+    const report = runDoctorChecks({
+      cwd,
+      existsSync: () => true,
+      runCommand: () => ({ status: 0, stdout: '1.0.0', stderr: '' }),
+    });
+    assert.equal(report.engine, 'openspec');
+    assert.equal(report.ok, true);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('PLAN_ENGINES is the closed engine set', () => {
+  assert.deepEqual([...PLAN_ENGINES], ['openspec', 'specs']);
+});

package/src/preferences.defaults.json

@@ -0,0 +1,78 @@
+{
+  "pace": "auto",
+  "integrity": {
+    "forbidStubs": true,
+    "specsBeatNarrowTasks": true,
+    "requireE2E": "when-jobs-or-workers"
+  },
+  "presets": {
+    "thorough": {
+      "review": {
+        "perTask": "always",
+        "final": "always",
+        "depth": "full",
+        "maxRounds": 3
+      },
+      "verify": {
+        "tier3": "full-workspace"
+      },
+      "models": {
+        "bias": "default"
+      },
+      "brainstorm": {
+        "depth": "full"
+      }
+    },
+    "standard": {
+      "review": {
+        "perTask": "per-group",
+        "final": "always",
+        "depth": "full",
+        "maxRounds": 2
+      },
+      "verify": {
+        "tier3": "full-workspace"
+      },
+      "models": {
+        "bias": "default"
+      },
+      "brainstorm": {
+        "depth": "full"
+      }
+    },
+    "brisk": {
+      "review": {
+        "perTask": "high-risk-only",
+        "final": "high-risk-only",
+        "depth": "spec-only",
+        "maxRounds": 1
+      },
+      "verify": {
+        "tier3": "affected-only"
+      },
+      "models": {
+        "bias": "prefer-fast"
+      },
+      "brainstorm": {
+        "depth": "short"
+      }
+    },
+    "lite": {
+      "review": {
+        "perTask": "never",
+        "final": "never",
+        "depth": "spec-only",
+        "maxRounds": 0
+      },
+      "verify": {
+        "tier3": "audit-tier2-only"
+      },
+      "models": {
+        "bias": "prefer-fast"
+      },
+      "brainstorm": {
+        "depth": "minimal"
+      }
+    }
+  }
+}