aiki-cli 0.3.2 → 0.3.5

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 is an alias for council)')
+    .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,6 +19,10 @@ 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 {
@@ -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);
 }

package/dist/council/view.js

@@ -3,6 +3,7 @@ import { basename, join } from 'node:path';
 import { DISPLAY_NAME } from '../providers/types.js';
 import { RoleOutput as RoleOutputSchema } from '../schemas/index.js';
 import { deriveAudit, deriveScorecard, mergeOpenQuestions } from '../orchestration/stages/s10-render.js';
+import { sanitizeLocalPaths } from '../orchestration/sanitize-paths.js';
 import { buildReaderProjection, claimLookup, readerClaimLabel, readerClaimRefs, renderDecisionDossierMarkdown, stripReaderClaimIds } from '../orchestration/decision-dossier.js';
 import { IDEA_RUBRIC } from '../workflows/idea-refinement.js';
 import { listArtifacts, readJsonArtifact } from '../storage/runs-read.js';
@@ -356,6 +357,12 @@ function dossierCoverageLabel(value) {
     return value >= 0.75 ? 'High' : value >= 0.5 ? 'Medium' : 'Low';
 }
 function dossierCouncilRead(report) {
+    if (report.fastPath)
+        return 'Single-pass analysis; council escalation was not required.';
+    if (report.adaptiveAuto)
+        return report.autoEscalationReasons?.length
+            ? `The primary analysis tripped structural gates; two task readings checked the interpretation${report.autoChallengeUsed ? ', and one targeted challenger checked eligible claims' : '; no challenger could add information'}. No full council was convened.`
+            : 'Two task readings informed one primary decision analyst. No full council was convened.';
     if (report.mode === 'quick')
         return 'One structured analyst produced this result; no council, consensus, or independent-verification claim is being made.';
     const scouts = report.models.filter((model) => model.roles.includes('scout')).length;
@@ -393,7 +400,7 @@ function renderDossierIdeaBody(report) {
     const decisiveNumbers = snapshot ? `<div class="decision-numbers">
       <span class="section-eyebrow">Decisive numbers</span>
       <div class="table-wrap"><table class="snapshot-table decisive-table"><thead><tr><th>Metric</th><th>Value</th><th>What it means</th></tr></thead><tbody>${snapshot.decisiveNumbers.map((item) => `<tr><td>${escapeHtml(item.label)}</td><td class="number-value">${escapeHtml(item.value)}</td><td>${escapeHtml(item.meaning)}</td></tr>`).join('')}</tbody></table></div>
-      ${snapshot.payback ? `<div class="payback-result"><span>Payback · ${escapeHtml(snapshot.payback.status.replaceAll('_', ' '))}</span><strong>${escapeHtml(snapshot.payback.result)}</strong><p>${escapeHtml(snapshot.payback.basis)}</p></div>` : ''}
+      ${snapshot.payback && snapshot.payback.status !== 'NOT_COMPUTABLE' ? `<div class="payback-result"><span>Payback · ${escapeHtml(snapshot.payback.status.replaceAll('_', ' '))}</span><strong>${escapeHtml(snapshot.payback.result)}</strong><p>${escapeHtml(snapshot.payback.basis)}</p></div>` : ''}
     </div>` : '';
     const optionComparison = snapshot ? `<div class="option-comparison">
       <span class="section-eyebrow">Options at a glance</span>
@@ -469,6 +476,7 @@ function renderDossierIdeaBody(report) {
     const contributions = `${dossierWarning(report, ['verification_skipped', 'single_model', 'low_diversity'])}<p class="lede">Only unique claims that survived independent verification receive credit.</p>${dossierTable(['Provider', 'Verified unique contributions', 'Count'], dossier.contributions.map((item) => [item.name, readerClaimRefs(report, item.verifiedUniqueClaimIds), String(item.verifiedUniqueClaimIds.length)]))}`;
     const receipt = `<div class="receipt">
     <span>mode ${escapeHtml(report.mode)}</span><span>${report.receipt.calls}/${report.receipt.budget} provider calls</span>
+    ${report.autoEscalationReasons?.length ? `<span>adaptive escalation ${escapeHtml(report.autoEscalationReasons.join('; '))}</span>` : ''}
     <span>discovery ${report.receipt.categories.discovery}</span><span>verification ${report.receipt.categories.verification}</span>
     <span>repair ${report.receipt.categories.repair}</span><span>planning ${report.receipt.categories.planning}</span>
     <span>by provider ${escapeHtml(Object.entries(report.receipt.byProvider).map(([provider, count]) => `${providerName(provider)} ${count}`).join(', ') || 'none')}</span>
@@ -522,7 +530,7 @@ function renderReaderBriefIdeaBody(report) {
     const warnings = projection.warnings.length || projection.notices.length
         ? `<div class="warns">${projection.warnings.map((warning) => `<span class="warn">⚑ ${escapeHtml(warning.message)}</span>`).join('')}${projection.notices.map((notice) => `<span class="warn">ⓘ ${escapeHtml(notice.message)}</span>`).join('')}</div>`
         : '';
-    const snapshot = projection.snapshot ? section('', 'Decision numbers', `${dossierTable(['Metric', 'Value', 'What it means'], projection.snapshot.decisiveNumbers.map((item) => [item.label, item.value, item.meaning]))}${projection.snapshot.payback ? `<div class="action-callout"><span>Payback · ${escapeHtml(projection.snapshot.payback.status.replaceAll('_', ' '))}</span><p>${escapeHtml(projection.snapshot.payback.result)} — ${escapeHtml(projection.snapshot.payback.basis)}</p></div>` : ''}<h3>Options at a glance</h3>${dossierTable(['Path', 'Commitment', 'Basis', 'Trade-off'], projection.snapshot.options.map((item) => [item.label, item.commitment, item.commitmentKind.replace('_', ' '), item.tradeoff]))}${projection.snapshot.tripwire ? `<div class="action-callout"><span>Go/no-go tripwire</span><p><strong>${escapeHtml(projection.snapshot.tripwire.metric)}: ${escapeHtml(projection.snapshot.tripwire.threshold)}</strong> — ${escapeHtml(projection.snapshot.tripwire.decisionRule)}</p></div>` : ''}`, 80) : '';
+    const snapshot = projection.snapshot ? section('', 'Decision numbers', `${dossierTable(['Metric', 'Value', 'What it means'], projection.snapshot.decisiveNumbers.map((item) => [item.label, item.value, item.meaning]))}${projection.snapshot.payback && projection.snapshot.payback.status !== 'NOT_COMPUTABLE' ? `<div class="action-callout"><span>Payback · ${escapeHtml(projection.snapshot.payback.status.replaceAll('_', ' '))}</span><p>${escapeHtml(projection.snapshot.payback.result)} — ${escapeHtml(projection.snapshot.payback.basis)}</p></div>` : ''}<h3>Options at a glance</h3>${dossierTable(['Path', 'Commitment', 'Basis', 'Trade-off'], projection.snapshot.options.map((item) => [item.label, item.commitment, item.commitmentKind.replace('_', ' '), item.tradeoff]))}${projection.snapshot.tripwire ? `<div class="action-callout"><span>Go/no-go tripwire</span><p><strong>${escapeHtml(projection.snapshot.tripwire.metric)}: ${escapeHtml(projection.snapshot.tripwire.threshold)}</strong> — ${escapeHtml(projection.snapshot.tripwire.decisionRule)}</p></div>` : ''}`, 80) : '';
     const editorial = projection.sections.map((item, index) => section(String(index + 1).padStart(2, '0'), item.heading, `<p class="lede">${escapeHtml(item.summary)}</p>${item.bullets.length
         ? `<ul class="reasons">${item.bullets.map((bullet) => `<li>${escapeHtml(bullet)}</li>`).join('')}</ul>`
         : ''}`, 100 + index * 40)).join('');
@@ -947,7 +955,8 @@ export function renderCouncilHtml(view) {
         : quick ? renderQuickIdeaBody(view) : isIdea ? renderIdeaBody(view) : renderReviewBody(view);
     // Embed the report as Markdown for the Copy button. Escape "<" so a "</script>" in content can't break out.
     const md = JSON.stringify(councilMarkdown(view)).replace(/</g, '\\u003c');
-    return `<!doctype html>
+    // v6: the whole rendered page is path-sanitized — no local usernames in any artifact (T8).
+    return sanitizeLocalPaths(`<!doctype html>
 <html lang="en">
 <head>
 <meta charset="utf-8">
@@ -1230,7 +1239,7 @@ async function copyReport(btn){
 document.getElementById('copy-report').addEventListener('click',function(){ copyReport(this); });
 </script>
 </body>
-</html>`;
+</html>`);
 }
 export async function writeCouncilHtml(runId, dir) {
     const view = await loadCouncilView(runId, dir);

package/dist/orchestration/auto-profile.js

@@ -0,0 +1,97 @@
+// v7 Phase B — `--mode auto`: a deterministic quick-vs-council routing decision made in the CLI
+// BEFORE the engine runs. No model call, no learned routing (§22 forbids that). The rules err toward
+// council: a false council only costs more calls, a false quick under-scrutinizes a risky decision.
+// ponytail: v1 keyword heuristics, not NLP. Upgrade path = a scored intent matcher if precision matters.
+const SENSITIVE = /\b(?:regulat|complian|legal|lawsuit|licens|liabilit|hipaa|gdpr|pci|soc\s?2|financ|fintech|invest|tax(?:es|ation)?|loan|mortgage|insuran|securities|security|vulnerab|exploit|breach|malware|phishing|credential|medical|patient|clinical|diagnos)\w*/i;
+const RESEARCH = /\b(?:research|investigat|competitive analysis|market size|find (?:sources|evidence|data)|look up|up[- ]to[- ]date|latest data|current (?:data|figures|numbers|pricing)|cite sources?)\w*/i;
+// ponytail: v1 decision-question heuristic; upgrade path = the same scored matcher as SENSITIVE/RESEARCH.
+const DECISION_INTENT = /\b(?:should (?:i|we|you)|is it worth|worth (?:it|building|doing|switching|the)|do i (?:need|use)|(?:choose|pick|decide|select) (?:between|whether)|go with|switch(?:ing)? (?:to|from)|migrate (?:to|from)|which\b[^.?!]*\bor\b)/i;
+export function buildTaskProfile(input, opts) {
+    const wordCount = input.trim().split(/\s+/).filter(Boolean).length;
+    return {
+        wordCount,
+        urlCount: opts.urlCount,
+        hasEvidencePack: opts.hasEvidencePack,
+        deliverablesBeyondDecision: opts.requestedOutputs.some((o) => o !== 'DECISION'),
+        hasSensitiveKeyword: SENSITIVE.test(input),
+        hasResearchWording: RESEARCH.test(input),
+        hasDecisionIntent: wordCount >= 4 && DECISION_INTENT.test(input),
+    };
+}
+/** Ordered deterministic rules: council if ANY signal fires, else quick. `fastPath` (Phase C, quick-only)
+ *  is the 1-call single-pass path — eligible when quick AND the input reads as a direct decision question. */
+export function resolveAutoMode(profile) {
+    const reasons = [];
+    if (profile.urlCount > 0)
+        reasons.push('URLs supplied');
+    if (profile.hasEvidencePack)
+        reasons.push('evidence pack supplied');
+    if (profile.hasSensitiveKeyword)
+        reasons.push('regulated/financial/security topic');
+    if (profile.deliverablesBeyondDecision)
+        reasons.push('deliverables beyond a decision requested');
+    if (profile.hasResearchWording)
+        reasons.push('research wording detected');
+    if (profile.wordCount > 120)
+        reasons.push('long or complex input (>120 words)');
+    if (reasons.length > 0)
+        return { mode: 'council', reasons, fastPath: false };
+    return { mode: 'quick', reasons: ['plain single-decision prompt'], fastPath: profile.hasDecisionIntent };
+}
+function evidenceForClaim(graph, claimId) {
+    const ids = new Set(graph.edges
+        .filter((edge) => edge.to === claimId && (edge.type === 'SUPPORTS' || edge.type === 'ATTACKS'))
+        .map((edge) => edge.from));
+    return graph.evidence.filter((evidence) => ids.has(evidence.id));
+}
+/** Phase D hard gates over validated graph structure; ordered for stable receipts and fixtures. */
+export function structuralEscalationGates(graph) {
+    const gates = [];
+    const seen = new Set();
+    const add = (claimId, kind, reason) => {
+        const key = `${claimId}:${kind}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        gates.push({ claimId, kind, reason });
+    };
+    for (const claim of graph.claims) {
+        const evidence = evidenceForClaim(graph, claim.id);
+        if (claim.sensitivity === 'DECISIVE'
+            && !evidence.some((item) => item.source_kind === 'PRIMARY' || item.source_kind === 'SECONDARY')) {
+            add(claim.id, 'NO_INDEPENDENT_EVIDENCE', 'decisive claim has no independent evidence');
+        }
+    }
+    for (const claim of graph.claims) {
+        const evidence = evidenceForClaim(graph, claim.id);
+        if ((claim.if_false === 'STOP' || claim.if_false === 'PIVOT')
+            && evidence.length > 0
+            && evidence.every((item) => item.source_kind === 'MODEL_KNOWLEDGE')) {
+            add(claim.id, 'MODEL_KNOWLEDGE_DECISION', 'STOP/PIVOT claim rests on model knowledge');
+        }
+    }
+    for (const check of graph.calculation_checks) {
+        if (check.status === 'FAIL')
+            add(check.claim_id, 'FAILED_CALCULATION', 'deterministic calculation failed');
+    }
+    for (const claim of graph.claims) {
+        if (claim.load_bearing && evidenceForClaim(graph, claim.id)
+            .some((item) => item.source_kind === 'USER' && item.support === 'CONTRADICTS')) {
+            add(claim.id, 'SUPPLIED_SOURCE_CONTRADICTION', 'user-supplied evidence contradicts a load-bearing claim');
+        }
+    }
+    for (const claim of graph.claims) {
+        if (claim.load_bearing && claim.state === 'DISAGREEMENT') {
+            add(claim.id, 'LOAD_BEARING_DISAGREEMENT', 'load-bearing claims are mutually inconsistent');
+        }
+    }
+    return gates;
+}
+/** One challenge call is useful only when the stored graph contains something new to inspect. */
+export function canProduceNewInformation(graph, claimId) {
+    if (!graph.claims.some((claim) => claim.id === claimId))
+        return false;
+    return evidenceForClaim(graph, claimId).some((item) => item.source_kind !== 'MODEL_KNOWLEDGE')
+        || graph.calculation_checks.some((check) => check.claim_id === claimId && check.status === 'FAIL')
+        || graph.edges.some((edge) => edge.type === 'DEPENDS_ON' && (edge.from === claimId || edge.to === claimId));
+}

package/dist/orchestration/claim-groups.js

@@ -0,0 +1,56 @@
+// v6 semantic claim join (plan/AIKI-v6-council-integrity-plan.md T5). The lexical ≥0.8 grouping in
+// S7 cannot join cross-provider paraphrases, so "0 consensus · 0 disputes" was structural (run
+// f740: codex G3 and agy G13 both said "build `aiki serve`" and sat as two UNIQUE claims). S8 now
+// emits `claim_groups`; this module validates them deterministically and OVERLAYS states onto the
+// compiled graph — claim ids, propositions, edges, and stored artifacts are never mutated, and the
+// state itself is computed by the SAME `classifyClaimState` machine the lexical path uses.
+import { classifyClaimState } from './decision-graph.js';
+/** Drop anything the model got wrong: unknown claim ids, duplicate ids, and groups whose claims
+ *  all come from ONE provider — a model agreeing with itself is not consensus. */
+export function sanitizeClaimGroups(graph, groups) {
+    if (!groups?.length)
+        return [];
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    const claimById = new Map(graph.claims.map((claim) => [claim.id, claim]));
+    return groups.flatMap((group) => {
+        const ids = [...new Set(group.ids)].filter((id) => claimById.has(id));
+        if (ids.length < 2)
+            return [];
+        const providers = new Set(ids.flatMap((id) => claimById.get(id).position_ids.map((positionId) => positionById.get(positionId)?.provider)
+            .filter((provider) => provider !== undefined)));
+        if (providers.size < 2)
+            return [];
+        return [{ ids, relation: group.relation }];
+    });
+}
+/** Overlay group-derived states onto a copy of the graph. SAME → the union of the member claims'
+ *  positions is re-classified by the existing state machine (CONSENSUS/SHARED_CONCERN/…);
+ *  OPPOSES → DISAGREEMENT, which wins over any SAME assignment. Old artifacts (no groups) pass
+ *  through unchanged, so every pre-v6 run keeps its exact rendering. */
+export function overlayClaimGroups(graph, groups) {
+    const sane = sanitizeClaimGroups(graph, groups);
+    if (!sane.length)
+        return graph;
+    const positionById = new Map(graph.positions.map((position) => [position.id, position]));
+    const claimById = new Map(graph.claims.map((claim) => [claim.id, claim]));
+    const stateById = new Map();
+    for (const group of sane) {
+        if (group.relation === 'OPPOSES') {
+            for (const id of group.ids)
+                stateById.set(id, 'DISAGREEMENT');
+            continue;
+        }
+        const union = group.ids
+            .flatMap((id) => claimById.get(id).position_ids)
+            .map((id) => positionById.get(id))
+            .filter((position) => position !== undefined);
+        const state = classifyClaimState(union);
+        for (const id of group.ids)
+            if (stateById.get(id) !== 'DISAGREEMENT')
+                stateById.set(id, state);
+    }
+    return {
+        ...graph,
+        claims: graph.claims.map((claim) => (stateById.has(claim.id) ? { ...claim, state: stateById.get(claim.id) } : claim)),
+    };
+}