aiki-cli 0.3.1 → 0.3.3

package/dist/council/view.js

@@ -3,7 +3,8 @@ 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 { readerClaimLabel, readerClaimRefs, renderDecisionDossierMarkdown, stripReaderClaimIds } from '../orchestration/decision-dossier.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';
 import { adaptIdeaOutput, adaptLegacyDecisionGraph } from '../orchestration/legacy-idea-adapter.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;
@@ -377,19 +384,23 @@ function renderDossierIdeaBody(report) {
     const criticalUnknowns = report.criticalUnknowns?.length ? report.criticalUnknowns : report.openQuestions.slice(0, 3);
     const tone = dossier.recommendation.status === 'ACCEPTED' ? 'good'
         : dossier.recommendation.status === 'REJECTED' ? 'risk' : 'caution';
-    const conditions = dossier.recommendation.conditions.length
-        ? `<details class="decision-details"><summary>Conditions and decision state</summary><div><p><strong>Internal state:</strong> ${escapeHtml(dossier.recommendation.status)}</p><ul>${dossier.recommendation.conditions.map((condition) => `<li>${escapeHtml(condition.text)}</li>`).join('')}</ul></div></details>`
+    const labelFor = claimLookup(report);
+    // Substitute ids then dedupe before escaping, mirroring the markdown renderer: old stored artifacts
+    // may carry duplicate / bare-G# condition strings.
+    const conditionItems = [...new Set(dossier.recommendation.conditions.map((condition) => stripReaderClaimIds(condition.text, labelFor)))];
+    const conditions = conditionItems.length
+        ? `<details class="decision-details"><summary>Conditions and decision state</summary><div><p><strong>Internal state:</strong> ${escapeHtml(dossier.recommendation.status)}</p><ul>${conditionItems.map((item) => `<li>${escapeHtml(item)}</li>`).join('')}</ul></div></details>`
         : '';
     const startHere = dossier.experiments.actions[0]?.action ?? 'No executable next step was produced.';
-    const recommendationLead = stripReaderClaimIds(dossier.recommendation.reason);
-    const recommendationDetail = stripReaderClaimIds(dossier.recommendation.summary);
+    const recommendationLead = stripReaderClaimIds(dossier.recommendation.reason, labelFor);
+    const recommendationDetail = stripReaderClaimIds(dossier.recommendation.summary, labelFor);
     const factLabels = ['Decisive result', 'Consequence', 'Supporting signal'];
     const facts = keyFindings.slice(0, 3).map((finding, index) => `<article class="decision-fact"><span>${factLabels[index]}</span><p>${escapeHtml(finding)}</p></article>`).join('');
     const snapshot = report.decisionSnapshot;
     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>
@@ -465,12 +476,16 @@ 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>
     <span>model time ${(report.receipt.modelTimeMs / 1000).toFixed(1)}s</span>
   </div>${report.flags.length ? `<div class="warns">${report.flags.map((flag) => `<span class="warn">⚑ ${escapeHtml(flag)}</span>`).join('')}</div>` : '<p class="muted">No degradation flags.</p>'}`;
-    const risks = dossierTable(['Risk', 'Severity'], report.risks.map((item) => [item.risk, item.severity]));
+    const shownRisks = report.risks.slice(0, 8);
+    const risks = `${dossierTable(['Risk', 'Severity'], shownRisks.map((item) => [item.risk, item.severity]))}${report.risks.length > shownRisks.length
+        ? `<p class="muted">${report.risks.length - shownRisks.length} lower-severity items — more in the technical audit (full list in the stored JSON).</p>`
+        : ''}`;
     const questions = report.openQuestions.length
         ? `<ul class="checks">${report.openQuestions.map((question) => `<li>${escapeHtml(question)}</li>`).join('')}</ul>`
         : '<p class="muted">No verdict-flipping open question was recorded.</p>';
@@ -500,7 +515,37 @@ function renderDossierIdeaBody(report) {
         section('08', 'What the council added', `${shared}${unique}<h3>Verified unique contributions</h3>${contributions}`, 340),
         section('09', 'Run details', runDetails, 380),
     ].join('');
-    return `${stripReaderClaimIds(readerBody)}${section('10', 'Technical audit', technical, 420)}`;
+    return `${stripReaderClaimIds(readerBody, labelFor)}${section('10', 'Technical audit', technical, 420)}`;
+}
+function renderReaderBriefIdeaBody(report) {
+    const dossier = report.dossier;
+    const projection = buildReaderProjection(report);
+    const tone = dossier.recommendation.status === 'ACCEPTED' ? 'good'
+        : dossier.recommendation.status === 'REJECTED' ? 'risk' : 'caution';
+    const hero = `<section class="verdict tone-${tone} reveal" style="animation-delay:60ms">
+    <span class="pill">Recommendation</span>
+    <p class="verdict-text">${escapeHtml(projection.headline)}</p>
+    <p class="verdict-detail">${escapeHtml(projection.bottomLine)}</p>
+  </section>`;
+    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 && 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('');
+    const backlog = projection.featureBacklog;
+    const features = backlog ? section('', 'Feature priorities', `<div class="feature-groups">${[
+        ['MUST', 'Build for the first useful release', backlog.must],
+        ['SHOULD', 'Add after the golden path is stable', backlog.should],
+        ['LATER', 'Keep outside the current build', backlog.later],
+    ].filter(([, , items]) => items.length).map(([priority, description, items]) => `<section class="feature-group priority-${priority.toLowerCase()}"><header><div><span>${priority}</span><h4>${description}</h4></div><strong>${items.length}</strong></header><ul>${items.map((item) => `<li><div class="feature-title"><strong>${escapeHtml(item.feature)}</strong><span>${item.effort}</span></div><p>${escapeHtml(item.user_value)}</p><small>${escapeHtml(item.rationale)}</small></li>`).join('')}</ul></section>`).join('')}</div>${backlog.wont.length ? `<h3>Not in this scope</h3><ul class="checks">${backlog.wont.map((item) => `<li><strong>${escapeHtml(item.feature)}</strong> — ${escapeHtml(item.reason)}</li>`).join('')}</ul>` : ''}`, 340) : '';
+    const buildPlan = projection.implementationPlan ? section('', 'Build plan', `<ol class="milestone-list">${projection.implementationPlan.milestones.map((milestone) => `<li><div class="milestone-marker"><span>${String(milestone.order).padStart(2, '0')}</span><small>${escapeHtml(milestone.timebox)}</small></div><article><h4>${escapeHtml(milestone.outcome)}</h4><ul>${milestone.tasks.map((task) => `<li>${escapeHtml(task)}</li>`).join('')}</ul><div class="acceptance"><span>Done when</span><p>${escapeHtml(milestone.acceptance_test)}</p></div></article></li>`).join('')}</ol>`, 380) : '';
+    const caveats = projection.caveats.length ? section('', 'Top caveats', `<ul class="checks">${projection.caveats.map((item) => `<li>${escapeHtml(item)}</li>`).join('')}</ul>`, 420) : '';
+    const sources = projection.sources.length ? section('', 'Sources', `<ul class="agree">${projection.sources.map((source) => `<li><p>${source.url ? `<a href="${escapeHtml(source.url)}" rel="noopener noreferrer">${escapeHtml(source.label)}</a>` : escapeHtml(source.label)}</p>${source.citedFor.length ? `<small>Cited for: ${source.citedFor.map(escapeHtml).join('; ')}</small>` : ''}</li>`).join('')}</ul>`, 460) : '';
+    const nextStep = section('', 'Next step', `<div class="action-callout"><span>Do this now</span><p>${escapeHtml(projection.nextStep)}</p></div>`, 500);
+    const audit = `<details class="fold council-audit"><summary>Council audit — reasoning, evidence, dissent, and run receipt</summary><div class="fold-body">${renderDossierIdeaBody(report)}</div></details>`;
+    return `${hero}${warnings}${snapshot}${editorial}${features}${buildPlan}${caveats}${sources}${nextStep}${audit}`;
 }
 function renderLegacyIdeaBody(view) {
     const risks = view.risks ?? [];
@@ -891,23 +936,27 @@ function renderTechnical(view) {
 export function renderCouncilHtml(view) {
     const isIdea = view.workflow !== 'code-review';
     const quick = isIdea && view.mode === 'quick';
+    const hasReaderBrief = Boolean(view.decisionReport?.dossier.readerBrief);
     const kicker = quick ? 'aiki · quick analysis' : isIdea ? 'aiki · idea refinement' : 'aiki · code review';
     const title = isIdea && view.topic ? cleanTopic(view.topic) : (isIdea ? 'Idea refinement' : 'Code review');
     const panel = view.columns.map((c) => c.title);
-    const metaBits = [
+    const metaBits = hasReaderBrief ? [] : [
         panel.length ? `${quick ? 'Analyst' : 'Panel'}: ${panel.join(' · ')}` : '',
         !quick && view.moderator ? `Chair: ${view.moderator}` : '',
         view.calls,
     ].filter(Boolean);
-    const flags = view.flags.length
+    const flags = !hasReaderBrief && view.flags.length
         ? `<div class="warns">${view.flags.map((f) => `<span class="warn">⚑ ${escapeHtml(f.replaceAll('_', ' '))}</span>`).join('')}</div>`
         : '';
     const body = isIdea && view.decisionReport?.dossier
-        ? renderDossierIdeaBody(view.decisionReport)
+        ? view.decisionReport.dossier.readerBrief
+            ? renderReaderBriefIdeaBody(view.decisionReport)
+            : renderDossierIdeaBody(view.decisionReport)
         : 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">
@@ -928,14 +977,14 @@ html{-webkit-text-size-adjust:100%;}
 body{margin:0;background:var(--paper);color:var(--ink);font-family:var(--sans);font-size:16px;line-height:1.6;}
 main{max-width:940px;margin:0 auto;padding:34px 24px 90px;}
 a{color:var(--accent);}
-h1{font-family:var(--serif);font-weight:600;letter-spacing:-.025em;}
+h1{font-family:var(--sans);font-weight:650;letter-spacing:-.01em;}
 h2,h3,h4{font-family:var(--sans);font-weight:650;letter-spacing:-.01em;}
 p{margin:0 0 .6em;}
 
 /* masthead */
 .mast{border-bottom:1px solid var(--ink);padding-bottom:22px;margin-bottom:30px;}
 .kicker{font-family:var(--mono);font-size:11.5px;letter-spacing:.22em;text-transform:uppercase;color:var(--accent);}
-.mast h1{font-size:clamp(32px,5.4vw,50px);line-height:1.05;margin:12px 0 18px;max-width:18ch;}
+.mast h1{font-size:clamp(28px,4.6vw,42px);line-height:1.12;margin:12px 0 16px;}
 .mmeta{display:flex;flex-wrap:wrap;gap:7px;}
 .mmeta span{font-family:var(--mono);font-size:11.5px;color:var(--soft);border:1px solid var(--line);background:var(--panel);border-radius:100px;padding:3px 10px;}
 .warns{margin-top:12px;display:flex;flex-wrap:wrap;gap:8px;}
@@ -1190,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)),
+    };
+}

package/dist/orchestration/context.js

@@ -15,7 +15,7 @@ import { extractJson } from '../providers/adapter-core.js';
 import { detect } from '../providers/detect.js';
 import { probeFlags } from '../providers/probe.js';
 import { replayKey } from '../storage/replay.js';
-import { callCategory, defaultBudgetFor, IDEA_MODE_PLANS, isOptionalStage, LEGACY_DEFAULT_BUDGET } from './modes.js';
+import { callCategory, defaultBudgetFor, defaultDeadlineFor, IDEA_MODE_PLANS, isOptionalStage, LEGACY_DEFAULT_BUDGET } from './modes.js';
 /** Bracket a stage call with the TUI's start/end events (no-op headless). A thrown StageError marks
  *  the row `failed` and re-propagates unchanged — the engine's failure handling is untouched. */
 export async function runStage(ctx, id, fn) {
@@ -39,7 +39,7 @@ export const DEFAULT_DEADLINE_MS = 20 * 60 * 1000; // wall-clock cap
 // (2026-07-13) after the spawn timeout became actually enforced and killed a LEGITIMATE deep call: codex's
 // S4 analysis of a hard build case ran ~10 min to a valid output (run 20260713-1341, 13:44→13:54). 900s
 // per attempt covers observed deep work; the wall-clock deadline above remains the outer bound.
-const DEFAULT_CALL_TIMEOUT_MS = 900_000;
+export const DEFAULT_CALL_TIMEOUT_MS = 900_000;
 export class BudgetExceeded extends Error {
     constructor(limit) {
         super(`call budget exhausted (limit ${limit})`);
@@ -74,6 +74,9 @@ export class RunCtx {
     cwd;
     events;
     evidencePack;
+    allowBlockedSources;
+    urlSources;
+    isAuto;
     budget;
     calls = [];
     /** Logical provider-call stages, including resume cache hits. Used by bounded protocol caps. */
@@ -87,6 +90,8 @@ export class RunCtx {
     deadlineAt;
     now;
     replay; // resume replay cache (V6.3)
+    autoDecision; // v7 Phase B/D: routing record + output escalation receipt
+    fastPathActive;
     seq = 0; // monotonic per-call counter for raw/ filenames (== budget.used on a fresh run)
     constructor(opts) {
         this.runId = opts.runId;
@@ -97,13 +102,36 @@ export class RunCtx {
         this.cwd = opts.cwd;
         this.events = opts.events;
         this.evidencePack = opts.evidencePack;
+        this.allowBlockedSources = opts.allowBlockedSources;
+        this.urlSources = opts.urlSources;
+        this.isAuto = opts.autoDecision !== undefined;
+        this.fastPathActive = this.mode === 'quick'
+            && opts.autoDecision?.resolved === 'quick'
+            && opts.autoDecision.fast_path === true;
         this.budget = { limit: opts.budget ?? defaultBudgetFor(opts.workflow, this.mode), used: 0 };
         this.handles = new Map(opts.handles.map((h) => [h.id, h]));
         this.signal = opts.signal;
-        this.deadlineMs = opts.deadlineMs ?? DEFAULT_DEADLINE_MS;
+        this.deadlineMs = opts.deadlineMs ?? defaultDeadlineFor(opts.workflow, this.mode);
         this.now = opts.now ?? Date.now;
         this.deadlineAt = this.now() + this.deadlineMs;
         this.replay = opts.replay;
+        this.autoDecision = opts.autoDecision ? { ...opts.autoDecision } : undefined;
+    }
+    get fastPath() {
+        return this.fastPathActive;
+    }
+    get autoEscalationReasons() {
+        return this.autoDecision?.escalation_reasons ?? [];
+    }
+    /** Phase D: retain initial fast-path eligibility in meta, but stop rendering it as single-pass. */
+    markAutoEscalated(reasons) {
+        if (!this.autoDecision || reasons.length === 0)
+            return;
+        this.fastPathActive = false;
+        this.autoDecision = {
+            ...this.autoDecision,
+            escalation_reasons: [...new Set([...(this.autoDecision.escalation_reasons ?? []), ...reasons])],
+        };
     }
     /** Provider ids available this run (READY at setup). */
     available() {
@@ -135,6 +163,8 @@ export class RunCtx {
     optionalCallsRemaining() {
         if (this.workflow !== 'idea-refinement')
             return 0;
+        if (this.isAuto)
+            return 0; // Phase D adaptive topology owns its single optional challenge directly.
         const plan = IDEA_MODE_PLANS[this.mode];
         const logicalUsed = this.attemptedStages.filter(isOptionalStage).length;
         const protocolRoom = Math.max(0, plan.optionalCalls - logicalUsed);
@@ -160,13 +190,16 @@ export class RunCtx {
         // Resume (V6.3): if this exact (provider, prompt) already succeeded in the run we're resuming,
         // replay its output — no real call, no budget spend. Only never-completed calls hit the model.
         const cachedOut = this.replay?.get(replayKey(handle.id, req.prompt));
+        const category = callCategory(stage);
+        const replayed = cachedOut !== undefined;
+        if (!replayed && this.budget.used + 1 > this.budget.limit)
+            throw new BudgetExceeded(this.budget.limit);
+        this.events?.onCallStart?.(handle.id, stage, category, replayed);
         let res;
         if (cachedOut !== undefined) {
             res = { ok: true, text: cachedOut, json: req.expectJson ? extractJson(cachedOut) : undefined, durationMs: 0 };
         }
         else {
-            if (this.budget.used + 1 > this.budget.limit)
-                throw new BudgetExceeded(this.budget.limit);
             this.budget.used++;
             res = await handle.adapter.run({
                 prompt: req.prompt,
@@ -174,7 +207,7 @@ export class RunCtx {
                 timeoutMs: req.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS,
                 expectJson: req.expectJson,
                 readOnly: true,
-                research: this.mode === 'research' && stage.startsWith('S4'),
+                research: this.workflow === 'idea-refinement' && this.mode !== 'quick' && stage.startsWith('S4'),
                 signal: this.signal, // Ctrl+C kills the in-flight child (T8); undefined headless
             }, handle.flags);
             // Only REAL calls count toward the ledger/budget; a replayed call is free and already recorded in
@@ -184,10 +217,12 @@ export class RunCtx {
                 stage,
                 category: callCategory(stage),
                 durationMs: res.durationMs,
+                usage: (res.ok && res.usage) || estimateUsage(req.prompt, res.ok ? res.text : ''),
                 ...(res.ok ? {} : { error: res.error }),
             });
         }
         await this.writer.writeRaw(`${stage}-${handle.id}-${seq}.out`, res.ok ? res.text : `[${res.error}]\n${res.stderrTail}`);
+        this.events?.onCallEnd?.(handle.id, stage, res.durationMs, res.ok, replayed);
         return res;
     }
     /** Assemble the run's `meta.json` payload (§15) from the handles + call ledger accumulated so
@@ -211,6 +246,7 @@ export class RunCtx {
         this.roles.s4.forEach((id, i) => (roles[`s4_${i + 1}`] = id));
         // Fold stage-raised flags in with any explicitly passed by the caller; dedupe.
         const allFlags = [...new Set([...(flags ?? []), ...this.flags])];
+        const usage_totals = this.sumUsage();
         return {
             run_id: this.runId,
             workflow: this.workflow,
@@ -223,11 +259,38 @@ export class RunCtx {
             call_count: this.calls.length,
             budget: { limit: this.budget.limit, used: this.budget.used },
             receipt: this.receipt(),
+            ...(usage_totals ? { usage_totals } : {}),
+            ...(this.autoDecision ? { auto_decision: this.autoDecision } : {}),
             exit_status: exitStatus,
             aborted,
             ...(allFlags.length ? { flags: allFlags } : {}),
         };
     }
+    /** Sum per-call usage into run totals. Undefined when no call carries usage (empty run). */
+    sumUsage() {
+        let inputTokens = 0, outputTokens = 0, reportedCalls = 0, estimatedCalls = 0, reportedCostUsd = 0, anyCost = false;
+        for (const c of this.calls) {
+            if (!c.usage)
+                continue;
+            inputTokens += c.usage.inputTokens ?? 0;
+            outputTokens += c.usage.outputTokens ?? 0;
+            if (c.usage.estimated)
+                estimatedCalls++;
+            else
+                reportedCalls++;
+            if (c.usage.reportedCostUsd !== undefined) {
+                reportedCostUsd += c.usage.reportedCostUsd;
+                anyCost = true;
+            }
+        }
+        if (reportedCalls === 0 && estimatedCalls === 0)
+            return undefined;
+        return { inputTokens, outputTokens, reportedCalls, estimatedCalls, ...(anyCost ? { reportedCostUsd } : {}) };
+    }
+}
+/** ponytail: chars/4 heuristic, labeled estimated — good enough until a provider reports. */
+function estimateUsage(prompt, out) {
+    return { inputTokens: Math.ceil(prompt.length / 4), outputTokens: Math.ceil(out.length / 4), estimated: true };
 }
 /** Run-fatal errors abort the whole run; everything else (e.g. a single provider failure in a
  *  fan-out) is handled locally by the stage (drop provider, check quorum). */