aiki-cli 0.2.2 → 0.3.1

package/dist/skills/idea-refinement/analyst.md

@@ -7,22 +7,22 @@ where it breaks. Steelman it once, then attack it honestly.
 - Before attacking, state the best honest version of the idea: who it is for and why it would win.
 - Attack THAT version, not a weak strawman. If the steelman is thin, that itself is a finding.
 
-## Assumptions — surface the load-bearing ones
-- Name the assumptions the idea silently depends on. Mark each VERIFIABLE (checkable with data or a
-  test) or JUDGMENT (a bet on taste, market, or behavior).
-- Flag which are load-bearing: the ones where, if false, the whole idea collapses. Spend effort
-  there, not on cosmetic assumptions.
-
-## Attacks — anchored and severe
-- Every attack must target a specific assumption id. An attack that floats free of an assumption is
-  noise — discard it yourself.
-- Rank by severity: HIGH = kills or reshapes the idea; MED = forces a costly change; LOW = a caveat.
-- Prefer the attack a smart skeptic would actually make: no strawmen, no nitpicks dressed as risks.
+## Positions — make the stance explicit
+- State each decision-critical proposition and take an explicit SUPPORT, OPPOSE, MIXED, or UNKNOWN
+  stance. Mark whether the basis is EVIDENCE, INFERENCE, or ASSUMPTION.
+- Flag load-bearing positions and say whether falsity means STOP, PIVOT, CONDITION, or MINOR.
+
+## Evidence — anchored and honest
+- Anchor evidence cards to position IDs. Distinguish user material, primary sources, secondary
+  sources, and model knowledge; never invent a source or URL.
+- Model knowledge cannot settle current, numeric, legal, medical, financial, market, or regulatory
+  facts. Mark uncertainty instead of laundering memory into evidence.
+- Prefer the objection a smart skeptic would actually make: no strawmen or cosmetic caveats.
 
 ## MANDATORY coverage — address every dimension below
 Do not leave a dimension unexamined; an unaddressed dimension is a hole in your analysis, not a
 neutral omission. For each, either raise an assumption/attack or state plainly why it is not a
-concern for THIS idea:
+concern for THIS idea using a reasoned NOT_APPLICABLE coverage entry:
 1. Target user / who this is actually for.
 2. Existing alternatives — including "do nothing" and the status quo.
 3. Differentiation — why this wins over those alternatives.
@@ -35,11 +35,15 @@ concern for THIS idea:
 10. Timing — why now, and what makes the market ready or not.
 11. Scalability — what breaks as it grows.
 12. Key risks / assumptions that must be validated first.
+13. Team / founder capability against the execution requirements.
+
+Also cover every domain-specific dimension listed in the task contract. The lane prompt assigns
+ownership; emit one explicit coverage entry for every owned dimension.
 
-## Open questions that move the verdict
+## Decision questions that move the verdict
 - List only questions whose ANSWER would change the decision. "Nice to know" is not one of them.
 - Phrase each so that a yes/no or a single number would actually flip your assessment.
 
 ## Do not
 - No motivational framing, no pitch language, no summarizing your own output.
-- No attack without an assumption to anchor it. No assumption you cannot tie to the idea.
+- No unanchored position or evidence. No proposition you cannot tie to the decision.

package/dist/skills/idea-refinement/economics-delivery.md

@@ -0,0 +1,7 @@
+# Economics and delivery lane
+
+Own unit economics and capital needs, technical and operational feasibility, supply constraints,
+legal and compliance exposure, scalability, failure modes, and the cheapest decisive kill criteria.
+
+Steelman the idea first. Cross into another lane only for a load-bearing issue. For every owned
+dimension, emit a `COVERED` entry anchored to positions or a reasoned `NOT_APPLICABLE` entry.

package/dist/skills/idea-refinement/market-adoption.md

@@ -0,0 +1,7 @@
+# Market and adoption lane
+
+Own target-user urgency, alternatives and status quo, differentiation, distribution and procurement,
+timing, and the team's ability to execute the required adoption motion.
+
+Steelman the idea first. Cross into another lane only for a load-bearing issue. For every owned
+dimension, emit a `COVERED` entry anchored to positions or a reasoned `NOT_APPLICABLE` entry.

package/dist/storage/runs.js

@@ -12,7 +12,7 @@
 //   an invalid payload throws and writes nothing.
 import { mkdir, rename, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { ActionPlan, DisagreementMap, IntentContract, JudgeReport, ReviewMap, RoleOutput, RunBrief, RunMeta, VerificationSet } from '../schemas/index.js';
+import { ActionPlanArtifact, DecisionContractArtifact, DecisionGraph, DisagreementMap, IdeaRoleOutput, JudgeReport, PreflightArtifact, RebuttalEventSet, ReviewMap, RoleOutput, RunBrief, RunMeta, UrlSourceSet, VerificationArtifact } from '../schemas/index.js';
 export class OutOfOrderWriteError extends Error {
     constructor(slot, ord, maxOrd) {
         super(`out-of-order write: "${slot}" (stage ${ord}) after stage ${maxOrd} already written`);
@@ -28,18 +28,26 @@ export class DuplicateWriteError extends Error {
 /** JSON stage slots. Composites without a T4 core schema (misunderstanding-guard, drift, claims)
  *  are written as-is; their schemas land with S2/S5/S6 (T5–T6). */
 const JSON_SLOTS = {
+    'url-sources': { ord: 0.25, path: '00a-url-sources.json', schema: UrlSourceSet },
     'run-brief': { ord: 0.5, path: '00b-run-brief.json', schema: RunBrief },
-    'intent-contract': { ord: 1, path: '01-intent-contract.json', schema: IntentContract },
+    'intent-contract': { ord: 1, path: '01-intent-contract.json', schema: DecisionContractArtifact },
+    'preflight-readings': { ord: 2, path: '02-preflight-readings.json', schema: PreflightArtifact },
     'misunderstanding-guard': { ord: 2, path: '02-misunderstanding-guard.json', schema: null },
     'drift-report': { ord: 5, path: '05-drift-report.json', schema: null },
+    positions: { ord: 6, path: '06-positions.json', schema: null },
+    'coverage-fill': { ord: 6.5, path: '06b-coverage-fill.json', schema: IdeaRoleOutput },
     claims: { ord: 6, path: '06-claims.json', schema: null },
+    'decision-graph': { ord: 7, path: '07-decision-graph.json', schema: DecisionGraph },
     'disagreement-map': { ord: 7, path: '07-disagreement-map.json', schema: DisagreementMap },
     // code-review's stage-7 artifact (ord 7, distinct path). A run writes one of {disagreement-map,
     // review-map} depending on its workflow, so the shared ord never collides within a run.
     'review-map': { ord: 7, path: '07-review-map.json', schema: ReviewMap },
-    verifications: { ord: 8, path: '08-verifications.json', schema: VerificationSet },
+    verifications: { ord: 8, path: '08-verifications.json', schema: VerificationArtifact },
+    rebuttals: { ord: 8.5, path: '08b-rebuttals.json', schema: RebuttalEventSet },
     'judge-report': { ord: 9, path: '09-judge-report.json', schema: JudgeReport },
-    'action-plan': { ord: 9.5, path: '09b-action-plan.json', schema: ActionPlan },
+    'action-plan': { ord: 9.5, path: '09b-action-plan.json', schema: ActionPlanArtifact },
+    // machine-readable final report (three-level report v4); schema-less: derived output, never re-read by stages
+    'decision-report': { ord: 10, path: '10-decision-report.json', schema: null },
 };
 /** Text (markdown) stage slots (§15). */
 const TEXT_SLOTS = {

package/dist/tui/app.js

@@ -8,8 +8,9 @@ import Spinner from 'ink-spinner';
 import TextInput from 'ink-text-input';
 import { readFile } from 'node:fs/promises';
 import { basename, dirname, join, resolve } from 'node:path';
-import { DISPLAY_NAME } from '../providers/types.js';
-import { RunCtx, DEFAULT_BUDGET, makeRunId, resolveRoles, setupProviders, } from '../orchestration/context.js';
+import { DISPLAY_NAME, PROVIDER_IDS } from '../providers/types.js';
+import { preflightLine, runDoctorChecks } from '../cli/doctor.js';
+import { RunCtx, makeRunId, resolveRoles, setupProviders, } from '../orchestration/context.js';
 import { executeRun } from '../orchestration/engine.js';
 import { RunWriter } from '../storage/runs.js';
 import { recordSession, updateSessionStatus, readSessions, findSession } from '../storage/sessions.js';
@@ -21,6 +22,8 @@ import { CR_STAGES, runCodeReview } from '../workflows/code-review.js';
 import { computeDiff, computeWorkingTreeDiff, detectRepoStatus } from '../orchestration/git.js';
 import { loadCouncilView } from '../council/view.js';
 import { openCouncilHtml } from '../council/open.js';
+import { readJsonArtifact } from '../storage/runs-read.js';
+import { defaultBudgetFor, defaultDeadlineFor, inferIdeaMode } from '../orchestration/modes.js';
 import { GLYPH, displayNames, elapsedLabel, initTimeline, markEnd, markStart, progressBar, runningPhrase, totalElapsed } from './timeline.js';
 import { formatCompletion, formatError } from './format.js';
 import { COMMANDS, PRODUCT_LINE, filterCommands, parseCommand, routeInput, scopeRedirect, suggestCommand } from './smart-entry.js';
@@ -28,7 +31,7 @@ async function loadCompletion(dir) {
     try {
         const [judge, map] = await Promise.all([
             readFile(join(dir, '09-judge-report.json'), 'utf8').then((s) => JSON.parse(s)),
-            readFile(join(dir, '07-disagreement-map.json'), 'utf8').then((s) => JSON.parse(s)),
+            readFile(join(dir, '07-decision-graph.json'), 'utf8').then((s) => JSON.parse(s)),
         ]);
         return formatCompletion(dir, judge, map);
     }
@@ -67,16 +70,24 @@ export function App(props) {
     const [aborted, setAborted] = useState(false);
     const abortRef = useRef(null);
     const ctxRef = useRef(null);
-    // Detect providers + repo context once, up front.
+    // Startup preflight (full doctor: CLI presence, version, auth/quota smoke — smoke cached ≤6h).
+    const [checks, setChecks] = useState({});
+    const [preflightFail, setPreflightFail] = useState(null);
+    // Full doctor preflight + provider handles + repo context once, up front. The menu only shows
+    // when ≥2 providers pass; a failure stays on this screen with the exact fix per provider.
     useEffect(() => {
         let alive = true;
-        void Promise.all([setupProviders(providerModels), detectRepoStatus(process.cwd())]).then(([hs, repoStatus]) => {
+        void Promise.all([
+            setupProviders(providerModels),
+            runDoctorChecks({ onRow: (row) => { if (alive)
+                    setChecks((prev) => ({ ...prev, [row.det.id]: preflightLine(row) })); } }),
+            detectRepoStatus(process.cwd()),
+        ]).then(([hs, report, repoStatus]) => {
             if (!alive)
                 return;
             setRepo(repoStatus);
-            if (hs.length < 2) {
-                setErrorView(formatError('QUORUM'));
-                setPhase('finished');
+            if (report.ready < 2 || hs.length < 2) {
+                setPreflightFail(report);
                 return;
             }
             setHandles(hs);
@@ -93,6 +104,8 @@ export function App(props) {
         const t = setInterval(() => setNow(Date.now()), 500);
         return () => clearInterval(t);
     }, [phase]);
+    // Preflight rows that failed but left quorum intact — surfaced as a warning on the home screen.
+    const degraded = Object.values(checks).filter((line) => !!line && !line.ok);
     // V10 command palette: matches for what's being typed (only on the input screen, not mid-confirm).
     const paletteMatches = phase === 'input' && pendingIdea === null ? filterCommands(idea) : [];
     const selIdx = Math.min(sel, Math.max(paletteMatches.length - 1, 0));
@@ -130,6 +143,11 @@ export function App(props) {
                 exit();
             return;
         }
+        // Failed preflight: any of q / Esc / Enter leaves — there is nothing else to do here.
+        if (phase === 'detecting' && preflightFail && (input === 'q' || key.escape || key.return)) {
+            exit();
+            return;
+        }
         // V10 confirm gate: the TextInput is unmounted while pending, so Enter/Esc arrive here only.
         if (phase === 'input' && pendingIdea !== null) {
             if (key.return) {
@@ -198,7 +216,7 @@ export function App(props) {
         if (phase === 'finished')
             exit();
     });
-    const startRun = (wf, text, cwd, runner, stages, replay) => {
+    const startRun = (wf, text, cwd, runner, stages, replay, mode) => {
         const trimmed = text.trim();
         if (!trimmed)
             return;
@@ -242,7 +260,20 @@ export function App(props) {
                 setPhase('clarify');
             }),
         };
-        const ctx = new RunCtx({ runId, workflow: wf, handles, roles: rs, writer, cwd: cwd ?? writer.dir, budget: budgetOverride, signal: controller.signal, events, replay });
+        const ctx = new RunCtx({
+            runId,
+            workflow: wf,
+            mode,
+            handles,
+            roles: rs,
+            writer,
+            cwd: cwd ?? writer.dir,
+            budget: budgetOverride,
+            deadlineMs: defaultDeadlineFor(wf, mode),
+            signal: controller.signal,
+            events,
+            replay,
+        });
         ctxRef.current = ctx;
         setWorkflow(wf);
         setRows(initTimeline(stages, rs, available));
@@ -268,7 +299,9 @@ export function App(props) {
             setPhase('finished');
         });
     };
-    const startIdea = (text) => startRun('idea-refinement', text, null, runIdeaRefinement, IDEA_STAGES);
+    const startIdea = (text) => {
+        startRun('idea-refinement', text, null, runIdeaRefinement, IDEA_STAGES, undefined, inferIdeaMode(text));
+    };
     const startCodeReview = async (action) => {
         if (!repo || !repo.defaultBranch) {
             setRouterMessage('code review needs a git repo with a detectable default branch');
@@ -341,7 +374,8 @@ export function App(props) {
         if (replay.size === 0)
             return void setRouterMessage(`no completed calls for ${sess.id} — start fresh`);
         const [runner, stages] = wf === 'code-review' ? [runCodeReview, CR_STAGES] : [runIdeaRefinement, IDEA_STAGES];
-        startRun(wf, input, wf === 'code-review' ? sess.cwd : null, runner, stages, replay);
+        const meta = await readJsonArtifact(oldDir, 'meta.json');
+        startRun(wf, input, wf === 'code-review' ? sess.cwd : null, runner, stages, replay, meta?.mode);
     };
     const runCommand = async (p) => {
         setRouterMessage('');
@@ -421,9 +455,14 @@ export function App(props) {
         setPendingIdea(text);
     };
     // ── render ────────────────────────────────────────────────────────────────
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, color: "cyan", children: "aiki" }), version ? _jsxs(Text, { dimColor: true, children: [" v", version] }) : null, _jsxs(Text, { dimColor: true, children: [" \u00B7 ", phase === 'input' ? 'local model council — ideas & code review' : workflow] })] }), phase === 'detecting' && (_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), ' ', "detecting providers\u2026"] })), (phase === 'input' || phase === 'running' || phase === 'grill' || phase === 'clarify' || phase === 'finished') && handles.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [repo && (_jsxs(Text, { children: ["repo: ", repo.name, " \u2014 ", repo.changedFiles, " changed files vs ", repo.defaultBranch ?? 'unknown default branch'] })), _jsxs(Text, { children: [handles.map((h, i) => (_jsxs(Text, { children: [i > 0 ? _jsx(Text, { dimColor: true, children: " \u00B7 " }) : null, _jsx(Text, { color: "green", children: "\u2714" }), " ", DISPLAY_NAME[h.id], h.version ? _jsxs(Text, { dimColor: true, children: [" ", h.version] }) : null] }, h.id))), _jsx(Text, { dimColor: true, children: " \u2014 council ready" })] })] })), phase === 'input' && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "/idea " }), _jsx(Text, { dimColor: true, children: '<text>' }), '   stress-test an idea'] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "/review " }), _jsx(Text, { dimColor: true, children: "[--branch]" }), '  review your changes', repo ? '' : _jsx(Text, { dimColor: true, children: "  (needs a git repo)" })] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "/resume " }), _jsx(Text, { dimColor: true, children: '<id>' }), '   continue a stopped run  ·  ', _jsx(Text, { color: "cyan", children: "/sessions" }), '  ', _jsx(Text, { color: "cyan", children: "/models" }), '  ', _jsx(Text, { color: "cyan", children: "/config" }), '  ', _jsx(Text, { color: "cyan", children: "/help" })] })] }), pendingIdea !== null ? (
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, color: "cyan", children: "aiki" }), version ? _jsxs(Text, { dimColor: true, children: [" v", version] }) : null, _jsxs(Text, { dimColor: true, children: [" \u00B7 ", phase === 'input' ? 'local model council — ideas & code review' : workflow] })] }), phase === 'detecting' && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "preflight \u2014 checking provider CLIs, auth & quota (smoke cached \u22646h)" }), PROVIDER_IDS.map((id) => {
+                        const line = checks[id];
+                        return (_jsxs(Text, { children: [line
+                                    ? line.ok ? _jsx(Text, { color: "green", children: "\u2714" }) : _jsx(Text, { color: "red", children: "\u2716" })
+                                    : _jsx(Text, { color: "yellow", children: _jsx(Spinner, { type: "dots" }) }), ' ', line ? line.label : `${DISPLAY_NAME[id]} — checking…`, line?.fix ? _jsxs(Text, { dimColor: true, children: ["  \u2192  ", line.fix] }) : null] }, id));
+                    }), preflightFail && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { color: "red", bold: true, children: ["preflight failed \u2014 ", preflightFail.ready, "/3 providers ready (aiki needs 2)"] }), _jsx(Text, { dimColor: true, children: "apply the fix shown next to each \u2716, then run `aiki` again \u00B7 `aiki doctor --fresh` re-checks live \u00B7 q quits" })] }))] })), (phase === 'input' || phase === 'running' || phase === 'grill' || phase === 'clarify' || phase === 'finished') && handles.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [repo && (_jsxs(Text, { children: ["repo: ", repo.name, " \u2014 ", repo.changedFiles, " changed files vs ", repo.defaultBranch ?? 'unknown default branch'] })), _jsxs(Text, { children: [handles.map((h, i) => (_jsxs(Text, { children: [i > 0 ? _jsx(Text, { dimColor: true, children: " \u00B7 " }) : null, _jsx(Text, { color: "green", children: "\u2714" }), " ", DISPLAY_NAME[h.id], h.version ? _jsxs(Text, { dimColor: true, children: [" ", h.version] }) : null] }, h.id))), _jsx(Text, { dimColor: true, children: " \u2014 council ready" })] }), degraded.length > 0 && (_jsxs(Text, { color: "yellow", children: ["\u26A0 ", degraded.map((line) => `${line.label}${line.fix ? ` (${line.fix})` : ''}`).join(' · '), " \u2014 continuing with ", Math.max(handles.length - degraded.length, 0), "/3 providers"] }))] })), phase === 'input' && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "/idea " }), _jsx(Text, { dimColor: true, children: '<text>' }), '   stress-test an idea'] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "/review " }), _jsx(Text, { dimColor: true, children: "[--branch]" }), '  review your changes', repo ? '' : _jsx(Text, { dimColor: true, children: "  (needs a git repo)" })] }), _jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "/resume " }), _jsx(Text, { dimColor: true, children: '<id>' }), '   continue a stopped run  ·  ', _jsx(Text, { color: "cyan", children: "/sessions" }), '  ', _jsx(Text, { color: "cyan", children: "/models" }), '  ', _jsx(Text, { color: "cyan", children: "/config" }), '  ', _jsx(Text, { color: "cyan", children: "/help" })] })] }), pendingIdea !== null ? (
                     /* V10 confirm gate — nothing spends model calls until Enter. */
-                    _jsxs(Box, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [_jsx(Text, { children: "Run the idea council on:" }), _jsxs(Text, { color: "cyan", children: ["  \u201C", pendingIdea.length > 100 ? `${pendingIdea.slice(0, 97)}…` : pendingIdea, "\u201D"] }), _jsxs(Text, { dimColor: true, children: ["  12-stage pipeline \u00B7 up to ", budgetOverride ?? DEFAULT_BUDGET, " model calls \u00B7 Ctrl+C aborts mid-run"] }), _jsxs(Text, { children: [_jsx(Text, { color: "green", children: "enter" }), " run  \u00B7  ", _jsx(Text, { color: "yellow", children: "esc" }), " cancel"] })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "Type a command, or just describe your idea and press Enter:" }), _jsxs(Box, { borderStyle: "round", paddingX: 1, children: [_jsx(Text, { children: "\u25B8 " }), _jsx(TextInput, { value: idea, onChange: (v) => setIdea(v.replace(/\s*[\r\n]+\s*/g, ' ').replace(/\t/g, '')), onSubmit: submitInput }, inputEpoch)] })] })), paletteMatches.length > 0 && (
+                    _jsxs(Box, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [_jsx(Text, { children: "Run the idea council on:" }), _jsxs(Text, { color: "cyan", children: ["  \u201C", pendingIdea.length > 100 ? `${pendingIdea.slice(0, 97)}…` : pendingIdea, "\u201D"] }), _jsxs(Text, { dimColor: true, children: ["  10-stage pipeline \u00B7 ", inferIdeaMode(pendingIdea), " mode \u00B7 up to ", budgetOverride ?? defaultBudgetFor('idea-refinement', inferIdeaMode(pendingIdea)), " model calls \u00B7 Ctrl+C aborts mid-run"] }), _jsxs(Text, { children: [_jsx(Text, { color: "green", children: "enter" }), " run  \u00B7  ", _jsx(Text, { color: "yellow", children: "esc" }), " cancel"] })] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "Type a command, or just describe your idea and press Enter:" }), _jsxs(Box, { borderStyle: "round", paddingX: 1, children: [_jsx(Text, { children: "\u25B8 " }), _jsx(TextInput, { value: idea, onChange: (v) => setIdea(v.replace(/\s*[\r\n]+\s*/g, ' ').replace(/\t/g, '')), onSubmit: submitInput }, inputEpoch)] })] })), paletteMatches.length > 0 && (
                     /* V10 live command palette — filtered as you type; ↑↓ move, Tab completes, Enter runs. */
                     _jsxs(Box, { flexDirection: "column", borderStyle: "round", paddingX: 1, children: [paletteMatches.map((m, i) => (_jsxs(Text, { children: [_jsxs(Text, { color: i === selIdx ? 'cyan' : undefined, bold: i === selIdx, children: [i === selIdx ? '▸ ' : '  ', "/", m.name] }), _jsx(Text, { dimColor: true, children: `  ${m.usage.replace(`/${m.name}`, '').trim().padEnd(10)}  ${m.help}` })] }, m.name))), _jsx(Text, { dimColor: true, children: "\u2191\u2193 select \u00B7 tab complete \u00B7 enter run" })] })), routerMessage ? _jsx(Text, { color: "yellow", children: routerMessage }) : null, panel ? (_jsx(Box, { flexDirection: "column", marginTop: 1, borderStyle: "round", paddingX: 1, children: panel.split('\n').map((l, i) => (_jsx(Text, { children: l }, i))) })) : (_jsx(Text, { dimColor: true, children: "new here? /help explains how aiki works \u00B7 long idea? `aiki run idea-refinement ./idea.md`" }))] })), (phase === 'running' || phase === 'grill' || phase === 'clarify' || phase === 'finished') && rows.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [rows.map((r) => {
                         const color = r.status === 'done' ? 'green' : r.status === 'failed' ? 'red' : r.status === 'running' ? 'yellow' : 'gray';

package/dist/tui/format.js

@@ -1,11 +1,10 @@
 // Pure formatters for the completion + error screens (T8, §4.3, §471). No Ink — unit-tested directly.
 /** Completion summary (§4.3): verdict + the top-N contradictions with their adjudication ruling. */
-export function formatCompletion(dir, judge, map, topN = 3) {
+export function formatCompletion(dir, judge, graph, topN = 3) {
     const ruling = new Map(judge.adjudications.map((a) => [a.id, a.ruling]));
-    const disagreements = map.contradictions.slice(0, topN).map((d) => {
-        const r = ruling.get(d.id) ?? 'UNRESOLVED';
-        const arg = d.attacks[0]?.argument ?? '';
-        return `${d.id} → ${r}: ${arg}`;
+    const disagreements = graph.claims.filter((claim) => claim.state === 'DISAGREEMENT').slice(0, topN).map((claim) => {
+        const result = ruling.get(claim.id) ?? 'UNRESOLVED';
+        return `${claim.id} → ${result}: ${claim.proposition}`;
     });
     return { verdict: judge.verdict, disagreements, reportPath: `${dir}/final-report.md`, rawPath: `${dir}/raw/` };
 }

package/dist/tui/smart-entry.js

@@ -1,6 +1,22 @@
 export const PRODUCT_LINE = 'aiki stress-tests ideas and reviews code; for general questions use a single model — a council adds cost, not accuracy, when there is one right answer.';
 const QUESTION_START = /^(what|why|how|who|when|where|is|are|can|could|should|would|do|does|did|will)\b/i;
-const CODE_MARKER = /(diff --git|^@@|\+\+\+ b\/|--- a\/|```|[A-Za-z0-9_-]+\/[A-Za-z0-9_./-]+\.(ts|tsx|js|jsx|py|go|rs|java|rb|php|css|html|md)\b|\b(function|const|let|class|import|export)\b|[{};])/m;
+// Detect PASTED code / a diff, NOT prose that merely contains a code-ish word. Bare keywords
+// (`class`, `export`, `import`) and a lone `;`/`{`/`}` collide with ordinary English — "a class
+// scheduling app; export our data" is an idea, not a diff — so every alternative below requires code
+// *structure*: a diff/fence marker, a file path with a code extension, arrow/`){`, or a keyword in
+// real syntax (`class Foo {`, `const x =`, `import { … }` / `import x from '…'`, `export default/const…`).
+const CODE_MARKER = new RegExp([
+    'diff --git', '^@@', '^\\+\\+\\+ b/', '^--- a/', // unified-diff headers
+    '```', // markdown code fence
+    '[A-Za-z0-9_-]+/[A-Za-z0-9_./-]+\\.(?:ts|tsx|js|jsx|py|go|rs|java|rb|php|css|html|md)\\b', // path/to/file.ext
+    '=>', // arrow function
+    '\\)\\s*\\{', // ) { — block open
+    '\\bfunction\\s+[A-Za-z_$][\\w$]*\\s*\\(|\\bfunction\\s*\\(', // function foo( / function(
+    '\\bclass\\s+[A-Za-z_$][\\w$]*\\s*(?:\\{|extends\\b)', // class Foo { / class Foo extends
+    '\\b(?:const|let|var)\\s+[A-Za-z_$][\\w$]*\\s*=', // const x =
+    "\\bimport\\s+(?:\\{|[\\w$]+\\s+from\\s+['\"]|['\"])", // import { … } / import x from '…' / import '…'
+    '\\bexport\\s+(?:default|const|let|var|function|class|async|\\{)', // export default / export const / …
+].join('|'), 'm');
 // ── Scope redirect (V10.2) — catch "explore my whole codebase / brainstorm features for me" asks and
 // point them at the right door, instead of silently stress-testing the request sentence as an "idea".
 // aiki reviews a DIFF and vets a STATED idea; it does not roam a repo (§3/§22). Pure + deterministic. ──

package/dist/tui/timeline.js

@@ -56,15 +56,13 @@ export const displayNames = (ps) => ps.map((p) => DISPLAY_NAME[p]).join(', ');
 // ── V10 run-screen life: rotating status phrases + progress bar + total time. Pure; unit-tested. ────
 /** Stage-flavored status phrases, rotated every 4s so long stages feel alive (not stuck). */
 const PHRASES = {
-    S0: ['grilling the intent', 'sharpening the run brief'],
-    S1: ['pinning down what you actually asked', 'writing the task contract'],
-    S2: ['checking every model read it the same way', 'guarding against a misread'],
-    S3: ["writing each seat's brief", 'tailoring the role prompts'],
+    S0: ['comparing two readings of your decision', 'sharpening one decision contract'],
     S4: ['council working in separate rooms', 'independent takes incoming'],
     S5: ['checking nobody drifted off-task', 'comparing echoes against the contract'],
     S6: ['boiling the output down to claims', 'extracting the claims'],
     S7: ['mapping where they disagree', 'drawing the disagreement map'],
     S8: ['cross-examining the claims', 'stress-testing the evidence'],
+    S8b: ['rebutting only what could flip the verdict', 'testing the decisive conflict'],
     S9: ['the judge is deliberating', 'weighing evidence over confidence'],
     S9b: ['planning decisive validation', 'ordering the next tests'],
     S10: ['writing the report', 'assembling the decision brief'],

package/dist/workflows/code-review.js

@@ -10,6 +10,7 @@ import { resolve } from 'node:path';
 import { runStage } from '../orchestration/context.js';
 import { parseDiffFiles } from '../orchestration/git.js';
 import { s4Review } from '../orchestration/stages/cr-s4-review.js';
+import { mergeCoverageHunt, runCoverageHunts } from '../orchestration/stages/cr-ladder.js';
 import { s8CrossExam } from '../orchestration/stages/cr-s8-crossexam.js';
 import { buildReviewMap } from '../orchestration/stages/cr-map.js';
 import { s9ReviewJudge } from '../orchestration/stages/cr-s9-judge.js';
@@ -44,7 +45,7 @@ export const CR_STAGES = [
     { id: 'S9', label: 'Judge adjudication', role: 'judge' },
     { id: 'S10', label: 'Report', role: null },
 ];
-export async function runCodeReview(ctx, input) {
+export async function runCodeReview(ctx, input, opts = {}) {
     // `input` is the unified diff. Persist it where the reviewer prompt points; parse the touched files.
     await ctx.writer.writeInput('diff.patch', input);
     const diffPath = resolve(ctx.writer.dir, 'inputs', 'diff.patch');
@@ -63,10 +64,11 @@ export async function runCodeReview(ctx, input) {
     const prompt = buildReviewerPrompt(diffPath, loadSkill('code-review', 'reviewer'));
     await ctx.writer.writePrompt('reviewer.md', prompt);
     const reviewers = await runStage(ctx, 'S4', () => s4Review(ctx, prompt, files));
+    const ladder = opts.ladder ? await runStage(ctx, 'L', () => runCoverageHunts(ctx, input, reviewers)) : null;
     const cross = await runStage(ctx, 'S8', () => s8CrossExam(ctx, reviewers));
     // S7 — build + persist the ReviewMap (07), then the cross-exam verifications (08). Order: 07 < 08.
     const map = await runStage(ctx, 'S7', async () => {
-        const m = buildReviewMap(reviewers, cross.byKey);
+        const m = mergeCoverageHunt(buildReviewMap(reviewers, cross.byKey), ladder);
         await ctx.writer.writeJson('review-map', m);
         await ctx.writer.writeJson('verifications', { verifications: cross.verifications });
         return m;

package/dist/workflows/idea-refinement.js

@@ -1,25 +1,23 @@
-// idea-refinement workflow (§12.1). Stage COMPOSITION only — no orchestration mechanics (those
-// live in the engine) and, for now, prompts inline here rather than in skills/<workflow>/ (the
-// full skill loader + registry, §11, is deferred; it must not register without bench/ + validate.ts).
-//
-// v1 T5 scope: S1 → S2 → S3. S4–S10 are added as later tasks extend this composition.
+// idea-refinement composition. R6 collapses the old S0/S1/S2 model chain into two parallel
+// preflight readings and fills the S4 prompt deterministically; later stages remain typed boundaries.
 import { resolve } from 'node:path';
-import { runStage } from '../orchestration/context.js';
-import { renderGrilledInput, s0Grill } from '../orchestration/stages/s0-grill.js';
-import { s1Intent } from '../orchestration/stages/s1-intent.js';
-import { s2Misread } from '../orchestration/stages/s2-misread.js';
-import { s3Prompts } from '../orchestration/stages/s3-prompts.js';
+import { runStage, StageError } from '../orchestration/context.js';
 import { s4Analyze } from '../orchestration/stages/s4-analyze.js';
 import { s5Drift } from '../orchestration/stages/s5-drift.js';
-import { s6Claims } from '../orchestration/stages/s6-claims.js';
-import { s7Disagreement } from '../orchestration/stages/s7-disagreement.js';
+import { s6Positions } from '../orchestration/stages/s6-positions.js';
+import { s7DecisionGraph } from '../orchestration/stages/s7-decision-graph.js';
 import { s8Verify } from '../orchestration/stages/s8-verify.js';
+import { s8bRebuttal } from '../orchestration/stages/s8b-rebuttal.js';
 import { s9Judge } from '../orchestration/stages/s9-judge.js';
 import { s9bPlan } from '../orchestration/stages/s9b-plan.js';
 import { s10Render } from '../orchestration/stages/s10-render.js';
 import { loadSkill } from '../orchestration/skills.js';
-/** §12.1 idea-vetting rubric: 12 mandatory coverage items. S7 flags any item no analyst addressed
- *  as a blind spot. Inlined here (like the S4 template) while the skill/`rubric.json` loader (§11)
+import { buildLanePrompts } from '../orchestration/idea-lanes.js';
+import { preflight, renderDecisionInput } from '../orchestration/preflight.js';
+import { buildQuickPrompt, quickActionPlan, quickJudgeReport, s4QuickAnalyze } from '../orchestration/quick-analysis.js';
+import { snapshotUrlSources } from '../orchestration/url-sources.js';
+/** Idea-vetting core rubric: 13 mandatory coverage items. S0 adds 3-5 domain dimensions per run.
+ *  Inlined here (like the S4 template) while the skill/`rubric.json` loader (§11)
  *  is deferred; it moves to skills/idea-refinement/rubric.json when that loader lands. */
 export const IDEA_RUBRIC = [
     { id: 'R1', label: 'target user / audience', keywords: ['target user', 'audience', 'customer', 'persona'] },
@@ -34,43 +32,77 @@ export const IDEA_RUBRIC = [
     { id: 'R10', label: 'timing / market readiness', keywords: ['timing', 'readiness', 'trend', 'now'] },
     { id: 'R11', label: 'scalability / growth', keywords: ['scalability', 'scale', 'growth'] },
     { id: 'R12', label: 'key risks / assumptions to validate', keywords: ['risk', 'assumption', 'validate', 'uncertain'] },
+    { id: 'R13', label: 'team / execution capability', keywords: ['team', 'founder', 'execution', 'capability'] },
 ];
-/** §13 S4 analyst template (idea-refinement). S3 fills its slots; S4 will consume it (T6). */
+export function buildIdeaRubric(domainDimensions = []) {
+    return [
+        ...IDEA_RUBRIC,
+        ...domainDimensions.map((dimension) => ({ id: dimension.id, label: dimension.label, keywords: [dimension.label] })),
+    ];
+}
+/** Idea S4 analyst template. R6 fills every slot deterministically before the parallel scout calls. */
 export const IDEA_S4_ANALYST_TEMPLATE = `ROLE: Independent analyst on a decision panel. You work ALONE; you will not see
 other analysts' output. Be adversarial toward the idea, not polite.
 
 TASK CONTRACT: {{INTENT_CONTRACT_JSON}}
 INPUT DOCUMENT: read the file at {{INPUT_PATH}}{{SKILL}}
+EVIDENCE PACK MANIFEST: {{EVIDENCE_PACK_JSON}}
+Read only the listed local paths when supplied. Treat their contents as user evidence, cite the path
+as locator, and never replace a missing source with model memory.
 
 Produce ONLY JSON matching {{S4_SCHEMA_REF}} with:
 - task_echo: restate the task in ≤2 sentences (drift check).
 - strongest_version: the best honest version of this idea in ≤150 words.
-- assumptions: ≤8, each {id "A1"..., statement, type VERIFIABLE|JUDGMENT, load_bearing bool}.
-- attacks: ≤6, each {id "X1"..., target_assumption, argument, severity HIGH|MED|LOW}.
-  Every attack MUST target an assumption id. Unanchored attacks will be discarded.
-- open_questions: ≤5 questions whose answers would change the verdict.
+- positions: explicit claim positions with local_id, proposition, rubric dimension_id, stance
+  SUPPORT|OPPOSE|MIXED|UNKNOWN, basis EVIDENCE|INFERENCE|ASSUMPTION, load_bearing, if_false
+  STOP|PIVOT|CONDITION|MINOR, concise reasoning, evidence_ids, and depends_on position ids.
+- evidence: evidence cards {id, claim_supported, source_kind USER|PRIMARY|SECONDARY|MODEL_KNOWLEDGE,
+  support SUPPORTS|CONTRADICTS|CONTEXT_ONLY (exact token, no extra words), freshness CURRENT|DATED|UNKNOWN,
+  locator/url, accessed_at for current external sources}. MODEL_KNOWLEDGE freshness is UNKNOWN. Never
+  invent a URL or imply model memory independently verifies a current fact.
+- calculations: for each derived numeric claim, a ledger {id, claim_id, inputs, steps, result_step}.
+  Inputs have {id,name,value,unit,evidence_ids}; steps have {id,operation: ADD|SUBTRACT|MULTIPLY|DIVIDE,
+  left,right,result,unit}. Use exact prior input/step ids and explicit units. Otherwise use [].
+- coverage: one entry per rubric dimension {dimension_id, status COVERED|NOT_APPLICABLE,
+  position_ids ([] when none), rationale (required for NOT_APPLICABLE)}.
+- decision_questions: questions {question, claim_ids} whose answers could change the verdict.
+Caps: at most 12 positions, 20 evidence cards, 8 calculations, 8 decision_questions.
 Rules: no motivation, no summaries of your own output, no markdown, JSON only.`;
 /**
- * Resolve the {{SKILL}} slot in the analyst template BEFORE S3 (S3 is a model call that tailors the
- * template + errors on any leftover {{...}}). An empty skill collapses the slot → exact pre-skill
- * baseline; the S3 deterministic fallback then preserves the embedded playbook verbatim.
+ * Resolve the {{SKILL}} slot before deterministic structural fill. An empty skill collapses the slot
+ * to the pre-skill baseline.
  */
 export function buildAnalystTemplate(skill) {
     return IDEA_S4_ANALYST_TEMPLATE.replace('{{SKILL}}', skill ? `\n\n${skill}` : '');
 }
+/** R6 deterministic S4 prompt fill. No model-authored prompt generation remains. */
+export function buildAnalystPrompt(contract, inputPath, evidencePack, mode, skill) {
+    const modeRules = mode === 'research'
+        ? `\n\nMODE: research. Use provider-native read-only source investigation when available. Every current
+fact must have an independently checkable locator and access date. If investigation is unavailable,
+leave the claim unverified; never invent a source.`
+        : `\n\nMODE: council. Analyze independently; do not assume another seat will cover your lane.`;
+    const prompt = buildAnalystTemplate(skill)
+        .replace('{{INTENT_CONTRACT_JSON}}', JSON.stringify(contract))
+        .replace('{{INPUT_PATH}}', inputPath)
+        .replace('{{EVIDENCE_PACK_JSON}}', JSON.stringify(evidencePack ?? { files: [] }))
+        .replace('{{S4_SCHEMA_REF}}', 'the idea-refinement S4 RoleOutput schema')
+        + modeRules;
+    if (/\{\{[^}]+\}\}/.test(prompt))
+        throw new StageError('S3', 'BAD_OUTPUT', 'deterministic analyst prompt has an unresolved slot');
+    return prompt;
+}
 /** Timeline manifest (T8): the stages in order, each with the provider-role its row displays.
  *  The TUI draws the pending skeleton from this and resolves chips from `ctx.roles`. Ids match the
  *  `runStage` calls below. S7 shows the judge (it makes the grouping call); S5/S6/S10 are pure (—). */
 export const IDEA_STAGES = [
-    { id: 'S0', label: 'Intent preflight', role: 'analyst' },
-    { id: 'S1', label: 'Intent contract', role: 'analyst' },
-    { id: 'S2', label: 'Misunderstanding guard', role: 'all' },
-    { id: 'S3', label: 'Prompt generation', role: 'analyst' },
+    { id: 'S0', label: 'Two-view preflight', role: 's4' },
     { id: 'S4', label: 'Parallel analysis', role: 's4' },
     { id: 'S5', label: 'Drift check', role: null },
-    { id: 'S6', label: 'Claim extraction', role: null },
-    { id: 'S7', label: 'Disagreement map', role: 'judge' },
+    { id: 'S6', label: 'Position collection', role: null },
+    { id: 'S7', label: 'Decision graph', role: null },
     { id: 'S8', label: 'Verifier loop', role: 'verifier' },
+    { id: 'S8b', label: 'Selective rebuttal', role: 's4' },
     { id: 'S9', label: 'Judge synthesis', role: 'judge' },
     { id: 'S9b', label: 'Validation plan', role: 'judge' },
     { id: 'S10', label: 'Report', role: null },
@@ -79,27 +111,67 @@ export const IDEA_STAGES = [
  *  `executeRun` wrapper turns that into a graceful failure + meta. Each stage is wrapped in
  *  `runStage` so the TUI timeline (T8) gets start/end events; headless, that's a no-op. */
 export async function runIdeaRefinement(ctx, input) {
-    const brief = await runStage(ctx, 'S0', () => s0Grill(ctx, input));
-    const grilledInput = renderGrilledInput(input, brief);
-    const contract = await runStage(ctx, 'S1', () => s1Intent(ctx, grilledInput));
-    const guard = await runStage(ctx, 'S2', () => s2Misread(ctx, contract, grilledInput));
+    if (ctx.evidencePack)
+        await ctx.writer.writeInput('evidence-pack.json', JSON.stringify(ctx.evidencePack, null, 2));
+    const urlSources = await snapshotUrlSources(input);
+    await ctx.writer.writeJson('url-sources', urlSources);
+    const unreadableSources = urlSources.sources.filter((source) => source.status !== 'FETCHED');
+    if (ctx.mode === 'research' && unreadableSources.length > 0) {
+        const details = unreadableSources.map((source) => `${source.url} (${source.status}: ${source.error})`).join('; ');
+        throw new StageError('S0', 'SOURCE_UNREADABLE', `research stopped before model calls because a supplied source could not be read: ${details}. Paste the relevant text or provide a public export, then rerun.`);
+    }
+    const { contract, brief } = await runStage(ctx, 'S0', () => preflight(ctx, input, IDEA_RUBRIC.map((item) => item.label), urlSources));
+    const grilledInput = renderDecisionInput(input, brief, urlSources);
     // Persist the input as a file so S4's "read the file at {{INPUT_PATH}}" resolves (not a stage).
     await ctx.writer.writeInput('idea.md', input);
     await ctx.writer.writeInput('idea-brief.md', grilledInput);
     const inputPath = resolve(ctx.writer.dir, 'inputs', 'idea-brief.md');
-    const stagePrompts = await runStage(ctx, 'S3', () => s3Prompts(ctx, {
-        contract,
-        interpretation: guard.chosen.my_interpretation,
-        templates: { analyst: buildAnalystTemplate(loadSkill('idea-refinement', 'analyst')) },
-        slots: { INPUT_PATH: inputPath, S4_SCHEMA_REF: 'the idea-refinement S4 RoleOutput schema' },
-    }));
-    // s3Prompts guarantees an entry for every template key (it iterates them), so `analyst` is present.
-    const seats = await runStage(ctx, 'S4', () => s4Analyze(ctx, stagePrompts.prompts.analyst));
+    const rubric = buildIdeaRubric(contract.domain_dimensions);
+    const analystSkill = loadSkill('idea-refinement', 'analyst');
+    if (ctx.mode === 'quick') {
+        ctx.addFlag('single_model');
+        const quickPrompt = buildQuickPrompt(contract, inputPath, ctx.evidencePack, analystSkill);
+        await ctx.writer.writePrompt('quick-analyst.md', quickPrompt);
+        const quick = await runStage(ctx, 'S4', () => s4QuickAnalyze(ctx, quickPrompt));
+        const { kept } = await runStage(ctx, 'S5', () => s5Drift(ctx, contract, [quick.seat], 1));
+        const positions = await runStage(ctx, 'S6', () => s6Positions(ctx, kept));
+        const graph = await runStage(ctx, 'S7', () => s7DecisionGraph(ctx, positions, rubric, contract.task));
+        const verifications = await runStage(ctx, 'S8', async () => {
+            const result = { verifications: [] };
+            await ctx.writer.writeJson('verifications', result);
+            return result;
+        });
+        const rebuttals = await runStage(ctx, 'S8b', async () => {
+            const result = { round: 1, selected_claim_ids: [], events: [], stop_reason: 'NO_ESCALATIONS' };
+            await ctx.writer.writeJson('rebuttals', result);
+            return result;
+        });
+        const judgeReport = await runStage(ctx, 'S9', async () => {
+            const report = quickJudgeReport(quick.decision, graph);
+            await ctx.writer.writeJson('judge-report', report);
+            return report;
+        });
+        const actionPlan = await runStage(ctx, 'S9b', async () => {
+            const plan = quickActionPlan(ctx, quick.seat.provider, quick.decision, graph, contract);
+            await ctx.writer.writeJson('action-plan', plan);
+            return plan;
+        });
+        await runStage(ctx, 'S10', () => s10Render(ctx, { contract, seats: kept, graph, verifications, rebuttals, judgeReport, actionPlan, rubric, original: input }));
+        return;
+    }
+    if (ctx.mode === 'research' && !ctx.evidencePack && !ctx.available().includes('codex')) {
+        ctx.addFlag('research_ungrounded');
+    }
+    const analystPrompt = buildAnalystPrompt(contract, inputPath, ctx.evidencePack, ctx.mode, analystSkill);
+    await ctx.writer.writePrompt('analyst.md', analystPrompt);
+    const lanePrompts = buildLanePrompts(analystPrompt, rubric);
+    const seats = await runStage(ctx, 'S4', () => s4Analyze(ctx, lanePrompts));
     const { kept } = await runStage(ctx, 'S5', () => s5Drift(ctx, contract, seats));
-    const claimSet = await runStage(ctx, 'S6', () => s6Claims(ctx, kept));
-    const map = await runStage(ctx, 'S7', () => s7Disagreement(ctx, claimSet, kept, IDEA_RUBRIC));
-    const verifications = await runStage(ctx, 'S8', () => s8Verify(ctx, map));
-    const judgeReport = await runStage(ctx, 'S9', () => s9Judge(ctx, contract, map, verifications, IDEA_RUBRIC));
-    const actionPlan = await runStage(ctx, 'S9b', () => s9bPlan(ctx, contract, kept, map, judgeReport));
-    await runStage(ctx, 'S10', () => s10Render(ctx, { contract, seats: kept, map, verifications, judgeReport, actionPlan, rubric: IDEA_RUBRIC }));
+    const positions = await runStage(ctx, 'S6', () => s6Positions(ctx, kept));
+    const graph = await runStage(ctx, 'S7', () => s7DecisionGraph(ctx, positions, rubric, contract.task));
+    const verifications = await runStage(ctx, 'S8', () => s8Verify(ctx, graph));
+    const rebuttals = await runStage(ctx, 'S8b', () => s8bRebuttal(ctx, graph, verifications, ctx.mode));
+    const judgeReport = await runStage(ctx, 'S9', () => s9Judge(ctx, contract, graph, verifications, rubric, rebuttals));
+    const actionPlan = await runStage(ctx, 'S9b', () => s9bPlan(ctx, contract, kept, graph, judgeReport));
+    await runStage(ctx, 'S10', () => s10Render(ctx, { contract, seats: kept, graph, verifications, rebuttals, judgeReport, actionPlan, rubric, original: input }));
 }