aiki-cli 0.3.1 → 0.3.3

package/dist/bench/idea-v3-rating.js

@@ -118,7 +118,7 @@ function blindId(seed) {
     return createHash('sha256').update(seed).digest('hex').slice(0, 12).toUpperCase();
 }
 /** Remove the explicit identifiers forbidden by BENCHMARK-IDEA-V3.md §4 before human rating. §4 bars
- *  provider/model names, run ids, arm labels, AND costs — so the R7 dossier's §9 "Run details" cost
+ *  provider/model names, run ids, arm labels, AND costs — so the dossier's "Run details" cost
  *  block (mode, call counts, categories, per-provider calls, model time, degradation flags) and the
  *  inline `> ⚠ DEGRADED: <flag tokens>` callouts are redacted too; the DEGRADED marker and any prose
  *  note stay, since those are quality self-assessments raters legitimately read. */
@@ -132,7 +132,7 @@ export function blindIdeaV3Report(report, runId, caseDir) {
         .replace(/^(- Report ID:).*$/gm, '$1 [redacted]')
         .replace(/^(- Generated:).*$/gm, '$1 [redacted]')
         .replace(/^(- Models and roles:).*$/gm, '$1 [redacted]')
-        .replace(/^(- (?:Mode|Provider calls|Categories|By provider|Recorded model time|Degradation flags):).*$/gm, '$1 [redacted]')
+        .replace(/^(- (?:Mode|Provider calls|Categories|By provider|Recorded model time|Tokens|Degradation flags):).*$/gm, '$1 [redacted]')
         .replace(/^(> ⚠ DEGRADED): [a-z0-9_]+(?:, [a-z0-9_]+)*\.?$/gm, '$1 [redacted]');
 }
 async function renderCasePacket(item) {
@@ -384,6 +384,82 @@ function median(values) {
     const middle = Math.floor(sorted.length / 2);
     return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
 }
+function nearestRank(values, percentile) {
+    if (!values.length)
+        return 0;
+    const sorted = [...values].sort((left, right) => left - right);
+    return sorted[Math.ceil(percentile * sorted.length) - 1];
+}
+/** Phase F additive metric: adjudicated matched expert claims per 1,000 recorded input+output tokens. */
+export function ideaV3TokenEfficiency(scored, campaign) {
+    scored = IdeaV3ScoredCampaign.parse(scored);
+    campaign = IdeaV3Campaign.parse(campaign);
+    return campaign.arms.map((arm) => {
+        const observations = campaign.observations.filter((item) => item.arm === arm);
+        const complete = observations.length > 0 && observations.every((item) => item.usage !== undefined);
+        const tokens = complete
+            ? observations.reduce((sum, item) => sum + item.usage.inputTokens + item.usage.outputTokens, 0)
+            : null;
+        const matched = scored.summary.find((item) => item.arm === arm)?.score.matched ?? 0;
+        return {
+            arm,
+            matched,
+            tokens,
+            matched_per_1k_tokens: tokens ? matched * 1_000 / tokens : null,
+            estimated_calls: observations.reduce((sum, item) => sum + (item.usage?.estimatedCalls ?? 0), 0),
+        };
+    });
+}
+/** Phase F build-only product targets. Original frozen holdout ship gates remain separate. */
+export function evaluateIdeaV3AdaptiveGates(scored, campaign) {
+    scored = IdeaV3ScoredCampaign.parse(scored);
+    campaign = IdeaV3Campaign.parse(campaign);
+    if (scored.set !== 'build' || campaign.set !== 'build') {
+        throw new Error('adaptive product targets require the Phase F build campaign');
+    }
+    const required = ['A', 'B', 'B2', 'D2', 'R'];
+    const caseIds = new Set(campaign.observations.filter((item) => item.arm === 'A').map((item) => item.case_id));
+    const expectedPairs = [...caseIds].flatMap((caseId) => required.map((arm) => `${caseId}:${arm}`));
+    const observedPairs = campaign.observations.filter((item) => required.includes(item.arm));
+    const scoredPairs = new Set(scored.reports.map((item) => `${item.case_id}:${item.arm}`));
+    const matrixComplete = caseIds.size > 0
+        && observedPairs.length === expectedPairs.length
+        && expectedPairs.every((pair) => observedPairs.some((item) => `${item.case_id}:${item.arm}` === pair) && scoredPairs.has(pair))
+        && required.every((arm) => scored.summary.some((item) => item.arm === arm));
+    const score = (arm) => scored.summary.find((item) => item.arm === arm)?.score.f1;
+    const a = score('A'), b = score('B'), d2 = score('D2'), r = score('R');
+    const aObservations = campaign.observations.filter((item) => item.arm === 'A');
+    const rObservations = campaign.observations.filter((item) => item.arm === 'R');
+    const usageComplete = aObservations.length > 0 && rObservations.length > 0
+        && [...aObservations, ...rObservations].every((item) => item.usage !== undefined);
+    const perCaseTokens = (items) => items.map((item) => item.usage.inputTokens + item.usage.outputTokens);
+    const aMedianTokens = usageComplete ? median(perCaseTokens(aObservations)) : null;
+    const rMedianTokens = usageComplete ? median(perCaseTokens(rObservations)) : null;
+    const tokenReduction = aMedianTokens !== null && rMedianTokens
+        ? 1 - aMedianTokens / rMedianTokens
+        : null;
+    const aMedianCalls = median(aObservations.map((item) => item.calls));
+    const aP95Calls = nearestRank(aObservations.map((item) => item.calls), 0.95);
+    const gates = {
+        matrix_complete: matrixComplete,
+        usage_complete: usageComplete,
+        primary_vs_b: a !== undefined && b !== undefined && a > b,
+        quality_floor_d2: a !== undefined && d2 !== undefined && a >= d2 - 0.05,
+        quality_floor_r: a !== undefined && r !== undefined && a >= r - 0.05,
+        token_savings: tokenReduction !== null && tokenReduction >= 0.4,
+        calls_median: aObservations.length > 0 && aMedianCalls <= 3,
+        calls_p95: aObservations.length > 0 && aP95Calls <= 6,
+    };
+    return {
+        ...gates,
+        pass: Object.values(gates).every(Boolean),
+        a_median_calls: aMedianCalls,
+        a_p95_calls: aP95Calls,
+        a_median_tokens: aMedianTokens,
+        r_median_tokens: rMedianTokens,
+        token_reduction: tokenReduction,
+    };
+}
 /** Pure frozen ship-gate calculation. Secondary wins cannot rescue either primary F1 loss. */
 export function evaluateIdeaV3Gates(scored, campaign) {
     scored = IdeaV3ScoredCampaign.parse(scored);
@@ -441,6 +517,75 @@ export function evaluateIdeaV3Gates(scored, campaign) {
         holdout_cases: cases.size,
     };
 }
+/** Publish Phase F build validation without turning it into a frozen holdout claim. */
+export async function writeIdeaV3AdaptiveResults(opts) {
+    const root = opts.root ?? process.cwd();
+    const scoredPath = resolve(opts.scoredPath);
+    const scored = IdeaV3ScoredCampaign.parse(JSON.parse(await readFile(scoredPath, 'utf8')));
+    const campaignPath = resolveFrom(dirname(scoredPath), scored.campaign);
+    const campaign = IdeaV3Campaign.parse(JSON.parse(await readFile(campaignPath, 'utf8')));
+    const gates = evaluateIdeaV3AdaptiveGates(scored, campaign);
+    const efficiency = ideaV3TokenEfficiency(scored, campaign);
+    const summary = new Map(scored.summary.map((item) => [item.arm, item.score]));
+    const rows = [
+        ['Complete scored A/B/B2/D2/R matrix', gates.matrix_complete, gates.matrix_complete ? 'complete' : 'missing or duplicate pairs'],
+        ['A/R token usage complete', gates.usage_complete, gates.usage_complete ? 'complete' : 'usage missing'],
+        ['A strictly beats B on F1', gates.primary_vs_b, `${summary.get('A')?.f1.toFixed(3)} vs ${summary.get('B')?.f1.toFixed(3)}`],
+        ['A within 0.05 F1 of D2', gates.quality_floor_d2, `${summary.get('A')?.f1.toFixed(3)} vs ${summary.get('D2')?.f1.toFixed(3)}`],
+        ['A within 0.05 F1 of R', gates.quality_floor_r, `${summary.get('A')?.f1.toFixed(3)} vs ${summary.get('R')?.f1.toFixed(3)}`],
+        ['A median tokens ≥40% below R', gates.token_savings, gates.token_reduction === null ? 'usage missing' : pct(gates.token_reduction)],
+        ['A median calls ≤3', gates.calls_median, gates.a_median_calls.toFixed(1)],
+        ['A p95 calls ≤6', gates.calls_p95, gates.a_p95_calls.toFixed(0)],
+    ];
+    const lines = [
+        '# RESULTS-IDEA-V3-ADAPTIVE — Phase F build validation',
+        '',
+        `**Adaptive build targets: ${gates.pass ? 'PASS' : 'FAIL'}**`,
+        '',
+        'Build-set product validation; not a frozen holdout claim.',
+        '',
+        '## Product targets',
+        '',
+        '| Target | Result | Evidence |',
+        '|---|---|---|',
+        ...rows.map(([name, pass, evidence]) => `| ${name} | ${pass ? 'PASS' : 'FAIL'} | ${evidence} |`),
+        '',
+        '## Primary metric',
+        '',
+        '| Arm | Matched | Recall | Precision | F1 |',
+        '|---|---:|---:|---:|---:|',
+        ...campaign.arms.map((arm) => {
+            const item = summary.get(arm);
+            return `| ${arm} | ${item.matched} | ${pct(item.recall)} | ${pct(item.precision)} | ${item.f1.toFixed(3)} |`;
+        }),
+        '',
+        '## Verified insights per 1,000 tokens',
+        '',
+        '| Arm | Matched | Tokens | Matched / 1k tokens | Estimated calls |',
+        '|---|---:|---:|---:|---:|',
+        ...efficiency.map((item) => `| ${item.arm} | ${item.matched} | ${item.tokens ?? 'missing'} | ${item.matched_per_1k_tokens?.toFixed(3) ?? 'missing'} | ${item.estimated_calls} |`),
+        '',
+        '## Every case and arm',
+        '',
+        '| Case | Arm | Status | Calls | Tokens | Repairs | Wall time | Flags / failure |',
+        '|---|---|---|---:|---:|---:|---:|---|',
+        ...[...campaign.observations]
+            .sort((left, right) => left.case_id.localeCompare(right.case_id) || left.arm.localeCompare(right.arm))
+            .map((item) => {
+            const tokens = item.usage ? item.usage.inputTokens + item.usage.outputTokens : 'missing';
+            const detail = item.status === 'error' ? item.error : item.flags.join(', ') || 'none';
+            return `| ${item.case_id} | ${item.arm} | ${item.status} | ${item.calls} | ${tokens} | ${item.repair_calls} | ${(item.latency_ms / 1000).toFixed(1)}s | ${mdCell(detail)} |`;
+        }),
+        '',
+        `Token values include input plus output. ${efficiency.some((item) => item.estimated_calls > 0) ? 'At least one call uses Phase A labeled estimation.' : 'All recorded calls use provider-reported totals.'}`,
+        '',
+    ];
+    const path = opts.outPath ?? join(root, 'RESULTS-IDEA-V3-ADAPTIVE.md');
+    const tmp = `${path}.tmp`;
+    await writeFile(tmp, lines.join('\n'), 'utf8');
+    await rename(tmp, path);
+    return { path, gates };
+}
 function mdCell(value) {
     return value.replaceAll('|', '\\|').replaceAll('\n', ' ');
 }
@@ -511,6 +656,16 @@ export async function writeIdeaV3Results(opts) {
     await rename(tmp, path);
     return { path, gates };
 }
+/** CLI publication dispatch: build amendments and frozen holdout results stay visibly separate. */
+export async function publishIdeaV3Results(opts) {
+    const scored = IdeaV3ScoredCampaign.parse(JSON.parse(await readFile(resolve(opts.scoredPath), 'utf8')));
+    if (scored.set === 'build') {
+        const result = await writeIdeaV3AdaptiveResults(opts);
+        return { path: result.path, passed: result.gates.pass, label: 'adaptive build targets' };
+    }
+    const result = await writeIdeaV3Results(opts);
+    return { path: result.path, passed: result.gates.ship, label: 'frozen ship gate' };
+}
 export const IdeaV3ProtocolDraft = z.object({
     build_scores: z.string().min(1),
     baseline_provider: z.enum(['claude', 'codex', 'agy']),
@@ -523,7 +678,7 @@ export const IdeaV3ProtocolDraft = z.object({
     }).strict(),
     lane_assignment: z.enum(['agy-market', 'codex-market']),
 }).strict();
-/** Freeze only a complete, already-scored B/C/D2/R build campaign; the file is one-shot. */
+/** Freeze only the original complete, already-scored B/C/D2/R build campaign; the file is one-shot. */
 export async function writeFrozenIdeaV3Protocol(opts) {
     const root = opts.root ?? process.cwd();
     const draftPath = resolve(opts.draftPath);
@@ -539,7 +694,7 @@ export async function writeFrozenIdeaV3Protocol(opts) {
     if (campaign.baseline_provider !== draft.baseline_provider) {
         throw new Error(`draft baseline ${draft.baseline_provider} does not match campaign ${campaign.baseline_provider}`);
     }
-    const arms = [...IDEA_V3_ARM_IDS];
+    const arms = ['B', 'C', 'D2', 'R'];
     if (arms.some((arm) => !campaign.arms.includes(arm) || !scored.summary.some((item) => item.arm === arm))) {
         throw new Error('protocol freeze requires scored B, C, D2, and R build arms');
     }

package/dist/cli/bench.js

@@ -6,7 +6,7 @@ import { planBench, renderTable, runBench } from '../bench/harness.js';
 import { setupProviders } from '../orchestration/context.js';
 import { chooseLaneDefault, importLaneAdjudications, planIdeaLaneBench, runIdeaLaneBench } from '../bench/idea-lane-rotation.js';
 import { IDEA_V3_ARM_IDS, planIdeaV3Bench, runIdeaV3Bench } from '../bench/idea-v3-bench.js';
-import { exportIdeaV3BlindBundle, importIdeaV3Ratings, writeFrozenIdeaV3Protocol, writeIdeaV3Results } from '../bench/idea-v3-rating.js';
+import { exportIdeaV3BlindBundle, importIdeaV3Ratings, publishIdeaV3Results, writeFrozenIdeaV3Protocol } from '../bench/idea-v3-rating.js';
 import { DISPLAY_NAME } from '../providers/types.js';
 const VALID_ARMS = ['A', 'B', 'C', 'D', 'E', 'L'];
 /** One-block pre-run summary: what will run + the ≈Opus cost, so the user commits knowingly (§19). */
@@ -34,9 +34,9 @@ export async function benchCommand(workflow, opts = {}) {
         }
         if (opts.publishResults) {
             try {
-                const result = await writeIdeaV3Results({ scoredPath: opts.publishResults });
+                const result = await publishIdeaV3Results({ scoredPath: opts.publishResults });
                 process.stdout.write(`\nresults: ${result.path}\n`);
-                process.stdout.write(`frozen ship gate: ${result.gates.ship ? 'PASS' : 'FAIL'}\n\n`);
+                process.stdout.write(`${result.label}: ${result.passed ? 'PASS' : 'FAIL'}\n\n`);
                 return 0;
             }
             catch (error) {
@@ -82,7 +82,7 @@ export async function benchCommand(workflow, opts = {}) {
             : set === 'build' ? ['B', 'C', 'D2', 'R'] : ['B', 'C', 'R'];
         const invalid = requested.filter((arm) => !IDEA_V3_ARM_IDS.includes(arm));
         if (invalid.length) {
-            process.stderr.write(`invalid idea-v3 arm(s): ${invalid.join(', ')}. Valid: B,C,D2,R\n`);
+            process.stderr.write(`invalid idea-v3 arm(s): ${invalid.join(', ')}. Valid: A,B,B2,C,D2,R\n`);
             return 1;
         }
         const arms = requested;
@@ -100,7 +100,7 @@ export async function benchCommand(workflow, opts = {}) {
             return 1;
         }
         process.stdout.write(`\nidea-v3 protocol comparison — ${set} — ${plan.cases.length} case(s) × arms ${arms.join(',')}\n`);
-        process.stdout.write(`B/C baseline provider: ${DISPLAY_NAME[provider]}\n`);
+        process.stdout.write(`B/B2/C baseline provider: ${DISPLAY_NAME[provider]}\n`);
         if (plan.resumedFrom)
             process.stdout.write(`resume: continuing ${plan.resumedFrom} — ${plan.skipCompleted} recorded pair(s) kept\n`);
         process.stdout.write(`to run: ${plan.toRun.length} case×arm pair(s) → ≤${plan.estimatedProviderCalls} nominal provider call(s)\n`);

package/dist/cli/index.js

@@ -12,6 +12,7 @@ import { sessionsCommand } from './sessions.js';
 import { config } from './config.js';
 import { modelsCommand } from './models.js';
 import { benchCommand } from './bench.js';
+import { serveCommand } from './serve.js';
 import { VERSION } from './version.js';
 import { ConfigError, loadLayeredConfig } from '../config/config.js';
 import { resolveRunsRoot } from '../storage/paths.js';
@@ -51,7 +52,8 @@ program
     .option('--head <ref>', 'code-review: head git ref to diff to (default HEAD)')
     .option('--diff <file>', 'code-review: review a patch file instead of computing a git diff')
     .option('--evidence <path>', 'idea-refinement: local source file/directory (stores paths + hashes, not copies)')
-    .option('--mode <mode>', 'idea-refinement: quick | council | research (default council; explicit research wording selects research)')
+    .option('--mode <mode>', 'idea-refinement: quick | council | auto (research is an alias for council)')
+    .option('--allow-blocked-sources', 'idea-refinement: proceed even when a supplied URL cannot be read (default: stop and ask)')
     .option('--cheap', 'code-review: Gemini+Codex review, Claude judges only disputes (~⅓ the Opus; experimental)')
     .option('--yes', 'skip the run-cost confirmation prompt')
     .action(async (workflow, input, opts) => {
@@ -93,7 +95,7 @@ program
     .command('bench')
     .description('Run code-review, idea lane, or frozen idea-v3 benchmark arms; writes bench/results/*.json.')
     .argument('<workflow>', 'code-review | idea-refinement | idea-v3')
-    .option('--arms <list>', 'comma-separated arms to run (code review defaults A,B,C,D; idea-v3 defaults B,C,D2,R on build)')
+    .option('--arms <list>', 'comma-separated arms to run (code review defaults A,B,C,D; idea-v3 defaults B,C,D2,R; Phase F adds explicit A,B2)')
     .option('--set <name>', 'task set: build | holdout', 'build')
     .option('--resume', 'continue the latest results file: keep already-scored case×arm pairs, retry the rest')
     .option('--yes', 'actually run; without it, print the pre-run Opus-call estimate and exit')
@@ -123,6 +125,14 @@ program
         campaign: opts.campaign,
     }));
 });
+program
+    .command('serve')
+    .description('Open the chat workspace in the browser (localhost only; no paid calls until you convene a run).')
+    .option('--port <n>', 'port to bind (default: first free in 4173–4183)', (v) => parseInt(v, 10))
+    .option('--no-open', 'do not open the browser automatically')
+    .action(async (opts) => {
+    process.exit(await serveCommand({ port: opts.port, open: opts.open }));
+});
 program
     .command('models')
     .description('Show configurable models per provider (lists via the CLI where supported) + your current pins.')

package/dist/cli/resume.js

@@ -9,6 +9,7 @@ import { resolveRunsRoot } from '../storage/paths.js';
 import { buildReplayCache } from '../storage/replay.js';
 import { findSession } from '../storage/sessions.js';
 import { readJsonArtifact, resolveRunId, runDir } from '../storage/runs-read.js';
+import { UrlSourceSet } from '../schemas/index.js';
 import { EvidencePack } from '../orchestration/evidence-pack.js';
 export async function resumeCommand(runArg, opts = {}) {
     if (!runArg) {
@@ -72,6 +73,22 @@ export async function resumeCommand(runArg, opts = {}) {
         }
         evidencePack = parsed.data;
     }
+    // v6 T10: the URL snapshot + the user's proceed-past-blocked decision are run inputs, like
+    // inputs/idea.md and evidence-pack.json. Reusing the ORIGINAL snapshot keeps every prompt that
+    // embeds it byte-identical (replay cache hits, no refetch); and a non-empty replay cache proves
+    // the old run cleared the S0 gate, so a blocked source in the snapshot means consent was given
+    // (interactive `y` or --allow-blocked-sources) — restore that decision instead of re-asking.
+    // (Real failure: resume c46e of 626e died SOURCE_UNREADABLE re-gating a consented run.)
+    let urlSources;
+    const savedUrlSources = await readJsonArtifact(oldDir, '00a-url-sources.json');
+    if (savedUrlSources) {
+        const parsedSources = UrlSourceSet.safeParse(savedUrlSources);
+        if (!parsedSources.success) {
+            process.stderr.write(`cannot validate 00a-url-sources.json for ${oldId} — nothing to resume.\n`);
+            return 1;
+        }
+        urlSources = parsedSources.data;
+    }
     const replay = await buildReplayCache(oldDir);
     if (replay.size === 0) {
         process.stderr.write(`no completed calls found for ${oldId} — start a fresh run instead.\n`);
@@ -100,6 +117,9 @@ export async function resumeCommand(runArg, opts = {}) {
         resumedFrom: oldId,
         providerModels: cfg.models,
         evidencePack,
+        urlSources,
+        allowBlockedSources: urlSources?.sources.some((s) => s.status !== 'FETCHED') ?? false,
+        autoDecision: previousMeta.auto_decision,
     });
     if (outcome.ok) {
         process.stdout.write(`\n  ✔ resumed run ${outcome.runId} complete — ${outcome.callCount} new provider call(s)\n  artifacts: ${outcome.dir}\n\n`);

package/dist/cli/run.js

@@ -3,6 +3,9 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
+import { blockedSourceStop, extractPublicUrls, snapshotUrlSources } from '../orchestration/url-sources.js';
+import { buildTaskProfile, resolveAutoMode } from '../orchestration/auto-profile.js';
+import { requestedOutputsFor } from '../orchestration/preflight.js';
 import { renderTerminalSummary } from '../orchestration/stages/s10-render.js';
 import { run as runEngine } from '../orchestration/engine.js';
 import { ConfigError, loadLayeredConfig } from '../config/config.js';
@@ -16,12 +19,16 @@ const WORKFLOWS = ['idea-refinement', 'code-review'];
 export function estimateRun(workflow, opts = {}) {
     if (workflow === 'code-review')
         return { calls: 5, opus: opts.cheap ? 1 : 2 };
+    if (opts.auto)
+        return { calls: 4, opus: 1, minCalls: opts.fastPath ? 1 : 3, reserved: 0 };
+    if (opts.fastPath)
+        return { calls: 1, opus: 1, minCalls: 1, reserved: 0 };
     const mode = opts.mode ?? 'council';
     const plan = IDEA_MODE_PLANS[mode];
     return {
         calls: plan.maxCalls,
         opus: mode === 'quick' ? 1 : 2,
-        minCalls: mode === 'research' ? 8 : plan.baseCalls,
+        minCalls: plan.maxCalls - plan.reservedCalls,
         reserved: plan.reservedCalls,
     };
 }
@@ -35,6 +42,19 @@ function confirm(question) {
         });
     });
 }
+/** One question, one trimmed answer. Resolve BEFORE close — closing fires the EOF handler, and
+ *  the live "typed Y, got cancelled" bug was that handler resolving '' first. EOF alone (Ctrl+D)
+ *  still resolves '' = the safe deny default. Exported (with injectable streams) for the test. */
+export function ask(question, io = { input: process.stdin, output: process.stdout }) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: io.input, output: io.output });
+        rl.on('close', () => resolve(''));
+        rl.question(question, (a) => {
+            resolve(a.trim());
+            rl.close();
+        });
+    });
+}
 /** Resolve an idea-refinement input: an existing file path → its contents, else the arg as inline text. */
 async function resolveInput(arg) {
     if (!arg)
@@ -90,11 +110,15 @@ export async function runCommand(workflow, input, opts = {}) {
         return 1;
     }
     let mode;
+    let autoRequested = false; // v7 Phase B: `--mode auto` → resolved to quick|council once inputs are known
     if (workflow === 'idea-refinement') {
-        if (opts.mode !== undefined) {
+        if (opts.mode === 'auto') {
+            autoRequested = true;
+        }
+        else if (opts.mode !== undefined) {
             const parsed = IdeaModeSchema.safeParse(opts.mode);
             if (!parsed.success) {
-                process.stderr.write(`unknown idea mode "${opts.mode}". Available: quick, council, research\n`);
+                process.stderr.write(`unknown idea mode "${opts.mode}". Available: quick, council, research, auto\n`);
                 return 1;
             }
             mode = parsed.data;
@@ -120,7 +144,8 @@ export async function runCommand(workflow, input, opts = {}) {
             return 1;
         }
         text = resolved;
-        mode ??= inferIdeaMode(text);
+        if (!autoRequested)
+            mode ??= inferIdeaMode(text);
     }
     if (opts.evidence) {
         if (workflow !== 'idea-refinement') {
@@ -135,6 +160,19 @@ export async function runCommand(workflow, input, opts = {}) {
             return 1;
         }
     }
+    // v7 Phase B: resolve `--mode auto` here, before any RunCtx/engine work, so meta.mode stays quick|council
+    // and the estimate below reflects the resolved mode. urlCount is fetch-free (extract only, no snapshot).
+    let autoDecision;
+    if (autoRequested) {
+        const resolved = resolveAutoMode(buildTaskProfile(text, {
+            urlCount: extractPublicUrls(text).length,
+            hasEvidencePack: !!evidencePack,
+            requestedOutputs: requestedOutputsFor(text),
+        }));
+        mode = resolved.mode;
+        autoDecision = { resolved: resolved.mode, reasons: resolved.reasons, ...(resolved.fastPath ? { fast_path: true } : {}) };
+        process.stdout.write(`  auto → ${resolved.mode}: ${resolved.reasons.join(', ')}.\n`);
+    }
     // Precedence (§10/T9): --budget flag > config.budget > built-in default. roles/deadline/models are
     // config-only (layered: global ~/.aiki base, project .aiki override).
     let cfg;
@@ -158,7 +196,7 @@ export async function runCommand(workflow, input, opts = {}) {
             process.stderr.write('--cheap only applies to code-review; ignoring for this workflow.\n');
     }
     // Run-cost preview (V5): show the estimate; confirm interactively unless --yes or non-interactive.
-    const est = estimateRun(workflow, { cheap: opts.cheap, mode });
+    const est = estimateRun(workflow, { cheap: opts.cheap, mode, auto: !!autoDecision, fastPath: autoDecision?.fast_path });
     const callEstimate = est.minCalls !== undefined && est.minCalls !== est.calls ? `${est.minCalls}–${est.calls}` : `${est.calls}`;
     const resolvedBudget = opts.budget ?? cfg.budget ?? defaultBudgetFor(workflow, mode);
     const reservation = est.reserved ? `; ${est.reserved} call(s) reserved for chair + planner` : '';
@@ -173,6 +211,36 @@ export async function runCommand(workflow, input, opts = {}) {
     else {
         process.stdout.write(`${note}\n`);
     }
+    // v6 T10b: check supplied URLs BEFORE any provider spend. A blocked source in a TTY gets a
+    // simple permission prompt — Y allow, anything else deny. Headless keeps the fail-fast gate.
+    let allowBlockedSources = opts.allowBlockedSources ?? false;
+    let urlSources;
+    if (workflow === 'idea-refinement') {
+        urlSources = await snapshotUrlSources(text);
+        const stopMessage = blockedSourceStop(urlSources, mode ?? 'council', allowBlockedSources);
+        if (stopMessage && process.stdin.isTTY && process.stdout.isTTY) {
+            const unreadable = urlSources.sources.filter((item) => item.status !== 'FETCHED');
+            const noun = unreadable.length > 1 ? 'these pages' : 'this page';
+            for (const source of unreadable) {
+                process.stdout.write(`\n  ⚠ Couldn't read a page you attached:\n    ${source.url}\n    reason: ${source.error ?? source.status}\n`);
+            }
+            process.stdout.write(`\n  Do you want to run without ${noun}?\n`);
+            process.stdout.write(`    y = yes, run anyway (facts from ${noun} will be marked unverified)\n`);
+            process.stdout.write('    n = no, cancel — paste the page text into your prompt and rerun\n\n');
+            const answer = await ask('  Choice [y/N]: ');
+            if (/^y/i.test(answer)) {
+                allowBlockedSources = true;
+            }
+            else {
+                process.stdout.write('\n  Cancelled. Paste the page text into your prompt and rerun, or rerun with --allow-blocked-sources.\n');
+                return 0;
+            }
+        }
+        else if (stopMessage) {
+            process.stderr.write(`  ✖ ${stopMessage}\n`);
+            return 1;
+        }
+    }
     const outcome = await runEngine(workflow, text, {
         mode,
         budget: resolvedBudget,
@@ -182,6 +250,9 @@ export async function runCommand(workflow, input, opts = {}) {
         runsRoot: await resolveRunsRoot(), // hybrid: repo .aiki when in a repo, else ~/.aiki
         providerModels: cfg.models, // V8: per-provider model → CLI --model
         evidencePack,
+        allowBlockedSources,
+        urlSources,
+        autoDecision,
     });
     if (outcome.ok) {
         process.stdout.write(`\n  ✔ run ${outcome.runId} complete — ${outcome.callCount} provider call(s)\n  artifacts: ${outcome.dir}\n\n`);

package/dist/cli/serve.js

@@ -0,0 +1,48 @@
+// `aiki serve` — open the chat workspace on localhost. Resolves the built serve-ui assets, builds a
+// FlightDeck over the hybrid runs root, starts the server, and (unless --no-open) opens the browser.
+// The process stays up until Ctrl+C; there are no paid calls until the user convenes a run in the UI.
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { FlightDeck } from '../serve/flight-deck.js';
+import { startServer } from '../serve/server.js';
+import { openInBrowser } from '../council/open.js';
+import { resolveRunsRoot } from '../storage/paths.js';
+import { VERSION } from './version.js';
+/** Locate the serve-ui assets: dist/serve-ui next to this module (built), else repo-root serve-ui (dev). */
+function resolveStaticDir() {
+    const here = dirname(fileURLToPath(import.meta.url)); // dist/cli
+    const built = join(here, '..', 'serve-ui'); // dist/serve-ui
+    if (existsSync(join(built, 'index.html')))
+        return built;
+    return join(here, '..', '..', 'serve-ui'); // repo-root serve-ui (running from src)
+}
+export async function serveCommand(opts = {}) {
+    const runsRoot = await resolveRunsRoot();
+    const log = (line) => {
+        const time = new Date().toLocaleTimeString('en-US', { hour12: false });
+        process.stdout.write(`  \x1b[2m${time}\x1b[0m  ${line}\n`);
+    };
+    const flightDeck = new FlightDeck({ runsRoot, version: VERSION, log });
+    const staticDir = resolveStaticDir();
+    let server;
+    try {
+        server = await startServer({ flightDeck, staticDir, port: opts.port });
+    }
+    catch (e) {
+        process.stderr.write(`aiki serve: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 1;
+    }
+    const url = `http://127.0.0.1:${server.port}`;
+    process.stdout.write(`\n  aiki workspace → ${url}\n  (Ctrl+C to stop)\n\n`);
+    if (opts.open !== false)
+        openInBrowser(url);
+    await new Promise((resolve) => {
+        const shutdown = () => {
+            server.close().finally(() => resolve());
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    });
+    return 0;
+}

package/dist/config/config.js

@@ -22,6 +22,7 @@ const ConfigRoles = z
     judge: ProviderIdSchema.optional(),
     verifier: ProviderIdSchema.optional(),
     s4: z.array(ProviderIdSchema).min(1).optional(),
+    responder: ProviderIdSchema.optional(),
 })
     .strict();
 /** Per-provider model override (V8). Each CLI runs its own model families, so model choice is per
@@ -96,7 +97,11 @@ export function mergeConfig(base, over) {
 }
 /** Layered config: global `~/.aiki/config.json` (base) overlaid by the project `.aiki/config.json`. What
  *  the CLI actually uses (V8) — a user can set defaults once in the global file and override per project. */
-export async function loadLayeredConfig() {
-    const [global, project] = await Promise.all([loadConfig(homeAikiRoot()), loadConfig('.aiki')]);
+export async function loadLayeredConfig(projectRoot = '.aiki') {
+    const globalRoot = homeAikiRoot();
+    const global = await loadConfig(globalRoot);
+    if (projectRoot === globalRoot)
+        return global;
+    const project = await loadConfig(projectRoot);
     return mergeConfig(global, project);
 }