aiki-cli 0.2.1 → 0.3.0

package/dist/orchestration/calculations.js

@@ -0,0 +1,97 @@
+const UNIT_ALIASES = {
+    ratios: '1', ratio: '1', percentage: '1', percent: '1', '%': '1', dimensionless: '1',
+    visitors: 'visitor', orders: 'order', customers: 'customer', users: 'user',
+    months: 'month', years: 'year', units: 'unit', items: 'item',
+};
+/** Keep unit meaning atomic. Model ledgers sometimes decorate currency tokens ("INR revenue") or
+ * use ordinary plurals; those are the same physical dimensions and must cancel algebraically. */
+function canonicalUnitToken(token) {
+    const normalized = token.trim().toLowerCase().replace(/\s+/g, ' ');
+    const currency = normalized.match(/^(inr|usd|eur|gbp|jpy|aud|cad|cny|sgd|aed)(?:\b|$)/)?.[1];
+    if (currency)
+        return currency;
+    return UNIT_ALIASES[normalized] ?? normalized;
+}
+function unitPowers(unit) {
+    const powers = new Map();
+    let sign = 1;
+    for (const token of unit.split(/([*/])/).map((part) => part.trim()).filter(Boolean)) {
+        if (token === '*') {
+            sign = 1;
+            continue;
+        }
+        if (token === '/') {
+            sign = -1;
+            continue;
+        }
+        const canonical = canonicalUnitToken(token);
+        if (canonical !== '1')
+            powers.set(canonical, (powers.get(canonical) ?? 0) + sign);
+    }
+    return new Map([...powers].filter(([, power]) => power !== 0));
+}
+function sameUnits(left, right) {
+    return left.size === right.size && [...left].every(([unit, power]) => right.get(unit) === power);
+}
+function formatUnits(powers) {
+    const numerator = [];
+    const denominator = [];
+    for (const [unit, power] of [...powers].sort(([a], [b]) => a.localeCompare(b))) {
+        for (let i = 0; i < Math.abs(power); i++)
+            (power > 0 ? numerator : denominator).push(unit);
+    }
+    const top = numerator.join('*') || '1';
+    return denominator.length ? `${top}/${denominator.join('/')}` : top;
+}
+function resultUnit(operation, left, right) {
+    const leftPowers = unitPowers(left);
+    const rightPowers = unitPowers(right);
+    if (operation === 'ADD' || operation === 'SUBTRACT')
+        return sameUnits(leftPowers, rightPowers) ? formatUnits(leftPowers) : null;
+    const powers = new Map(leftPowers);
+    for (const [unit, power] of rightPowers) {
+        powers.set(unit, (powers.get(unit) ?? 0) + (operation === 'MULTIPLY' ? power : -power));
+        if (powers.get(unit) === 0)
+            powers.delete(unit);
+    }
+    return formatUnits(powers);
+}
+/** Recompute a declared ledger without eval/shell execution and report value/unit mismatches. */
+export function evaluateCalculation(calculation) {
+    const values = new Map(calculation.inputs.map((input) => [input.id, { value: input.value, unit: input.unit }]));
+    const issues = [];
+    for (const step of calculation.steps) {
+        const left = values.get(step.left);
+        const right = values.get(step.right);
+        if (!left || !right) {
+            issues.push(`${step.id}: unknown operand reference`);
+            continue;
+        }
+        if (step.operation === 'DIVIDE' && right.value === 0) {
+            issues.push(`${step.id}: division by zero`);
+            continue;
+        }
+        const expected = step.operation === 'ADD' ? left.value + right.value
+            : step.operation === 'SUBTRACT' ? left.value - right.value
+                : step.operation === 'MULTIPLY' ? left.value * right.value
+                    : left.value / right.value;
+        const unit = resultUnit(step.operation, left.unit, right.unit);
+        if (!unit)
+            issues.push(`${step.id}: ${step.operation} requires matching units (${left.unit} vs ${right.unit})`);
+        else if (!sameUnits(unitPowers(step.unit), unitPowers(unit)))
+            issues.push(`${step.id}: unit ${step.unit} does not match ${unit}`);
+        if (Math.abs(step.result - expected) > 1e-9 * Math.max(1, Math.abs(expected))) {
+            issues.push(`${step.id}: result ${step.result} does not match ${expected}`);
+        }
+        values.set(step.id, { value: expected, unit: unit ?? step.unit });
+    }
+    if (!calculation.steps.some((step) => step.id === calculation.result_step)) {
+        issues.push(`result_step: unknown step ${calculation.result_step}`);
+    }
+    return {
+        calculation_id: calculation.id,
+        claim_id: calculation.claim_id,
+        status: issues.length ? 'FAIL' : 'PASS',
+        issues,
+    };
+}

package/dist/orchestration/context.js

@@ -15,6 +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';
 /** 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) {
@@ -29,17 +30,16 @@ export async function runStage(ctx, id, fn) {
         throw e;
     }
 }
-export const DEFAULT_BUDGET = 18; // full idea pipeline min = S0(1)+S1(1)+S2(3)+S3(1)+S4(2)+S7-group(1)+
-// S8(1)+S9(1)+S9b(1) = 12. But S2 runs 3 providers that EACH can repair, plus S9 + S9b anchor repairs —
-// a live run spent 3 repairs and died at 13 before S9b. 18 = 12 + ~6 repair headroom so the validation
-// plan actually renders; a true repair-storm still fails gracefully. Overridable via `--budget`/config.
+/** Legacy/code-review fallback. Idea-refinement defaults are adaptive by explicit mode (R6). */
+export const DEFAULT_BUDGET = LEGACY_DEFAULT_BUDGET;
 // §19 was 10 min; raised to 20 (user-authorized 2026-07-06). Evidence: a real Opus judge (S9) on a
 // 9-dispute idea ran ~360s and the whole run was ~14 min → the 10-min wall-clock aborted a legitimate run.
 export const DEFAULT_DEADLINE_MS = 20 * 60 * 1000; // wall-clock cap
-// §7.1 was 180s; raised to 300 (user-authorized 2026-07-06). The adapter retries a TIMEOUT once, so 180s
-// gave a 360s ceiling and the deep-reasoning judge blew it (observed exactly 360.1s → TIMEOUT). 300s per
-// attempt covers the Opus judge; the wall-clock deadline above remains the outer bound.
-const DEFAULT_CALL_TIMEOUT_MS = 300_000;
+// §7.1 was 180s; raised to 300 (user-authorized 2026-07-06) for the deep-reasoning judge; raised to 900
+// (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 class BudgetExceeded extends Error {
     constructor(limit) {
         super(`call budget exhausted (limit ${limit})`);
@@ -68,12 +68,16 @@ export class StageError extends Error {
 export class RunCtx {
     runId;
     workflow;
+    mode;
     roles;
     writer;
     cwd;
     events;
+    evidencePack;
     budget;
     calls = [];
+    /** Logical provider-call stages, including resume cache hits. Used by bounded protocol caps. */
+    attemptedStages = [];
     /** §16 report-header flags accumulated by stages (S4 → low_diversity, S7 → low_diversity,
      *  S9 → synthesis_suspect). Folded into meta.json at finalize by `buildMeta`. */
     flags = new Set();
@@ -87,11 +91,13 @@ export class RunCtx {
     constructor(opts) {
         this.runId = opts.runId;
         this.workflow = opts.workflow;
+        this.mode = opts.mode ?? 'council';
         this.roles = opts.roles;
         this.writer = opts.writer;
         this.cwd = opts.cwd;
         this.events = opts.events;
-        this.budget = { limit: opts.budget ?? DEFAULT_BUDGET, used: 0 };
+        this.evidencePack = opts.evidencePack;
+        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;
@@ -125,12 +131,30 @@ export class RunCtx {
         if (this.now() > this.deadlineAt)
             throw new DeadlineExceeded(this.deadlineMs);
     }
+    /** Calls optional stages may still spend after preserving this mode's required tail calls. */
+    optionalCallsRemaining() {
+        if (this.workflow !== 'idea-refinement')
+            return 0;
+        const plan = IDEA_MODE_PLANS[this.mode];
+        const logicalUsed = this.attemptedStages.filter(isOptionalStage).length;
+        const protocolRoom = Math.max(0, plan.optionalCalls - logicalUsed);
+        const budgetRoom = Math.max(0, this.budget.limit - this.budget.used - plan.reservedCalls);
+        return Math.min(protocolRoom, budgetRoom);
+    }
+    /** Actual-call receipt. Resume replay is free and therefore intentionally absent. */
+    receipt() {
+        const receipt = { discovery: 0, verification: 0, repair: 0, planning: 0 };
+        for (const call of this.calls)
+            receipt[call.category ?? callCategory(call.stage)]++;
+        return receipt;
+    }
     /**
      * Make one budgeted provider call. Decrements budget (throws `BudgetExceeded` if it would go
      * over), records a `CallRecord`, and dumps the exact prompt + raw output under `raw/` (§15).
      */
     async call(handle, req, stage) {
         this.guard();
+        this.attemptedStages.push(stage);
         const seq = ++this.seq;
         await this.writer.writeRaw(`${stage}-${handle.id}-${seq}.prompt.txt`, req.prompt);
         // Resume (V6.3): if this exact (provider, prompt) already succeeded in the run we're resuming,
@@ -150,6 +174,7 @@ export class RunCtx {
                 timeoutMs: req.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS,
                 expectJson: req.expectJson,
                 readOnly: true,
+                research: this.mode === 'research' && 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
@@ -157,6 +182,7 @@ export class RunCtx {
             this.calls.push({
                 provider: handle.id,
                 stage,
+                category: callCategory(stage),
                 durationMs: res.durationMs,
                 ...(res.ok ? {} : { error: res.error }),
             });
@@ -188,6 +214,7 @@ export class RunCtx {
         return {
             run_id: this.runId,
             workflow: this.workflow,
+            ...(this.workflow === 'idea-refinement' ? { mode: this.mode } : {}),
             provider_versions,
             flag_profiles,
             roles,
@@ -195,6 +222,7 @@ export class RunCtx {
             calls: this.calls,
             call_count: this.calls.length,
             budget: { limit: this.budget.limit, used: this.budget.used },
+            receipt: this.receipt(),
             exit_status: exitStatus,
             aborted,
             ...(allFlags.length ? { flags: allFlags } : {}),

package/dist/orchestration/decision-dossier.js

@@ -0,0 +1,262 @@
+import { DISPLAY_NAME } from '../providers/types.js';
+function cell(value) {
+    return value.replaceAll('\n', ' ').replaceAll('|', '\\|');
+}
+function refs(ids) {
+    return ids.length ? ids.map((id) => `\`${id}\``).join(', ') : 'none recorded';
+}
+function providerName(id) {
+    return id in DISPLAY_NAME ? DISPLAY_NAME[id] : id;
+}
+function degradation(report, flags) {
+    const active = flags.filter((flag) => report.flags.includes(flag));
+    return active.length ? [`> ⚠ DEGRADED: ${active.join(', ')}`, ''] : [];
+}
+function pct(value) {
+    return `${Math.round(value * 100)}%`;
+}
+function coverageLabel(value) {
+    return value >= 0.75 ? 'High' : value >= 0.5 ? 'Medium' : 'Low';
+}
+function councilRead(report) {
+    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;
+    if (report.disagreements.length === 0) {
+        return `${scouts || 'The'} independent scout ${scouts === 1 ? 'analysis produced' : 'analyses produced'} no genuine opposing claim; the chair had less contested material to resolve.`;
+    }
+    const resolved = report.disagreements.filter((item) => item.status === 'RESOLVED').length;
+    return `${report.disagreements.length} genuine disagreement${report.disagreements.length === 1 ? '' : 's'} reached the chair; ${resolved} ${resolved === 1 ? 'was' : 'were'} resolved.`;
+}
+/** Canonical R7 Markdown. HTML and Copy-Markdown consume the same persisted dossier object. */
+export function renderDecisionDossierMarkdown(report) {
+    const { dossier } = report;
+    const keyFindings = report.keyFindings?.length ? report.keyFindings : [dossier.recommendation.reason];
+    const criticalUnknowns = report.criticalUnknowns?.length ? report.criticalUnknowns : report.openQuestions.slice(0, 3);
+    const coverage = report.confidenceBreakdown.verificationCoverage;
+    const L = [report.mode === 'quick' ? '# Single-Model Decision Report' : '# Multi-Model Decision Report', ''];
+    L.push('## 1. Decision', '', ...degradation(report, ['synthesis_suspect']));
+    if (report.decisionSnapshot) {
+        L.push('### Decisive numbers', '', '| Metric | Value | What it means | Evidence |', '|---|---:|---|---|');
+        for (const item of report.decisionSnapshot.decisiveNumbers) {
+            L.push(`| ${cell(item.label)} | ${cell(item.value)} | ${cell(item.meaning)} | ${refs(item.claimIds)} |`);
+        }
+        if (report.decisionSnapshot.payback) {
+            const payback = report.decisionSnapshot.payback;
+            L.push('', `**Payback — ${payback.status.replaceAll('_', ' ')}:** ${payback.result}`);
+            L.push(`Basis: ${payback.basis} (${refs(payback.claimIds)})`, '');
+        }
+        else
+            L.push('');
+    }
+    L.push(`**Recommendation:** ${dossier.recommendation.summary}`, '');
+    L.push(`**Evidence coverage:** ${coverageLabel(coverage)} — ${pct(coverage)} of load-bearing claims independently verified.`);
+    L.push(coverage < 0.5
+        ? '> Low coverage means important inputs remain unchecked; it is not a probability that the recommendation is correct.'
+        : '> Evidence coverage measures independent checking; it is not a probability that the recommendation is correct.', '');
+    if (!report.decisionSnapshot) {
+        L.push('### Decisive findings', '');
+        for (const finding of keyFindings.slice(0, 3))
+            L.push(`- ${finding}`);
+    }
+    L.push('', '### Do this first', '', dossier.experiments.actions[0]?.action ?? 'No executable next step was produced.', '');
+    if (report.decisionSnapshot) {
+        L.push('### Options at a glance', '', '| Path | Commitment | Basis | Trade-off | Evidence |', '|---|---:|---|---|---|');
+        for (const option of report.decisionSnapshot.options) {
+            L.push(`| ${cell(option.label)} | ${cell(option.commitment)} | ${option.commitmentKind.replace('_', ' ')} | ${cell(option.tradeoff)} | ${refs(option.claimIds)} |`);
+        }
+        if (report.decisionSnapshot.tripwire) {
+            const tripwire = report.decisionSnapshot.tripwire;
+            L.push('', '### Go/no-go tripwire', '', `**${tripwire.metric}: ${tripwire.threshold}** — ${tripwire.decisionRule} (${refs(tripwire.claimIds)})`, '');
+        }
+    }
+    L.push('### What could overturn this', '', dossier.counterCase.available ? dossier.counterCase.reasoning : dossier.counterCase.reasoning, '');
+    L.push('### Critical unknowns', '');
+    if (criticalUnknowns.length)
+        for (const unknown of criticalUnknowns)
+            L.push(`- ${unknown}`);
+    else
+        L.push('- None recorded.');
+    L.push('', `**Critical warning:** ${report.verdict.criticalWarning ?? 'None recorded.'}`);
+    L.push(`**Council read:** ${councilRead(report)}`);
+    L.push(`Evidence anchors: ${refs(dossier.recommendation.claimIds)}`, '');
+    if (!dossier.recommendation.claimIds.length)
+        L.push('> ⚠ DEGRADED: recommendation has no stored graph anchor.', '');
+    L.push('<details>', '<summary>Decision conditions and technical confidence</summary>', '');
+    L.push(`- Decision state: ${dossier.recommendation.status}`);
+    L.push(`- Structural score: ${report.confidenceBreakdown.score}/100 (${report.confidenceBreakdown.label}); heuristic, not benchmark-calibrated.`);
+    L.push(`- Basis: verification ${pct(coverage)} · independent convergence ${pct(report.confidenceBreakdown.independentConvergence)} · evidence quality ${pct(report.confidenceBreakdown.evidenceQuality)} · stability ${pct(report.confidenceBreakdown.stability)} · critical-risk penalty −${report.confidenceBreakdown.criticalRiskPenalty}`);
+    if (dossier.recommendation.conditions.length) {
+        L.push('', 'Conditions:');
+        for (const condition of dossier.recommendation.conditions) {
+            L.push(`- ${condition.text} (${refs(condition.claimIds)})`);
+        }
+    }
+    L.push('', '</details>', '');
+    L.push('## 2. Action plan', '', ...degradation(report, ['plan_fallback', 'plan_skipped']));
+    if (dossier.experiments.status === 'DEGRADED')
+        L.push(`> ⚠ DEGRADED: ${dossier.experiments.note}`, '');
+    if (dossier.experiments.actions.length) {
+        L.push('| # | Experiment | Why | Validates | Effort | Kill signal |', '|---|---|---|---|---|---|');
+        for (const action of dossier.experiments.actions) {
+            L.push(`| ${action.order} | ${cell(action.action)} | ${cell(action.why)} | ${action.validates} | ${action.effort} | ${cell(action.killSignal)} |`);
+        }
+        L.push('', dossier.experiments.note);
+    }
+    else
+        L.push('No executable experiment was produced.');
+    L.push('');
+    L.push('## 3. Why this decision', '');
+    if (dossier.claimChain.length) {
+        L.push('| Claim ID | Claim | Ruling | Evidence status | Depends on |', '|---|---|---|---|---|');
+        for (const claim of dossier.claimChain) {
+            L.push(`| ${claim.claimId} | ${cell(claim.text)} | ${claim.ruling} | ${claim.evidenceStatus} | ${refs(claim.dependsOn)} |`);
+        }
+    }
+    else
+        L.push('No graph-anchored decision chain was recorded.');
+    L.push('');
+    L.push('## 4. What could change the decision', '', '### Decision-sensitive facts', '');
+    if (dossier.sensitivity.length) {
+        L.push('| Claim ID | Fact | Sensitivity | If false | What would change it | Linked claims |', '|---|---|---|---|---|---|');
+        for (const item of dossier.sensitivity) {
+            L.push(`| ${item.claimId} | ${cell(item.fact)} | ${item.sensitivity} | ${item.impactIfFalse} | ${cell(item.whatWouldChangeIt)} | ${refs(item.linkedClaimIds)} |`);
+        }
+    }
+    else
+        L.push('No verdict-sensitive graph node was recorded.');
+    L.push('', '### Strongest counter-case', '');
+    if (dossier.counterCase.available) {
+        L.push(dossier.counterCase.reasoning, '', `Evidence anchors: ${refs(dossier.counterCase.claimIds)}`);
+    }
+    else
+        L.push(`> ⚠ DEGRADED: ${dossier.counterCase.reasoning}`);
+    L.push('');
+    L.push('## 5. Evidence and verification', '', ...degradation(report, ['verification_skipped', 'research_ungrounded']));
+    if (dossier.evidence.length) {
+        L.push('| Evidence ID | Source | Date | Freshness | Verification | Linked claims |', '|---|---|---|---|---|---|');
+        for (const evidence of dossier.evidence) {
+            L.push(`| ${evidence.id} | ${cell(evidence.source)} (${evidence.sourceKind}) | ${evidence.date} | ${evidence.freshness} | ${evidence.verificationStatus} | ${refs(evidence.claimIds)} |`);
+        }
+    }
+    else
+        L.push('No evidence cards were stored.');
+    L.push('');
+    L.push('## 6. Risks, gaps, and open questions', '', '### Risks', '');
+    if (report.risks.length) {
+        L.push('| Risk | Severity |', '|---|---|');
+        for (const risk of report.risks)
+            L.push(`| ${cell(risk.risk)} | ${risk.severity} |`);
+    }
+    else
+        L.push('No material risk was recorded.');
+    L.push('', '### Coverage', '');
+    if (dossier.coverage.length) {
+        L.push('| Dimension | Status | Claim IDs |', '|---|---|---|');
+        for (const item of dossier.coverage)
+            L.push(`| ${cell(item.label)} | ${item.status} | ${refs(item.claimIds)} |`);
+    }
+    else
+        L.push('No rubric coverage ledger was recorded.');
+    L.push('', '### Open questions', '');
+    if (report.openQuestions.length) {
+        for (const question of report.openQuestions)
+            L.push(`- ${question}`);
+    }
+    else
+        L.push('No verdict-flipping open question was recorded.');
+    L.push('');
+    L.push('## 7. Disagreement and dissent', '', ...degradation(report, ['single_model', 'low_diversity']));
+    if (report.disagreements.length) {
+        for (const disagreement of report.disagreements) {
+            L.push(`- **${disagreement.id}: ${disagreement.topic}** — ${disagreement.status}; ${disagreement.ruling}.`);
+            for (const side of disagreement.sides)
+                L.push(`  - ${side.stance} (${side.providers.map(providerName).join(', ')}): ${side.reasoning.join(' ')}`);
+            if (disagreement.reasoning)
+                L.push(`  - Why: ${disagreement.reasoning}`);
+        }
+    }
+    else
+        L.push(report.mode === 'quick' ? 'No cross-model disagreement analysis runs in quick mode.' : 'No genuine disagreements were stored.');
+    L.push('', '### Position changes', '');
+    if (dossier.positionChanges.length) {
+        L.push('| Event | Claim | Responder | Change | Evidence | Detail |', '|---|---|---|---|---|---|');
+        for (const event of dossier.positionChanges) {
+            L.push(`| ${event.eventId} | ${event.claimId} | ${providerName(event.responder)} | ${event.response} | ${refs(event.evidenceIds)} | ${cell(event.narrowedProposition ?? event.reasoning)} |`);
+        }
+    }
+    else
+        L.push('No `CONCEDE`, `COUNTER`, or `NARROW` event was recorded.');
+    L.push('', '### Minority report', '');
+    if (report.minority.dissent.length) {
+        for (const item of report.minority.dissent)
+            L.push(`- ${item}`);
+    }
+    else
+        L.push('No minority dissent was recorded.');
+    for (const item of report.minority.uniqueOppositions)
+        L.push(`- ${providerName(item.provider)} uniquely opposed: ${item.proposition}`);
+    L.push(`- Decision-blocking status: ${report.minority.blocksDecision}`, '');
+    L.push('## 8. What the council added', '');
+    if (dossier.sharedConcerns.length) {
+        L.push('Shared concerns:');
+        for (const item of dossier.sharedConcerns)
+            L.push(`- **${item.claimId}** ${item.text} — ${item.evidenceStatus}; ${item.providerIds.map(providerName).join(', ')}.`);
+    }
+    else
+        L.push('Shared concerns: none recorded.');
+    L.push('');
+    if (dossier.uniqueSupportedInsights.length) {
+        L.push('Unique supported insights:');
+        for (const item of dossier.uniqueSupportedInsights)
+            L.push(`- **${item.claimId}** ${item.text} — ${providerName(item.providerId)}; ${item.verificationStatus}.`);
+    }
+    else
+        L.push('Unique supported insights: none recorded.');
+    L.push('', '### Verified unique contributions', '', ...degradation(report, ['verification_skipped', 'single_model', 'low_diversity']));
+    L.push('Only unique claims that survived independent verification receive credit.', '');
+    L.push('| Provider | Verified unique claim IDs | Count |', '|---|---|---|');
+    for (const contribution of dossier.contributions) {
+        L.push(`| ${contribution.name} | ${refs(contribution.verifiedUniqueClaimIds)} | ${contribution.verifiedUniqueClaimIds.length} |`);
+    }
+    L.push('');
+    L.push('## 9. Run details', '');
+    L.push(`- Report ID: \`${report.reportId}\``);
+    L.push(`- Generated: ${report.generatedAt}`);
+    L.push(`- Original task: ${report.task.original}`);
+    L.push(`- Normalized question: ${report.task.normalized}`);
+    if (report.task.confirmation)
+        L.push(`- User confirmation: ${report.task.confirmation}`);
+    L.push(`- Constraints: ${report.task.constraints.join('; ') || 'none recorded'}`);
+    L.push(`- Success criteria: ${report.task.successCriteria.join('; ') || 'none recorded'}`);
+    L.push(`- Models and roles: ${report.models.map((model) => `${model.name} (${model.roles.join(', ')})`).join(' · ') || 'none recorded'}`);
+    L.push(`- Mode: ${report.mode}`);
+    L.push(`- Provider calls: ${report.receipt.calls}/${report.receipt.budget}`);
+    L.push(`- Categories: discovery ${report.receipt.categories.discovery} · verification ${report.receipt.categories.verification} · repair ${report.receipt.categories.repair} · planning ${report.receipt.categories.planning}`);
+    L.push(`- By provider: ${Object.entries(report.receipt.byProvider).map(([provider, count]) => `${providerName(provider)} ${count}`).join(', ') || 'none'}`);
+    L.push(`- Recorded model time: ${(report.receipt.modelTimeMs / 1000).toFixed(1)}s`);
+    L.push(`- Degradation flags: ${report.flags.join(', ') || 'none'}`, '');
+    L.push('## 10. Technical audit', '');
+    L.push('<details>', '<summary>Original submissions and graph events</summary>', '');
+    for (const submission of dossier.technical.submissions) {
+        L.push(`- **${submission.name}:** ${submission.strongestVersion} (${refs(submission.positionIds)})`);
+    }
+    L.push('', 'Original positions:');
+    for (const position of dossier.technical.positions) {
+        L.push(`- ${position.id} [${providerName(position.provider)} ${position.stance}] ${position.proposition}; evidence ${refs(position.evidenceIds)}`);
+    }
+    if (!dossier.technical.positions.length)
+        L.push('- none');
+    L.push('', 'Graph edges:');
+    for (const edge of dossier.technical.edges)
+        L.push(`- ${edge.from} —${edge.type}→ ${edge.to}`);
+    if (!dossier.technical.edges.length)
+        L.push('- none');
+    L.push('', 'Position-change events:');
+    for (const event of dossier.technical.events)
+        L.push(`- ${event.eventId}: ${providerName(event.responder)} ${event.response} ${event.claimId} — ${event.reasoning}`);
+    if (!dossier.technical.events.length)
+        L.push('- none');
+    L.push('', '</details>', '');
+    return L.join('\n');
+}