amicus 4.8.0 → 4.9.0

package/src/cli-handlers-council.js

@@ -8,7 +8,9 @@ const { sumWaveUsage, formatCost } = require('./utils/pricing');
 const { failJson, ERROR_CODES } = require('./utils/error-doc');
 const { buildReport } = require('./council/report');
 const { validateFindings, buildValidateDoc } = require('./council/findings');
-const { buildVerdict, readOverallVerdict, readPriorVerdictSurfaces, writeVerdictAtomic } = require('./council/verdict');
+const { buildVerdict, readOverallVerdict, readPriorVerdictSurfaces, readPriorVerdictIntent,
+  writeVerdictAtomic } = require('./council/verdict');
+const { readRun } = require('./council/run-state');
 const {
   runSave: runCouncilSave,
   runList: runCouncilList,
@@ -32,10 +34,19 @@ function runTally(inputPath, useJson, opts = {}) {
     return failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: `malformed tally input: ${e.message}`,
       hint: 'input needs meta.models, findings[], adjudications[], rankings[]' });
   }
+  // ⚠️ PR #200 round-5 B1 — DOOR PARITY with the MCP enum (mcp-tools.js ::
+  // amicus_council_tally, round-4 C1): raw JSON.parse, no schema, exact-match
+  // consumers, so a near-miss ('Task') slid past the gate below into the ledger.
+  // Refused whatever `opts.append` says — meta rides VERBATIM into tally.json.
+  const intent = record.meta && record.meta.intent;
+  if (intent !== undefined && intent !== 'task' && intent !== 'review') {
+    return failJson(useJson, { code: ERROR_CODES.BAD_ARGS, message: `malformed tally input: meta.intent must be 'task' or 'review', got ${JSON.stringify(intent)}`,
+      hint: "omit meta.intent for a review run; 'task' is the only spelling that marks a task run" });
+  }
   // Auto-append the run to the reliability ledger (consumed by `amicus council
-  // stats`). Tally is the council's finalize step, so this is where the row is
-  // recorded. Best-effort: a ledger write failure must not fail the tally.
-  if (opts.append !== false) {
+  // stats`) — tally is the council's finalize step. Best-effort: a ledger write
+  // failure must not fail the tally. v4.9 W5.4 gate 2: task runs never feed it.
+  if (opts.append !== false && intent !== 'task') {
     try { appendRun(record); }
     catch (e) { process.stderr.write(`Notice: council ledger append failed: ${e.message}\n`); }
   }
@@ -59,7 +70,19 @@ function renderRecord(r) {
     `  Cost: ${formatCost(cost)}\n`;
 }
 function renderStats(agg) {
-  if (!agg.length) { return 'No council runs recorded yet.\n'; }
+  // v4.9 W8 (ruling V5 / R10): an empty table is ambiguous — a fresh install and a
+  // task-only install look the same, because task runs never append a row (the
+  // intent gate in runTally above). Say so here rather than let silence imply that
+  // no council ever ran. Human render only; --json's doc shape is untouched.
+  // ⚠️ v4.9 fix round 2 (council C5): the line must be true on ANY empty ledger,
+  // and the first wording was not. "…a task-only install has no history here"
+  // ASSERTS which of the two states the reader is in, and printed that assertion
+  // on every fresh install, where it is false. An EXPLAINER of where rows come
+  // from disambiguates the same pair without claiming anything about the reader.
+  if (!agg.length) {
+    return 'No council runs recorded yet.\n'
+      + '(reliability history comes from review runs; task runs never write rows here)\n';
+  }
   // v4.7 GOA-7 D10: group keys may be executable ids (>16 chars) — size the
   // model column to the longest key; legacy (alias-keyed) groups get a notes
   // marker beside low-N.
@@ -191,11 +214,38 @@ function runVerdict(args, useJson) {
     // chair-output.md); tally.json carries no copy. Recover it from the RUN
     // folder — the tally's own directory, not `-o` — before rebuilding.
     const runDir = path.dirname(path.resolve(tallyPath));
-    const overallVerdict = readOverallVerdict(runDir, record.meta.runId);
+    // v4.9 fix round 2 (council B1/C2/C1), extended by fix round 3 (C3): the
+    // run's INTENT decides which chair scale this rebuild may read, and rides
+    // onto the rebuilt document. THREE carriers, because no one of them covers
+    // every leg: the record's own `meta.intent` is what the run dir's tally.json
+    // carries (tally.js copies meta verbatim) but a hand-assembled or
+    // MCP-supplied record has none; `run.json`'s checkpoint (run.js ::
+    // runCouncil) covers that leg but can itself be absent or foreign; and the
+    // run folder's own prior verdict.json carries the key too (verdict.js ::
+    // buildVerdict writes it), which is the last document standing when the
+    // other two are missing. All three are emit-when-'task', so they combine as
+    // a DISJUNCTION — absence is no vote, not a vote for review — and
+    // absent/unreadable on all three = review, the fail-closed direction and
+    // what every pre-v4.9 run is.
+    // ⚠️ PR #200 C2 + C3: the run.json and verdict.json reads carry the SAME
+    // runId guard as their siblings — verdict.js :: readOverallVerdict and
+    // verdict.js :: readPriorVerdictSurfaces — `!runId || doc.runId === runId`, waived
+    // only when the RECORD names no run, never when the DOCUMENT does not.
+    // Without it a stale or foreign document in the folder hands this rebuild
+    // another run's intent, and intent SELECTS THE CHAIR PARSER in the
+    // readOverallVerdict call just below — so the leak can also change
+    // overallVerdict to a phrase off the wrong scale, exactly the failure the
+    // foreign-verdict.json guard exists to prevent one file over. PR #200 round-5 B3 parenthesized the whole three-carrier disjunction below before the `?` — behaviour-identical (`||` already binds tighter than `?:`), readability only.
+    const runDoc = readRun(runDir);
+    const ownRunDoc = runDoc && (!record.meta.runId || runDoc.runId === record.meta.runId);
+    const intent = ((record.meta && record.meta.intent === 'task')
+      || (ownRunDoc && runDoc.intent === 'task')
+      || readPriorVerdictIntent(runDir, record.meta.runId) === 'task') ? 'task' : 'review';
+    const overallVerdict = readOverallVerdict(runDir, record.meta.runId, intent);
     // #87: tally.json carries neither seatLoss nor degrades — recover both from
     // the run folder's verdict the same way the chair line is recovered.
     const prior = readPriorVerdictSurfaces(runDir, record.meta.runId);
-    verdict = buildVerdict(record, decisions, { overallVerdict,
+    verdict = buildVerdict(record, decisions, { overallVerdict, intent,
       ...(prior.seatLoss ? { seatLoss: prior.seatLoss } : {}),
       ...(prior.degrades ? { degrades: prior.degrades } : {}) });
   }

package/src/cli-handlers-doctor.js

@@ -14,8 +14,11 @@ const electronMcpCheck = require('./utils/doctor-electron-mcp-check');
 const localProvidersCheck = require('./utils/doctor-local-providers-check');
 // v4.6.2 PR1 (spec §4) — the 'anthropic-base-url' check body.
 const baseUrlCheck = require('./utils/doctor-base-url-check');
+// B3 (council review of PR 198, issue 195) — the 'aliases' check body,
+// including its --fix repair of fabricated bare ids. Same split rationale.
+const aliasCheck = require('./utils/doctor-alias-check');
 
-const MAX_CATALOG_AGE_MS = 24 * 60 * 60 * 1000; // 24h (mirrors model-catalog DEFAULT_MAX_AGE_MS)
+const { DEFAULT_MAX_AGE_MS: MAX_CATALOG_AGE_MS } = require('./utils/model-catalog'); // 24h — single source
 
 /** #56: keep `doctor --fix`'s electron self-heal from ever hanging on a slow disk/network. */
 const FIX_TIMEOUT_MS = 90 * 1000;
@@ -41,6 +44,10 @@ function realDeps() {
     collectAliasSources: () => require('./utils/alias-audit').collectAliasSources(),
     findStaleAliases: (s, c) => require('./utils/alias-audit').findStaleAliases(s, c),
     findDriftedStoredAliases: (s, c) => require('./utils/alias-audit').findDriftedStoredAliases(s, c),
+    // B3: the narrow fabricated-bare-id repair class (pure detection) + the
+    // impure rewrite primitive `doctor --fix` calls when repairing one.
+    findFabricatedAliasRepairs: (s, c) => require('./utils/alias-audit').findFabricatedAliasRepairs(s, c),
+    repairAlias: (alias, newId) => aliasCheck.repairAlias(alias, newId),
     hasOpencodeBinary: () => {
       // Single source of truth shared with the runtime server-start guard.
       const { ensureNodeModulesBinInPath, hasOpencodeBinary } = require('./utils/path-setup');
@@ -156,20 +163,10 @@ async function runDoctorChecks(depsOverride = {}) {
       : { id: 'catalog', name: 'Model catalog', status: 'warn', message: `stale (${hrs}h old)`, hint: 'amicus models --refresh' };
   }));
 
-  checks.push(guard('aliases', 'Model aliases', () => {
-    const cache = d.readCache();
-    const catalog = (cache && cache.models) || [];
-    const sources = d.collectAliasSources();
-    const stale = d.findStaleAliases(sources, catalog);
-    const drifted = d.findDriftedStoredAliases(sources, catalog);
-    if (stale.length === 0 && drifted.length === 0) {
-      return { id: 'aliases', name: 'Model aliases', status: 'ok', message: catalog.length ? 'all resolve' : 'catalog empty — not checked', hint: null };
-    }
-    const parts = [];
-    if (stale.length) { parts.push(`${stale.length} stale: ${stale.map(s => s.alias).join(', ')}`); }
-    if (drifted.length) { parts.push(`${drifted.length} drifted: ${drifted.map(s => s.alias).join(', ')}`); }
-    return { id: 'aliases', name: 'Model aliases', status: 'warn', message: parts.join('; '), hint: 'amicus models --check' };
-  }));
+  // B3: self-heals in place under --fix (fabricated bare ids only) — see
+  // utils/doctor-alias-check.js for the check body and utils/alias-audit.js's
+  // findFabricatedAliasRepairs for the detection rule.
+  checks.push(guard('aliases', 'Model aliases', () => aliasCheck.evaluateAliasesCheck(d)));
 
   checks.push(guard('anthropic-base-url', 'ANTHROPIC_BASE_URL',
     () => baseUrlCheck.evaluateAnthropicBaseUrl(d)));

package/src/cli.js

@@ -590,7 +590,7 @@ Subcommands for 'council':
       [--debate] [--claude-review <file>] [--no-cost-gate] [--follow]
       [--fallback] [--no-fallback] [--on-complete <cmd>]
       [--template <name|path>] [--artifact <file>] [--var <k=v>]
-      [--pack <name|path>] [--tag <t>]
+      [--pack <name|path>] [--tag <t>] [--intent review|task]
                                 Run the full headless council engine (v4.0).
                                 Chair default: deepseek (must NOT be a bench seat).
                                 --critic and --lenses are mutually exclusive.
@@ -620,6 +620,8 @@ Subcommands for 'council':
                                 --pack <name|path> loads a saved pack (bench,
                                 chair, critic/lenses, options, template);
                                 explicit flags always override the pack's values.
+                                --intent task marks a task-mode run (v4.9);
+                                review is the default and is never stored.
                                 Exit: 0 full run, 2 degraded, 1 quorum/cost/validation.
   save <name> --models a,b,c    Save a named council preset (>=2 resolvable members)
     --json                     Machine-readable output

package/src/council/anonymize.js

@@ -35,7 +35,8 @@ const LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  *   `seatMap` (label -> seat id) is sparse by construction: a label lands in
  *   it only when `seats[i]` is a real bound seat that differs from its own
  *   alias — the shared emit-when-DIFFERENT predicate every other seat-emit
- *   producer uses (run-stats-entry.js:64: `seat.id !== seat.alias`). On a
+ *   producer uses (run-stats-entry.js :: buildRunStatsEntry —
+ *   `seat.id !== seat.alias`). On a
  *   unique-alias bench, or when `seats` is omitted entirely, `seatMap` is
  *   `{}` — so no pre-T3.2 caller (or consumer of just `{entries, labelMap}`)
  *   can observe a change. T3.2 wired `seatMap` only as far as

package/src/council/briefings-chair-task.js

@@ -0,0 +1,161 @@
+// src/council/briefings-chair-task.js
+'use strict';
+
+/**
+ * @module council/briefings-chair-task
+ * Chair TASK-intent templates (v4.9 W7; v4.8 design spec §5.5, closing #146):
+ * the synthesis pair, the ANSWER scale addendum, the concurrence caveat and the
+ * one-shot ANSWER-line repair prompt. `briefings-chair.js` lazy-requires this
+ * module at call time from `buildChairPacket` and `chairRepairPromptFor` — the
+ * W6 dispatcher shape — so the review path composes byte-identically by
+ * construction and the two modules can never form a load cycle.
+ *
+ * WHAT FORKS, AND WHAT DOES NOT. The packet takes exactly four seams on
+ * `intent`: the synthesis instruction (the pair below replaces CHAIR_TASK /
+ * CHAIR_TASK_NO_FINDINGS), the scale addendum, the no-tools preamble's last
+ * word ('verdict.' → 'answer.'), and this module's concurrence caveat. Ruling
+ * V11 keeps everything else ONE vocabulary — and this task records the
+ * extension the ruling did not spell out: the packet's SECTION HEADERS
+ * (`--- STAGE-1 REVIEWS (de-anonymized) ---`, `--- PEER RANKINGS …`,
+ * `--- PER-FINDING ADJUDICATIONS ---`, the R8 block), the `Review by <model>`
+ * labels and the empty-section `(none — …)` wordings are shared verbatim. A
+ * task packet is the review packet with a different instruction, a different
+ * scale and one extra caveat; nothing re-parses those headers, and one habit
+ * should read both intents.
+ *
+ * ⚠️ TWO SCALES, EACH SPELLED TWICE (memo trap 2). `CHAIR_ANSWER_VALUES` here
+ * and `parse-stage2.js :: CHAIR_ANSWERS` are independent constants, exactly as
+ * the review pair has always been. Skew either and the chair is asked for a
+ * phrase the parser cannot read — a degraded run AFTER the whole bench is paid
+ * for. Both pairs are drift-pinned in tests/council/chair-scale-drift.test.js,
+ * which also carries the named mutant ANSWERSCALEDRIFT and its measured red
+ * set. The published schema's enum is a THIRD independent spelling and is
+ * pinned in the same suite.
+ */
+
+/** The task chair's terminal scale (spec §5.5; ruling V4). */
+const CHAIR_ANSWER_VALUES = ['Converged', 'Split', 'Insufficient'];
+
+/**
+ * The chair's opening instruction when the bench raised claims (the ordinary
+ * case). Task mode asks for an ANSWER, not an assessment: the chair adopts,
+ * merges or refuses, and the disputed claims its answer still rests on are
+ * named in a RESIDUAL RISK section rather than left implicit.
+ *
+ * ⚠️ v4.9 fix round 2 (council C3) — the close carries an ESCAPE HATCH, and it
+ * is the same lesson as the no-claims twin below, one bench-shape over. That
+ * twin drops the section entirely because a bench that declared NO adjudicable
+ * claims cannot have disputed any. But this instruction runs on the commoner
+ * middle case: claims WERE raised and adjudicated, and every one of them was
+ * concurred. "The claims peers disputed" then names the empty set, and the only
+ * satisfiable reading of an unfollowable directive is to invent material —
+ * LC-10 exactly. Naming the honest line is a satisfiable instruction for that
+ * bench; deleting the section here is not an option, because unlike the twin
+ * this template cannot know at composition time whether any dispute survived.
+ */
+const TASK_CHAIR_SYNTHESIS =
+  'You are the council chair. Write the synthesized ANSWER across the responses, ' +
+  'rankings, and adjudications below: adopt the strongest response, merge ' +
+  'complementary ones, or refuse the premise if the bench showed it unsound. State ' +
+  'the consensus, the disagreements and which way they went, and close the synthesis ' +
+  'with a RESIDUAL RISK section — the claims peers disputed that your answer still ' +
+  'depends on, or the single line "RESIDUAL RISK: none — no load-bearing claim was ' +
+  'disputed." when that is the truth.';
+
+/**
+ * The chair's opening instruction when the bench declared no adjudicable claims
+ * — the LC-10-shaped twin, and it carries that lesson twice.
+ *
+ * LC-10's rule is that an instruction whose only satisfiable reading is to
+ * invent material must be REPLACED, never amended: the review twin swaps
+ * CHAIR_TASK out entirely rather than appending a correction after it. Task
+ * mode inherits that, and drops one thing more — the RESIDUAL RISK close. That
+ * section is defined as "the claims peers disputed", which is precisely the set
+ * a clean bench just declared empty; asking for it here would be the same
+ * unfollowable directive in a new place.
+ */
+const TASK_CHAIR_SYNTHESIS_NO_CLAIMS =
+  'You are the council chair. Write the synthesized ANSWER across the responses and ' +
+  'rankings below: adopt the strongest response, merge complementary ones, or refuse ' +
+  'the premise if the bench showed it unsound. Weigh each analyst\'s standing by rank ' +
+  'position. NOTE: this bench declared NO adjudicable claims. Every analyst did the ' +
+  'work and reported no discrete claim needing adjudication, which is a valid outcome ' +
+  '— not a failed run. Synthesize on that basis: say what the responses actually ' +
+  'establish and where the bench\'s agreement is thin, and do not manufacture disputes ' +
+  'to fill the sections below.';
+
+/**
+ * Pushed after the adjudications the chair is about to weigh (R8-style
+ * placement — the caveat is read while the votes are still in view). Peer
+ * agreement on a generative bench is correlation between models trained on
+ * overlapping priors, not independent verification, and a task chair that
+ * reads "3 agree" as evidence overstates exactly what the tier table cannot.
+ */
+const TASK_CONCURRENCE_CAVEAT =
+  'Peer agreement on a claim is CONCURRENCE, not verification — models correlate on ' +
+  'priors. Weigh adjudications accordingly.';
+
+/**
+ * The ANSWER-scale addendum. Its first seven lines are
+ * `briefings-chair.js :: VERDICT_SCALE_ADDENDUM`'s, verbatim (V11: the
+ * two-closing-sections framing, the whole HARD QUESTIONS item and the
+ * "final line, alone" rule are scale-independent) — pinned as a prefix in
+ * tests/council/briefings-chair-task.test.js so the shared half cannot fork
+ * silently. Only the phrase list and its gloss are task-specific.
+ */
+const ANSWER_SCALE_ADDENDUM = [
+  'After your synthesis, add two closing sections:',
+  '',
+  '1. HARD QUESTIONS — three to five questions the material\'s author has probably not',
+  '   asked themselves, chosen so that an unanswerable question reveals a structural gap',
+  '   (not gotchas — questions whose answers should exist).',
+  '2. A final line, alone on the last line, containing ONLY the phrase — no rationale, no',
+  '   dash, no trailing text of any kind — exactly one of:',
+  '',
+  '   ANSWER: Converged',
+  '   ANSWER: Split',
+  '   ANSWER: Insufficient',
+  '',
+  '   Pick one. "Converged" = the bench substantially agrees and the synthesis above is',
+  '   well-supported. "Split" = material disagreement remains; the synthesis states both',
+  '   positions and what would settle them. "Insufficient" = the bench\'s work cannot',
+  '   support an answer — missing information, an unsound premise, or too little usable',
+  '   output. Name which, in the synthesis ABOVE, not on the ANSWER line.',
+].join('\n');
+
+/**
+ * One-shot chair repair, task twin: the ANSWER line was missing.
+ *
+ * Mirrors `briefings-chair.js :: buildChairRepairPrompt` block for block,
+ * because LC-12 carries unchanged — the chair leg SUCCEEDED and only the
+ * terminal line is missing, so the synthesis rides along and the repair solo
+ * picks the phrase its own prose supports instead of re-deriving one from
+ * nothing.
+ * @param {{synthesis?: string}} [args]
+ */
+function buildTaskChairRepairPrompt({ synthesis } = {}) {
+  const text = typeof synthesis === 'string' ? synthesis.trim() : '';
+  const prior = text
+    ? ['--- YOUR SYNTHESIS (verbatim — answer on THIS) ---', text,
+      '--- END OF YOUR SYNTHESIS ---'].join('\n')
+    : null;
+  return [
+    'Do NOT use any tools or read any files; everything is in this message; begin '
+    + 'immediately with the ANSWER line.',
+    ...(prior ? [prior] : []),
+    'Your synthesis was received, but the final parseable line was missing. Emit ONLY '
+    + 'one line, exactly one of:',
+    'ANSWER: Converged',
+    'ANSWER: Split',
+    'ANSWER: Insufficient',
+  ].join('\n\n');
+}
+
+module.exports = {
+  CHAIR_ANSWER_VALUES,
+  ANSWER_SCALE_ADDENDUM,
+  TASK_CHAIR_SYNTHESIS,
+  TASK_CHAIR_SYNTHESIS_NO_CLAIMS,
+  TASK_CONCURRENCE_CAVEAT,
+  buildTaskChairRepairPrompt,
+};

package/src/council/briefings-chair.js

@@ -13,16 +13,19 @@
 // hazard above does not apply to it. Do NOT require ./briefings-stage2.
 const { displayName } = require('./seats');
 
-const CHAIR_NO_TOOLS_PREAMBLE =
+// v4.9 W7: the preamble's LAST WORD is the only fork ('verdict.' | 'answer.'), so
+// the shared sentence keeps ONE spelling. This constant's value is unchanged.
+const CHAIR_NO_TOOLS_LEAD =
   'Do NOT use any tools or read any files; everything is in this message; ' +
-  'begin immediately with the verdict.';
+  'begin immediately with the ';
+const CHAIR_NO_TOOLS_PREAMBLE = CHAIR_NO_TOOLS_LEAD + 'verdict.';
 
 const CHAIR_VERDICT_VALUES = ['Ship it', 'Fix these first', 'Fundamental rethink'];
 
 /** Shared date line (spec §4.3) — prepended to every model-facing briefing. */
 function dateLine(date) { return `Today's date is ${date}.`; }
 
-/** Verdict-scale addendum (SEAT-BRIEFS.md § Chair verdict-scale addendum; always on headless). */
+/** Verdict-scale addendum (SEAT-BRIEFS.md § Chair closing-scale addendum; always on headless). */
 const VERDICT_SCALE_ADDENDUM = [
   'After your synthesis, add two closing sections:',
   '',
@@ -153,8 +156,12 @@ function seatKeyedOrder(order, orderSeats) {
  *   `rankings` and `adjudications` may both be empty — an all-clean bench (LC-10)
  *   has nothing to adjudicate, and a Stage 2 whose judges all died has nothing to
  *   rank. Each empty section says WHICH of those it is rather than rendering blank.
+ *   `intent` (v4.9 W7): `'task'` composes the twins from ./briefings-chair-task;
+ *   absent — or anything else, fail-closed — composes this packet byte-identically.
+ *   The four seams it moves, and the V11 vocabulary it leaves shared, are listed
+ *   in briefings-chair-task.js's docblock.
  */
-function buildChairPacket({ reviews, rankings, adjudications, tierCounts, date, findings }) {
+function buildChairPacket({ reviews, rankings, adjudications, tierCounts, date, findings, intent }) {
   // ⚠️ v4.8 SI-25: all three rendering sites below are SEAT-KEYED with an ALIAS
   // FALLBACK. Alias-keyed, a twin bench handed the chair "tier counts:
   // {Confirmed: 1}" beside two identical `A1 — deepseek:` lines, with nothing in
@@ -203,9 +210,14 @@ function buildChairPacket({ reviews, rankings, adjudications, tierCounts, date,
   const raisedCount = Object.values(tierCounts || {})
     .reduce((s, n) => s + (typeof n === 'number' ? n : 0), 0);
   const tiers = JSON.stringify(tierCounts);
-  const parts = [CHAIR_NO_TOOLS_PREAMBLE];
+  // Lazy, AT CALL TIME (the W6 dispatcher shape) — a top-level require would bind
+  // the two chair modules into a cycle the moment the twins need a fragment back.
+  const task = intent === 'task' ? require('./briefings-chair-task') : null;
+  const parts = [CHAIR_NO_TOOLS_LEAD + (task ? 'answer.' : 'verdict.')];
   if (date) { parts.push(dateLine(date)); }
-  parts.push(raisedCount === 0 ? CHAIR_TASK_NO_FINDINGS : CHAIR_TASK);
+  parts.push(task
+    ? (raisedCount === 0 ? task.TASK_CHAIR_SYNTHESIS_NO_CLAIMS : task.TASK_CHAIR_SYNTHESIS)
+    : (raisedCount === 0 ? CHAIR_TASK_NO_FINDINGS : CHAIR_TASK));
   parts.push(
     `Deterministic tier counts (peers-only cascade): ${tiers}`,
     '--- STAGE-1 REVIEWS (de-anonymized) ---',
@@ -228,7 +240,10 @@ function buildChairPacket({ reviews, rankings, adjudications, tierCounts, date,
       + ' Weigh them accordingly.',
     );
   }
-  parts.push(VERDICT_SCALE_ADDENDUM);
+  // R8's placement rule, applied again: after the votes it qualifies, before the
+  // scale — read while the adjudications are still in view.
+  if (task) { parts.push(task.TASK_CONCURRENCE_CAVEAT); }
+  parts.push(task ? task.ANSWER_SCALE_ADDENDUM : VERDICT_SCALE_ADDENDUM);
   return parts.join('\n\n');
 }
 
@@ -260,9 +275,19 @@ function buildChairRepairPrompt({ synthesis } = {}) {
   ].join('\n\n');
 }
 
+/**
+ * Chair repair-prompt dispatcher (v4.9 W7, the W6 shape): `'task'` asks for the
+ * ANSWER line, anything else for the VERDICT line, byte-identically. Lazy require.
+ */
+function chairRepairPromptFor(intent, args) {
+  return intent === 'task'
+    ? require('./briefings-chair-task').buildTaskChairRepairPrompt(args)
+    : buildChairRepairPrompt(args);
+}
+
 module.exports = {
   dateLine,
-  CHAIR_NO_TOOLS_PREAMBLE,
+  CHAIR_NO_TOOLS_PREAMBLE, chairRepairPromptFor,
   CHAIR_VERDICT_VALUES,
   VERDICT_SCALE_ADDENDUM,
   CHAIR_TASK,

package/src/council/briefings-debate.js

@@ -9,6 +9,23 @@
  * trailing-JSON style (prose first, one fenced ```json block last, nothing
  * after it). Every brief opens with the no-tools preamble and the date stamp
  * (spec §4.3). No IO, no model calls.
+ *
+ * v4.9 W7 (ruling V2) — the TASK twins live IN THIS FILE rather than in a
+ * sibling module the way W6's Stage-1 twins do: the fork is one PARAGRAPH per
+ * builder, the file is well under the 300-line gate, and a sibling would have
+ * to re-import every renderer below. Each builder takes `intent` on its args
+ * object; `'task'` composes the task frame and ANYTHING ELSE — absent included
+ * — composes the review frame byte-identically, fail-closed exactly like
+ * briefings.js's Stage-1 dispatchers. run-debate.js :: runDefenseSolo and
+ * run-debate-revote.js :: runRevoteWave are the only two callers; both thread
+ * `ctx.o.intent` straight through.
+ *
+ * V11 (one vocabulary) as extended here: ONLY the frame paragraph forks. The
+ * no-tools preamble, the date line, both trailing-JSON contracts, both
+ * finding-block renderers (`- <id> [<severity>]`, the anonymized peer split,
+ * the **AMENDED** mark), the shared `repair()` and buildDebateAddendum are one
+ * spelling across both intents — which is also why parse-stage2.js ::
+ * parseDebateDefense / parseRevote are frame-neutral and W7 does not touch them.
  */
 
 const { dateLine } = require('./briefings-stage2');
@@ -78,16 +95,63 @@ function findingBlockRevote(f) {
   return `- ${f.id} [${f.severity}]${mark}: ${f.claim}\n  Raiser's response: ${f.argument}`;
 }
 
-/** One defense solo per raiser (spec §5.3a). */
-function buildDefenseBrief({ findings, date }) {
+/** Defense frame — REVIEW intent, verbatim from v4.0 (spec §5.3a). */
+const DEFENSE_FRAME =
+  'You reviewed an artifact and raised the findings below. Peer reviewers ' +
+  '(anonymous) disputed them for the stated reasons. For EACH finding decide: ' +
+  'DEFEND it with evidence, AMEND it with corrected replacement text, or WITHDRAW ' +
+  'it. Withdraw anything you cannot defend with evidence — an unsupported repeat ' +
+  'of the original claim is weaker than a withdrawal.';
+
+/**
+ * Defense frame — TASK intent (v4.9 W7, ruling V2). Mirrors the review frame's
+ * structure: same three actions, same DEFENSE_CONTRACT, same block list. What
+ * a raiser defends here is a load-bearing CLAIM under its OWN answer, not a
+ * finding about someone else's artifact — the frame is the only thing that has
+ * to know that.
+ *
+ * ⚠️ PR #200 C4: the closing sentence is the review frame's CALIBRATION
+ * INCENTIVE, restored claim-worded. W7 wrote this frame fresh and dropped it,
+ * which quietly made the task debate a worse instrument than the review one:
+ * without it the cheapest move for a disputed raiser is to restate the claim,
+ * and a debate that rewards stubbornness measures conviction rather than
+ * evidence. Only 'anything' → 'any claim' changes; the rest is the review
+ * wording verbatim, because the point it makes is mode-neutral.
+ */
+const TASK_DEFENSE_FRAME =
+  'You produced an answer and declared the claims below as load-bearing. Peer ' +
+  'analysts (anonymous) disputed them. For each claim: defend it with your ' +
+  'strongest argument, amend it if the dispute exposed a real flaw, or withdraw it. ' +
+  'Withdraw any claim you cannot defend with evidence — an unsupported repeat ' +
+  'of the original claim is weaker than a withdrawal.';
+
+/** Re-vote frame — REVIEW intent, verbatim from v4.0 (spec §5.3b). */
+const REVOTE_FRAME =
+  'You previously adjudicated findings on this artifact and disputed at least ' +
+  'one of those below. The (anonymous) raiser has now responded. Re-adjudicate ' +
+  'ONLY the findings listed, in light of each response. Changing your verdict ' +
+  'when the defense is convincing is good judging, not weakness; so is holding ' +
+  'your dispute when it isn\'t.';
+
+/**
+ * Re-vote frame — TASK intent (v4.9 W7, ruling V2); same REVOTE_CONTRACT verdicts.
+ * ⚠️ PR #200 C4: closes on the review frame's judge-side calibration incentive,
+ * reused VERBATIM — nothing in it speaks of findings-vs-claims, and a judge who
+ * reads holding a dispute as strength is the same failure on either scale.
+ */
+const TASK_REVOTE_FRAME =
+  'You previously adjudicated claims from this bench\'s answers and disputed at ' +
+  'least one of those below. The raiser has now responded. Re-vote each claim: ' +
+  'agree / dispute / neutral. Changing your verdict ' +
+  'when the defense is convincing is good judging, not weakness; so is holding ' +
+  'your dispute when it isn\'t.';
+
+/** One defense solo per raiser (spec §5.3a). `intent`: 'task' | absent (review). */
+function buildDefenseBrief({ findings, date, intent }) {
   const parts = [DEBATE_NO_TOOLS_PREAMBLE];
   if (date) { parts.push(dateLine(date)); }
   parts.push(
-    'You reviewed an artifact and raised the findings below. Peer reviewers ' +
-    '(anonymous) disputed them for the stated reasons. For EACH finding decide: ' +
-    'DEFEND it with evidence, AMEND it with corrected replacement text, or WITHDRAW ' +
-    'it. Withdraw anything you cannot defend with evidence — an unsupported repeat ' +
-    'of the original claim is weaker than a withdrawal.',
+    intent === 'task' ? TASK_DEFENSE_FRAME : DEFENSE_FRAME,
     findings.map(findingBlockDefense).join('\n\n'),
     DEFENSE_CONTRACT,
   );
@@ -95,15 +159,11 @@ function buildDefenseBrief({ findings, date }) {
 }
 
 /** One shared re-vote bundle, fanned out to disputing judges (spec §5.3b). */
-function buildRevoteBundle({ findings, date }) {
+function buildRevoteBundle({ findings, date, intent }) {
   const parts = [DEBATE_NO_TOOLS_PREAMBLE];
   if (date) { parts.push(dateLine(date)); }
   parts.push(
-    'You previously adjudicated findings on this artifact and disputed at least ' +
-    'one of those below. The (anonymous) raiser has now responded. Re-adjudicate ' +
-    'ONLY the findings listed, in light of each response. Changing your verdict ' +
-    'when the defense is convincing is good judging, not weakness; so is holding ' +
-    'your dispute when it isn\'t.',
+    intent === 'task' ? TASK_REVOTE_FRAME : REVOTE_FRAME,
     findings.map(findingBlockRevote).join('\n\n'),
     REVOTE_CONTRACT,
   );
@@ -116,6 +176,12 @@ function buildRevoteBundle({ findings, date }) {
  * `prior` is embedded verbatim and uncapped; the absent case is stated rather
  * than papered over with an empty block, so a model with nothing to correct is
  * told to say so instead of left to invent a position.
+ *
+ * NO intent fork (v4.9 W7, ruling V2 — verified, not forked): a repair turn
+ * carries the trailing-JSON CONTRACT and the prior text, never a frame, so
+ * there is nothing here that speaks in findings-vs-claims. Both repair builders
+ * therefore stay one spelling for both intents; pinned in
+ * tests/council/briefings-debate.test.js ("frame-neutral in both intents").
  * @param {string} kind 'defense' | 're-vote'
  * @param {string} contract the trailing-JSON contract for that kind
  * @param {Array<{code:string,detail:string}>} errors