aiki-cli 0.3.1 → 0.3.3

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

@@ -1,11 +1,11 @@
-# Analyst playbook — pressure-test the idea
+# Analyst playbook — strengthen and pressure-test the idea
 
-You are an adversarial analyst on a decision panel. Your job is not to like the idea — it is to find
-where it breaks. Steelman it once, then attack it honestly.
+You are an independent analyst on a decision panel. Build the strongest useful version for your lane,
+then expose where it breaks. Creation and criticism are both required.
 
 ## Strongest version first
 - 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.
+- Test THAT version, not a weak strawman. If the steelman is thin, that itself is a finding.
 
 ## Positions — make the stance explicit
 - State each decision-critical proposition and take an explicit SUPPORT, OPPOSE, MIXED, or UNKNOWN
@@ -45,5 +45,5 @@ ownership; emit one explicit coverage entry for every owned dimension.
 - 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 unsupported hype or generic feature wishlists. Explain the mechanism and user value.
 - No unanchored position or evidence. No proposition you cannot tie to the decision.

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

@@ -0,0 +1,18 @@
+# Chair playbook — rule on the real disagreement
+
+Add to your base instructions; the schema and caps are unchanged and always win.
+
+## Synthesis discipline
+- Count convergence only when seats reached the same conclusion independently with different evidence.
+  Two seats repeating the same hedge is not agreement.
+- Never smooth over a clash. State both readings, compare their evidence quality, and rule.
+- A strong dissent beats a weak majority. Side with the better-evidenced minority when warranted and
+  explain why in `key_points`.
+- Never answer "it depends". Choose the required verdict enum; put contingencies into concrete,
+  checkable conditions that name their claim.
+- Lead `key_points` with the evidence or result that would change the verdict.
+- Report a blind spot only when verification or rebuttal actually exposed it.
+
+## First action
+- Anchor the first action to the single cheapest check that could kill or confirm the decision.
+- Pick one thing first, not a list disguised as one action.

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

@@ -3,5 +3,16 @@
 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.
 
+Act as the skeptic/executor for requested deliverables. When FEATURE_BACKLOG is requested, produce 2–4
+`deliverable_proposals` that preserve the standout value while remaining credible under the stated deadline.
+When IMPLEMENTATION_PLAN is requested, propose the shortest build sequence with observable outcomes.
+
 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.
+
+## Lens discipline (council seat)
+- Contrarian: assume a fatal flaw and hunt it — the number that does not close, the unpriced dependency,
+  or the deadline that does not fit.
+- Executor: every recommendation must survive the question, "What do you do Monday morning?"
+- Stance strength must match evidence strength — a hunch is an UNKNOWN position with a question
+  attached, never a confident claim.

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

@@ -3,5 +3,17 @@
 Own target-user urgency, alternatives and status quo, differentiation, distribution and procurement,
 timing, and the team's ability to execute the required adoption motion.
 
+Act as the visionary product strategist for requested deliverables. When FEATURE_BACKLOG is requested,
+produce 3–6 bold but concrete `deliverable_proposals` that create a memorable user or demo moment; say why
+each is distinctive rather than listing ordinary table-stakes UI.
+
 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.
+
+## Lens discipline (council seat)
+- Expansionist: lean fully into this lane instead of hedging toward balance; the other seat and verifier
+  cover the rest. Name the undervalued upside with a number and evidence ID, or mark it UNKNOWN.
+- Outsider: read the pitch with zero context. If its framing would confuse a fresh reader, that is a
+  market finding, not a presentation footnote.
+- Stance strength must match evidence strength — a hunch is an UNKNOWN position with a question
+  attached, never a confident claim.

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

@@ -1,25 +1,31 @@
-# Planner playbook — decisive validation
+# Answer editor playbook — useful first, honest throughout
 
-You write the next tests after the council has already judged the idea. Do not plan the build.
-Plan only the cheapest validation work that can change the decision.
+You turn the council's work into the answer the user actually asked for. Lead with a clear product
+recommendation, select the strongest ideas from both seats, and make the result practical enough to act on.
 
-## Order
-- Start with upheld HIGH risks. If one fails, the idea should stop or change shape before any other work.
-- Then cover blind spots that could hide a blocker.
-- Then answer open questions that would flip the verdict.
+## Reader answer
+- Answer the original task directly. Do not narrate the council process.
+- Prefer specific product language: what to build, why users care, what makes it memorable, and what to do first.
+- Combine complementary proposals; remove duplicates and cautious filler.
+- Explain the user value or demo payoff of each standout idea, not merely its feature name.
+- Keep facts inside supported findings and sources. Present unevidenced product choices as recommendations,
+  never as established market facts.
+- Chair output is decision reasoning, not evidence. Reframe its unsupported certainty as a recommendation,
+  risk, or hypothesis unless the proposition also appears in supported findings.
+- Use plain-language caveats only when they could change the recommendation.
 
-## Action quality
-- Every action must be concrete enough that a person can run it this week.
-- Prefer interviews, landing-page smoke tests, pricing tests, manual concierge trials, prototype probes,
-  competitor checks, and policy checks over implementation work.
-- Tie every action to exactly one anchor in `validates`.
+## Requested deliverables
+- When a feature backlog is requested, make MUST the smallest compelling golden path. Use SHOULD and LATER
+  for real prioritization; WONT protects the concept from scope creep.
+- When an implementation plan is requested, give an outcome-driven build sequence with observable acceptance tests.
+- The reader brief should summarize these deliverables rather than repeat every field verbatim.
 
-## Kill signals
-- A kill signal is not "learn more". It is the result that stops, pivots, or narrows the idea.
-- Make the signal observable: a count, threshold, refusal pattern, legal blocker, cost ceiling, or
-  behavior that contradicts the assumption.
+## Validation actions
+- Keep 1–4 actions. Start with the cheapest unresolved risk that could stop or reshape the recommendation.
+- Every action must be concrete enough to run this week and tie to exactly one supplied anchor.
+- A kill signal must be observable: a threshold, refusal pattern, blocker, cost ceiling, or failed behavior.
 
 ## Do not
-- No product roadmap, scaffolding plan, architecture plan, or feature list.
-- No action for a claim the chair already settled.
-- No vague market research. No unanchored action.
+- No graph ids, verification labels, confidence formulas, audit vocabulary, or model-process commentary in reader_brief.
+- No generic "do more research" action.
+- No invented source or unsupported hype.

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

@@ -0,0 +1,15 @@
+# Rebuttal playbook — answer the strongest opposition
+
+Add to your base instructions; the schema and caps are unchanged and always win.
+
+## Review in this order
+1. Steelman the opposing position in one line before answering it.
+2. Name its biggest blind spot: the assumption it never checks. Attack that assumption with supplied
+   evidence IDs.
+3. Name what both sides missed. Use NARROW or UNRESOLVED instead of pretending it was covered.
+
+## Stance discipline
+- CONCEDE when the evidence beats your position. An early concession on a lost point preserves
+  credibility for the decision-critical dispute.
+- Never change a stance word without a supplied evidence ID.
+- Prefer a precise unresolved boundary over a broad defensive counterclaim.

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

@@ -0,0 +1,17 @@
+# Verifier playbook — try to disprove the claim
+
+Add to your base instructions; the schema and caps are unchanged and always win.
+
+## Refute first
+- Assume each claim is wrong. Hunt for the disconfirming reading of the same supplied evidence.
+- Confirm only after a serious refutation attempt fails.
+- Agreement without attempted refutation is analytically NOT_CHECKED, not SUPPORTED; express that
+  uncertainty with the closest allowed schema status rather than returning VERIFIED.
+- Judge the evidence, never its author.
+
+## Evidence discipline
+- Treat CONFLICTED as a finding, not an output enum: use the allowed status and record the exact two
+  clashing readings in the reasoning.
+- Never verify a value judgment as fact. Numbers, deadlines, and rule text can be checked; taste and
+  strategy remain positions for the chair.
+- Include one concise sentence describing the method used for each verification.

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 { ActionPlanArtifact, DecisionContractArtifact, DecisionGraph, DisagreementMap, IdeaRoleOutput, JudgeReport, PreflightArtifact, RebuttalEventSet, ReviewMap, RoleOutput, RunBrief, RunMeta, UrlSourceSet, VerificationArtifact } from '../schemas/index.js';
+import { ActionPlanArtifact, ChallengeDeltaSet, 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`);
@@ -33,6 +33,7 @@ const JSON_SLOTS = {
     '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 },
+    'challenge-deltas': { ord: 4.5, path: '04b-challenge-deltas.json', schema: ChallengeDeltaSet },
     '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 },

package/dist/workflows/idea-refinement.js

@@ -7,15 +7,19 @@ import { s5Drift } from '../orchestration/stages/s5-drift.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 { overlayClaimGroups } from '../orchestration/claim-groups.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';
 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';
+import { deterministicContract, preflight, renderDecisionInput } from '../orchestration/preflight.js';
+import { buildAdaptivePrompt, buildQuickPrompt, quickActionPlan, quickJudgeReport, s4QuickAnalyze } from '../orchestration/quick-analysis.js';
+import { blockedSourceStop, snapshotUrlSources } from '../orchestration/url-sources.js';
+import { compileDecisionGraph } from '../orchestration/decision-graph.js';
+import { structuralEscalationGates } from '../orchestration/auto-profile.js';
+import { overlayChallengeDeltas, s4bChallenge } from '../orchestration/stages/s4b-challenge.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. */
@@ -42,7 +46,7 @@ export function buildIdeaRubric(domainDimensions = []) {
 }
 /** 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.
+other analysts' output. Improve the strongest version and pressure-test it honestly within your assigned lane.
 
 TASK CONTRACT: {{INTENT_CONTRACT_JSON}}
 INPUT DOCUMENT: read the file at {{INPUT_PATH}}{{SKILL}}
@@ -54,7 +58,10 @@ 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.
 - positions: explicit claim positions with local_id, proposition, rubric dimension_id, stance
-  SUPPORT|OPPOSE|MIXED|UNKNOWN, basis EVIDENCE|INFERENCE|ASSUMPTION, load_bearing, if_false
+  SUPPORT|OPPOSE|MIXED|UNKNOWN, basis EVIDENCE|INFERENCE|ASSUMPTION, nature FACTUAL when the position
+  asserts something independently checkable about the world (rules, deadlines, prices, observed CLI
+  behavior, published numbers) or JUDGMENT for a design choice, recommendation, prioritization, or
+  prediction (when unsure use JUDGMENT), 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,
@@ -66,8 +73,11 @@ Produce ONLY JSON matching {{S4_SCHEMA_REF}} with:
 - 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.`;
+- deliverable_proposals: when requested_outputs includes FEATURE_BACKLOG or IMPLEMENTATION_PLAN, propose
+  concrete user-facing work as {output,title,detail,user_value,why_distinctive,evidence_ids}; otherwise [].
+  Proposals are recommendations, not factual claims. Use evidence_ids only when evidence directly supports them.
+Caps: at most 12 positions, 20 evidence cards, 8 calculations, 8 decision_questions, 8 deliverable_proposals.
+Rules: no unsupported hype, no summaries of your own output, no markdown, JSON only.`;
 /**
  * Resolve the {{SKILL}} slot before deterministic structural fill. An empty skill collapses the slot
  * to the pre-skill baseline.
@@ -77,11 +87,11 @@ export function buildAnalystTemplate(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
+    const modeRules = mode !== 'quick'
+        ? `\n\nMODE: full council. 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.`;
+        : `\n\nMODE: quick. Analyze independently and keep unsupported claims visibly unverified.`;
     const prompt = buildAnalystTemplate(skill)
         .replace('{{INTENT_CONTRACT_JSON}}', JSON.stringify(contract))
         .replace('{{INPUT_PATH}}', inputPath)
@@ -107,27 +117,122 @@ export const IDEA_STAGES = [
     { id: 'S9b', label: 'Validation plan', role: 'judge' },
     { id: 'S10', label: 'Report', role: null },
 ];
+/** Record guarantees observed at the surviving typed S4 boundary; never infer them from prompts. */
+export function recordIdeaOutcomeFlags(ctx, contract, seats) {
+    if (ctx.mode === 'quick')
+        return;
+    const requested = (contract.requested_outputs ?? [])
+        .filter((output) => output === 'FEATURE_BACKLOG' || output === 'IMPLEMENTATION_PLAN');
+    if (requested.some((output) => seats.some((seat) => !seat.output.deliverable_proposals.some((proposal) => proposal.output === output)))) {
+        ctx.addFlag('deliverable_gap');
+    }
+    const grounded = seats.some((seat) => {
+        const cited = new Set(seat.output.positions.flatMap((position) => position.evidence_ids));
+        return seat.output.evidence.some((card) => cited.has(card.id)
+            && (card.source_kind === 'PRIMARY' || card.source_kind === 'SECONDARY')
+            && card.freshness === 'CURRENT'
+            && Boolean(card.accessed_at && (card.url || card.locator))
+            && card.support !== 'CONTEXT_ONLY');
+    });
+    if (!grounded)
+        ctx.addFlag('research_ungrounded');
+}
 /** Runs the full idea-refinement pipeline S0–S10. Throws on any fatal condition; the engine's
  *  `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) {
     if (ctx.evidencePack)
         await ctx.writer.writeInput('evidence-pack.json', JSON.stringify(ctx.evidencePack, null, 2));
-    const urlSources = await snapshotUrlSources(input);
+    // v6 T10b: the CLI may have already snapshotted (and interactively cleared) the sources.
+    const urlSources = ctx.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 needsSourceFallback = ctx.mode !== 'quick' && unreadableSources.length > 0;
+    // v6 T10: ANY unreadable supplied source stops the run before paid calls unless the user
+    // explicitly proceeds (--allow-blocked-sources). Codex search no longer silences the ask —
+    // it runs in addition, once the user has chosen to proceed.
+    const stop = blockedSourceStop(urlSources, ctx.mode, ctx.allowBlockedSources ?? false);
+    if (stop)
+        throw new StageError('S0', 'SOURCE_UNREADABLE', `source investigation stopped before model calls: ${stop}`);
+    let contract;
+    let grilledInput;
+    if (ctx.fastPath) {
+        contract = await runStage(ctx, 'S0', async () => {
+            return deterministicContract(input, IDEA_RUBRIC.map((item) => item.label));
+        });
+        ctx.addFlag('headless_intent');
+        grilledInput = input;
+    }
+    else {
+        const result = await runStage(ctx, 'S0', () => preflight(ctx, input, IDEA_RUBRIC.map((item) => item.label), urlSources));
+        contract = result.contract;
+        grilledInput = renderDecisionInput(input, result.brief, urlSources);
     }
-    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 rubric = buildIdeaRubric(contract.domain_dimensions);
     const analystSkill = loadSkill('idea-refinement', 'analyst');
+    if (ctx.isAuto) {
+        ctx.addFlag('single_model');
+        const startedFast = ctx.fastPath;
+        const primaryPrompt = startedFast
+            ? buildQuickPrompt(contract, inputPath, ctx.evidencePack, analystSkill)
+            : buildAdaptivePrompt(contract, inputPath, ctx.evidencePack, analystSkill);
+        if (!startedFast)
+            await ctx.writer.writePrompt('auto-primary.md', primaryPrompt);
+        const quick = await runStage(ctx, 'S4', () => s4QuickAnalyze(ctx, primaryPrompt, {
+            persist: !startedFast,
+            stage: startedFast ? 'Q1' : 'S4-auto-primary',
+        }));
+        const provisional = compileDecisionGraph([{ provider: quick.seat.provider, submission: quick.seat.output }], rubric);
+        const gates = structuralEscalationGates(provisional);
+        if (gates.length) {
+            ctx.markAutoEscalated(gates.map((gate) => gate.reason));
+            if (startedFast) {
+                const result = await runStage(ctx, 'S0-auto', () => preflight(ctx, input, IDEA_RUBRIC.map((item) => item.label), urlSources));
+                contract = result.contract;
+            }
+        }
+        if (startedFast) {
+            if (gates.length === 0)
+                await ctx.writer.writeJson('intent-contract', contract);
+            await ctx.writer.writePrompt('quick-analyst.md', primaryPrompt);
+            await ctx.writer.writeRoleOutput(quick.seat.provider, quick.seat.output);
+        }
+        const challenge = gates.length
+            ? await runStage(ctx, 'S4b', () => s4bChallenge(ctx, provisional, gates, quick.seat.provider))
+            : { deltas: [] };
+        const { kept } = await runStage(ctx, 'S5', () => s5Drift(ctx, contract, [quick.seat], 1));
+        if (ctx.mode !== 'quick')
+            recordIdeaOutcomeFlags(ctx, contract, kept);
+        const positions = await runStage(ctx, 'S6', () => s6Positions(ctx, kept));
+        const graph = await runStage(ctx, 'S7', () => s7DecisionGraph(ctx, positions, rubric, contract.task));
+        const challenged = overlayChallengeDeltas(graph, challenge.deltas);
+        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, challenged);
+            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, challenged, contract);
+            await ctx.writer.writeJson('action-plan', plan);
+            return plan;
+        });
+        await runStage(ctx, 'S10', () => s10Render(ctx, { contract, seats: kept, graph: challenged, verifications, rebuttals, judgeReport, actionPlan, rubric, original: input }));
+        return;
+    }
     if (ctx.mode === 'quick') {
         ctx.addFlag('single_model');
         const quickPrompt = buildQuickPrompt(contract, inputPath, ctx.evidencePack, analystSkill);
@@ -159,19 +264,20 @@ export async function runIdeaRefinement(ctx, input) {
         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 seats = await runStage(ctx, 'S4', () => s4Analyze(ctx, lanePrompts, needsSourceFallback));
     const { kept } = await runStage(ctx, 'S5', () => s5Drift(ctx, contract, seats));
+    recordIdeaOutcomeFlags(ctx, contract, kept);
     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 }));
+    // v6 semantic join: S8's validated claim_groups upgrade cross-provider paraphrase states
+    // (UNIQUE → CONSENSUS/DISAGREEMENT/…) on a derived copy; the stored 07 artifact stays original.
+    const joined = overlayClaimGroups(graph, verifications.claim_groups);
+    const rebuttals = await runStage(ctx, 'S8b', () => s8bRebuttal(ctx, joined, verifications, ctx.mode));
+    const judgeReport = await runStage(ctx, 'S9', () => s9Judge(ctx, contract, joined, verifications, rubric, rebuttals));
+    const actionPlan = await runStage(ctx, 'S9b', () => s9bPlan(ctx, contract, kept, joined, judgeReport, input));
+    await runStage(ctx, 'S10', () => s10Render(ctx, { contract, seats: kept, graph: joined, verifications, rebuttals, judgeReport, actionPlan, rubric, original: input }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiki-cli",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Local-first AI model council for code review and idea stress-testing using Claude Code, Codex, and Gemini/Antigravity CLIs. No API keys.",
   "type": "module",
   "license": "MIT",
@@ -45,7 +45,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && node -e \"require('fs').copyFileSync('src/providers/profiles.json','dist/providers/profiles.json')\" && node -e \"require('fs').cpSync('src/skills','dist/skills',{recursive:true})\"",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && node -e \"require('fs').copyFileSync('src/providers/profiles.json','dist/providers/profiles.json')\" && node -e \"require('fs').cpSync('src/skills','dist/skills',{recursive:true})\" && node -e \"require('fs').cpSync('serve-ui','dist/serve-ui',{recursive:true})\"",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",