alphacouncil-agent 1.0.3 → 1.0.13

package/mcp/lib/markdown.mjs

@@ -13,6 +13,16 @@ import { intentLabel, VOICE_FIELDS, voiceDisclaimer, voiceFieldLabel } from "./v
 import { agentState, appendEvent, artifactPaths, runPath, taskState } from "./run-store.mjs";
 import { personaTitle, registry } from "./personas/registry.mjs";
 
+/**
+ * Per-seat statement budget in the handoff.
+ *
+ * The governance contract requires every selected seat's statement in the handoff, so this is
+ * the seat's only appearance there. At the old one-line budget a seat's conclusion was always
+ * the part that got cut, which is how seven seats that all spoke read as seven seats that had
+ * not. The complete statement stays in the report and in `master_<id>.md`.
+ */
+const MASTER_STATEMENT_CHARS = 2000;
+
 export function renderPacketMarkdown(packet, index = 0, language = packet?.language) {
   const key = languageKey(language);
   const label = {
@@ -1170,7 +1180,21 @@ export function userResponseMarkdown(run, manager) {
     if (!opinion) return `- ${masterTitle(id, run.language)} (\`${id}\`) [${localizedDisplayValue(state.status, run.language)}]: ${localizedFailure(state.error, run.language) || copy.missing}`;
     const statementSource = opinion.dedicated_worker?.status || opinion.voice_status || "unknown";
     const frozenRecord = opinion.statement_origin || opinion.reason || opinion.engine || "recorded";
-    return `- ${masterTitle(id, run.language)} (\`${id}\`) — ${clipAtBoundary(opinion.voice_statement || opinion.summary || opinion.verdict, 520)} [${copy.record}: ${localizedDisplayValue(opinion.stance, run.language)}/${localizedDisplayValue(opinion.confidence || "low", run.language)}; ${copy.worker}: ${localizedDisplayValue(statementSource, run.language)}; ${frozenRecord}]`;
+    // A seat's statement opens with the evidence it read and closes with what it would do, so
+    // clipping the opening to one line spent the whole budget on background and cut the
+    // conclusion. Lead with the reading that decided it and the action it implies -- both are
+    // already composed from the frozen decision -- then quote the statement at a budget that
+    // survives a paragraph, and leave provenance to its own line instead of the same sentence.
+    const lead = [opinion.voice?.how_my_method_reads_it, opinion.voice?.would_i_act]
+      .filter((part) => typeof part === "string" && part.trim().length)
+      .join(" ");
+    const statement = opinion.voice_statement || opinion.summary || opinion.verdict || "";
+    return [
+      `- ${masterTitle(id, run.language)} (\`${id}\`)`,
+      lead ? `  - ${clipAtBoundary(lead, 700)}` : "",
+      statement ? `  - ${clipAtBoundary(statement, MASTER_STATEMENT_CHARS)}` : "",
+      `  - [${copy.record}: ${localizedDisplayValue(opinion.stance, run.language)}/${localizedDisplayValue(opinion.confidence || "low", run.language)}; ${copy.worker}: ${localizedDisplayValue(statementSource, run.language)}; ${frozenRecord}]`,
+    ].filter(Boolean).join("\n");
   }).join("\n") || `- ${copy.missing}`;
   const analystLines = (run.tasks || []).map((task) => {
     const packet = (run.packets || []).find((item) => item.task === task);

package/mcp/lib/orchestrator.mjs

@@ -1,19 +1,19 @@
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { COUNCIL_MODES, DEBATE_ROLES, DEFAULT_TASKS, LIMITS, OUTPUT_MODES, QUICK_TASKS } from "./constants.mjs";
+import { COUNCIL_MODES, DEBATE_ROLES, DEFAULT_TASKS, LIMITS, OUTPUT_MODES, QUICK_TASKS, councilPaceProfile } from "./constants.mjs";
 import { invalidParams } from "./errors.mjs";
 import { readJson, writeJson } from "./fsutil.mjs";
 import { registry } from "./personas/registry.mjs";
 import { assertReaderLanguage, isChineseLanguage, localized, resolveLanguage } from "./lang.mjs";
 import { cleanLog } from "./text.mjs";
-import { completenessStatus, masterSeatIncomplete, verificationStatus } from "./gates.mjs";
+import { authoredReportSectionGaps, completenessStatus, masterSeatIncomplete, requiredReportSectionAliases, verificationStatus } from "./gates.mjs";
 import { agentState, appendEvent, artifactPaths, existingDebate, runPath, runId, safeSymbol, saveRun, taskState, today, updateAgent, updateTask, writeSourceManifest, writeStatus } from "./run-store.mjs";
 import { writeAllAgentsMarkdown, writeAnalystMarkdownFiles, writeArtifactIndex, writeFinalArtifacts } from "./markdown.mjs";
 import { debateFailurePacket, debateFromCodex, debateQnaGate, dryDebate, dryPacket, extractJson, firstFailedDebateResult, managerFallback, mergeDebateRounds, normalizeDebate, normalizeMasterOpinion, normalizeMasterVoice, normalizePacket, rawRecordText } from "./packets.mjs";
 import { mapLimit, runCodex } from "./codex.mjs";
 import { debatePrompt, masterPrompt, masterVoicePrompt, selectedMasters, taskPrompt } from "./prompts.mjs";
 import { resolveSeatWeights } from "./weights.mjs";
-import { completedMasterOpinion, declinedMasterOpinion, planMasterSeats, reconcileMasterOpinion } from "./personas/engine.mjs";
+import { completedMasterOpinion, declinedMasterOpinion, needsMethodVoiceWorker, planMasterSeats, reconcileMasterOpinion } from "./personas/engine.mjs";
 import { gatherGrounding } from "./grounding.mjs";
 import { councilOptions } from "./council-options.mjs";
 import { sha256 } from "./personas-v3/canonical.mjs";
@@ -28,11 +28,28 @@ function plannedTasks(args = {}) {
   return DEFAULT_TASKS;
 }
 
+/**
+ * The pace a run executes at, and the per-stage caps that come with it.
+ *
+ * Quick has one fixed shape and does not take a pace: it is a smaller contract, not a slower
+ * one. Full carries the pace on the run so every stage reads the same profile and `status.json`
+ * records which one was used.
+ */
+export function runPace(run) {
+  if (run?.council_mode === "quick") return null;
+  return councilPaceProfile(run?.council_pace);
+}
+
 function councilTiming(args, startedAt) {
   const mode = councilMode(args);
   const requested = Number(args.total_timeout_ms);
-  const hardMaximum = mode === "quick" ? LIMITS.QUICK_HARD_MAX_MS : LIMITS.FULL_HARD_MAX_MS;
-  const defaultBudget = mode === "quick" ? LIMITS.QUICK_TOTAL_MS : LIMITS.FULL_TOTAL_MS;
+  const profile = mode === "quick" ? null : councilPaceProfile(args.council_pace);
+  // The ceiling a call is held to is its own pace's total, not the outer bound of the schema.
+  // A caller may still lower it; `LIMITS.FULL_TOTAL_MS` keeps the operator env override.
+  const hardMaximum = mode === "quick" ? LIMITS.QUICK_HARD_MAX_MS : profile.total_ms;
+  const defaultBudget = mode === "quick"
+    ? LIMITS.QUICK_TOTAL_MS
+    : Math.min(profile.total_ms, LIMITS.FULL_TOTAL_OVERRIDE_MS ?? profile.total_ms);
   const timeBudgetMs = Number.isFinite(requested) && requested > 0
     ? Math.min(requested, hardMaximum)
     : defaultBudget;
@@ -40,6 +57,7 @@ function councilTiming(args, startedAt) {
     || new Date(Date.parse(startedAt) + timeBudgetMs).toISOString();
   return {
     council_mode: mode,
+    council_pace: profile?.pace || null,
     debate_format: mode === "quick" ? "single_round_parallel" : "three_round_cross_exam_parallel_per_round",
     time_budget_ms: timeBudgetMs,
     deadline_at: deadlineAt,
@@ -62,7 +80,7 @@ function remainingCouncilBudget(run, capMs) {
   if (!run.deadline_at) return capMs;
   const configuredReserve = run.council_mode === "quick"
     ? LIMITS.QUICK_FINALIZE_RESERVE_MS
-    : LIMITS.FULL_FINALIZE_RESERVE_MS;
+    : runPace(run).finalize_reserve_ms;
   const reserve = Math.min(
     configuredReserve,
     Math.max(100, Math.floor(Number(run.time_budget_ms || LIMITS.FULL_TOTAL_MS) * 0.1)),
@@ -268,7 +286,7 @@ export function visibleAgentSpecs(run, userPrompt = "") {
       ja: `AlphaCouncil Agent ${run.symbol} ${task} 証拠サブエージェント`,
       ko: `AlphaCouncil Agent ${run.symbol} ${task} 증거 하위 에이전트`,
     }),
-    prompt: taskPrompt(task, run.symbol, run.as_of, userPrompt, run.language, run.grounding),
+    prompt: taskPrompt(task, run.symbol, run.as_of, userPrompt, run.language, run.grounding, run.council_pace),
     output_contract: localized(run.language, {
       en: `Return one JSON evidence packet with reader-facing fields in ${run.language}.`,
       zh: "只返回一个 JSON evidence packet。",
@@ -374,16 +392,23 @@ export function visibleAgentSpecs(run, userPrompt = "") {
           item.engine,
         ));
       }
+      // A seat that executed its policy and still abstained is in the same position as a
+      // declined seat: the frozen stance is out_of_scope, no worker may change it, and the
+      // deterministic statement already names the gate that closed and says an abstention is
+      // not a bearish vote. Only seats that reached a stance have a reading to explain.
+      const requiresVisibleVoice = needsMethodVoiceWorker(byId.get(item.id));
       const alreadyVoiced = run.master_status?.[item.id]?.status === "completed"
         && byId.get(item.id)?.voice_status === "completed";
       run.master_status[item.id] = {
         ...(run.master_status[item.id] || {}),
         master: item.id,
-        status: alreadyVoiced ? "completed" : "waiting",
+        status: alreadyVoiced || !requiresVisibleVoice ? "completed" : "waiting",
         engine: item.engine,
         deterministic_execution: true,
-        voice_required: true,
-        completed_at: alreadyVoiced ? run.master_status[item.id].completed_at : null,
+        voice_required: requiresVisibleVoice,
+        completed_at: alreadyVoiced || !requiresVisibleVoice
+          ? (run.master_status[item.id]?.completed_at || new Date().toISOString())
+          : null,
       };
     }
     run.master_opinions = selectedMasters(run).map((id) => byId.get(id)).filter(Boolean);
@@ -402,6 +427,7 @@ export function visibleAgentSpecs(run, userPrompt = "") {
   const v3VoiceAgents = plan.completed
     .filter((item) => item.engine === "v3_method_runtime")
     .filter((item) => run.master_status?.[item.id]?.status !== "completed")
+    .filter((item) => needsMethodVoiceWorker(frozenById.get(item.id)))
     .map((item) => {
       const frozenOpinion = frozenById.get(item.id);
       return {
@@ -432,10 +458,21 @@ export function visibleAgentSpecs(run, userPrompt = "") {
     .map((id) => master_agents.find((agent) => agent.role === id))
     .filter(Boolean);
   saveRun(run);
+  const prompts = externalizeVisiblePrompts(run, [
+    { kind: "evidence", agents: evidence_agents },
+    { kind: "master", agents: orderedMasterAgents },
+    { kind: "debate", agents: debate_agents },
+  ]);
   return {
-    evidence_agents,
-    master_agents: orderedMasterAgents,
-    debate_agents,
+    // Every planned prompt is on disk either way. `prompts_inline` says whether this result
+    // also carries them, so a host never has to guess whether `prompt_template` is missing
+    // because the plan failed or because it was too large to return.
+    prompts_inline: prompts.inline,
+    prompt_dir: prompts.prompt_dir,
+    prompt_chars_total: prompts.prompt_chars_total,
+    evidence_agents: prompts.byKind.get("evidence"),
+    master_agents: prompts.byKind.get("master"),
+    debate_agents: prompts.byKind.get("debate"),
     // Recorded, not hidden: a reader must be able to tell a method that judged from a method
     // that could not look, and neither from a seat that was never offered.
     master_decisions: plan.decisions,
@@ -468,6 +505,67 @@ export function visibleAgentSpecs(run, userPrompt = "") {
   };
 }
 
+/**
+ * Total prompt characters a visible plan may return inline.
+ *
+ * The plan carries one full prompt per agent, and every prompt embeds the grounding and
+ * evidence JSON. A real eight-seat run returned 311,007 characters in a single tool result and
+ * the host rejected the whole thing for exceeding its result ceiling -- the plan was produced
+ * correctly and then thrown away. Below this budget nothing changes for an existing host;
+ * above it the prompts move to disk and each agent carries the path instead.
+ */
+const VISIBLE_PLAN_INLINE_PROMPT_CHARS = 120000;
+
+/**
+ * The size that decides this is the grounding each prompt embeds, not the number of seats: a
+ * bench-wide plan with no grounding is well inside the budget, while eight seats against a
+ * full macro series is what produced the 311k result. Operators may lower the budget for a
+ * host with a tighter ceiling; they may not raise it past what that host would reject anyway.
+ */
+function inlinePromptBudget(env = process.env) {
+  const requested = Number(env?.ALPHACOUNCIL_VISIBLE_INLINE_PROMPT_CHARS);
+  if (!Number.isFinite(requested) || requested < 0) return VISIBLE_PLAN_INLINE_PROMPT_CHARS;
+  return Math.min(requested, VISIBLE_PLAN_INLINE_PROMPT_CHARS);
+}
+
+/**
+ * Write every planned prompt to the run directory, and drop the inline copies when returning
+ * them all at once would exceed what a host will accept.
+ */
+function externalizeVisiblePrompts(run, groups) {
+  const dir = join(runPath(run.run_id), "prompts");
+  mkdirSync(dir, { recursive: true });
+  // Roles are generated ids, but a filename is still a filename: keep it to one path segment.
+  const fileSafe = (role) => String(role || "agent").replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 80) || "agent";
+  // Evidence agents carry `prompt`; master and debate agents carry `prompt_template`. Reading
+  // only one of them wrote empty files for the other group.
+  const promptKey = (agent) => (typeof agent.prompt_template === "string" ? "prompt_template" : "prompt");
+  const total = groups.reduce((sum, { agents }) => sum + agents
+    .reduce((inner, agent) => inner + String(agent[promptKey(agent)] || "").length, 0), 0);
+  const inline = total <= inlinePromptBudget();
+  const externalized = groups.map(({ kind, agents }) => ({
+    kind,
+    agents: agents.map((agent) => {
+      const key = promptKey(agent);
+      const file = join(dir, `${kind}.${fileSafe(agent.role)}.prompt.md`);
+      const prompt = String(agent[key] || "");
+      writeFileSync(file, prompt.endsWith("\n") ? prompt : `${prompt}\n`, { encoding: "utf8", mode: 0o600 });
+      return {
+        ...agent,
+        prompt_file: file,
+        prompt_chars: prompt.length,
+        ...(inline ? {} : { [key]: null }),
+      };
+    }),
+  }));
+  return {
+    inline,
+    prompt_dir: dir,
+    prompt_chars_total: total,
+    byKind: new Map(externalized.map(({ kind, agents }) => [kind, agents])),
+  };
+}
+
 /**
  * The stance is already decided. The prompt says so, in the run's language, so the model
  * writes an explanation rather than a verdict.
@@ -941,14 +1039,48 @@ function recordVisiblePortfolioManager(run, args) {
     execution_mode: "visible_host_threads",
   }, "portfolio_manager", run, rawRecordText(args.packet));
   assertVisibleReaderLanguage(debateReaderText(packet), run, "visible portfolio_manager decision");
+  // Reject a report body that cannot pass the report gate before the packet takes the
+  // idempotency lock, and say which headings are owed. Previously the gate ran only after the
+  // report was assembled, so a submission with no `report_markdown` at all was accepted, the
+  // report was built from the summary fallback, and the author learned about 21 missing
+  // sections only after the entire PM turn had been spent.
+  const authoredGaps = authoredReportSectionGaps(packet.report_markdown, run);
+  if (authoredGaps.length) {
+    rejectVisibleDecision(
+      run,
+      "VISIBLE_PM_REPORT_SECTIONS_MISSING",
+      packet.report_markdown
+        ? "portfolio_manager rejected: report_markdown does not carry every required report-contract section."
+        : "portfolio_manager rejected: packet.report_markdown is required and must be the complete report body, not an execution note.",
+      {
+        report_contract: run.council_mode === "quick" ? "quick_v1" : "full_v2",
+        report_markdown_characters: String(packet.report_markdown || "").length,
+        gaps: authoredGaps,
+        required_sections: requiredReportSectionAliases(run),
+      },
+    );
+  }
   const contentHash = visibleDecisionContentHash(packet);
   if (state.portfolio_manager) {
-    if (state.portfolio_manager.content_hash !== contentHash) {
+    // A report that failed the structure gate must stay revisable. The first submission takes
+    // the idempotency lock before the gate runs, so a PM whose report_markdown was thin left the
+    // run stuck at needs_revision forever: the fix was rejected as a conflicting replay and there
+    // was no other way in. A passed report is still frozen -- revision is for repairing a
+    // rejected report, not for changing a verdict that already stands.
+    const priorQualityPath = join(dir, "report_quality.json");
+    const priorQuality = existsSync(priorQualityPath) ? readJson(priorQualityPath) : null;
+    const revisable = priorQuality && priorQuality.status !== "passed";
+    if (state.portfolio_manager.content_hash !== contentHash && !revisable) {
       rejectVisibleDecision(run, "VISIBLE_PM_CONFLICT", "Conflicting portfolio_manager replay.", {
         existing_content_hash: state.portfolio_manager.content_hash,
         submitted_content_hash: contentHash,
+        report_quality: priorQuality?.status || null,
       });
     }
+    // Revision accepted: drop the lock so the normal record path below runs again.
+    if (state.portfolio_manager.content_hash !== contentHash) state.portfolio_manager = null;
+  }
+  if (state.portfolio_manager) {
     const handoffPath = join(dir, "user_response.md");
     const reportPath = join(dir, "final_report.md");
     const qualityPath = join(dir, "report_quality.json");
@@ -1138,8 +1270,12 @@ function readerStrings(value, skipKeys = new Set()) {
 }
 
 function visibleEvidenceReaderText(packet) {
+  // `title` joins the machine set for the same reason `url` is already there: a source title is
+  // the publisher's own words. Counting English headlines against a Chinese run's language ratio
+  // rejected packets whose every authored sentence was Chinese, and the only way to pass was to
+  // translate the citation -- which is falsifying the source, not localising the report.
   const machine = new Set([
-    "task", "symbol", "as_of", "source_ids", "id", "url", "published_at", "retrieved_at",
+    "task", "symbol", "as_of", "source_ids", "id", "url", "title", "published_at", "retrieved_at",
     "confidence", "information_richness", "thread_id", "execution_mode", "raw_text",
   ]);
   return [
@@ -1314,7 +1450,7 @@ export async function collectEvidence(args) {
   const requestedTimeoutMs = Number.isFinite(args.timeout_ms) ? args.timeout_ms : LIMITS.CODEX_TIMEOUT_MS;
   const timeoutMs = timing.council_mode === "quick"
     ? Math.min(requestedTimeoutMs, LIMITS.QUICK_EVIDENCE_MS)
-    : Math.min(requestedTimeoutMs, LIMITS.FULL_EVIDENCE_MS);
+    : Math.min(requestedTimeoutMs, councilPaceProfile(timing.council_pace).evidence_ms);
   const defaultConcurrency = timing.council_mode === "quick"
     ? QUICK_TASKS.length
     : Math.min(tasks.length, LIMITS.FULL_EVIDENCE_CONCURRENCY);
@@ -1334,7 +1470,7 @@ export async function collectEvidence(args) {
     dryRun,
     timeoutMs: remainingCouncilBudget(
       timing,
-      timing.council_mode === "quick" ? LIMITS.QUICK_GROUNDING_MS : LIMITS.FULL_GROUNDING_MS,
+      timing.council_mode === "quick" ? LIMITS.QUICK_GROUNDING_MS : councilPaceProfile(timing.council_pace).grounding_ms,
     ),
   });
   const dir = runPath(id);
@@ -1436,7 +1572,7 @@ export async function collectEvidence(args) {
         : "QUICK COUNCIL PRIORITY: return only the 4-6 highest-information claims needed for a directional read. Keep the packet concise, source every claim, and make unknowns explicit."
       : "";
     const workerObjective = [args.prompt || "", quickPriority].filter(Boolean).join("\n\n");
-    const prompt = taskPrompt(task, symbol, asOfDate, workerObjective, language, run.grounding);
+    const prompt = taskPrompt(task, symbol, asOfDate, workerObjective, language, run.grounding, run.council_pace);
     updateTask(run, task, "running", { started_at: new Date().toISOString() });
     if (dryRun) {
       const packet = dryPacket(task, symbol, asOfDate, prompt, language);
@@ -1637,7 +1773,7 @@ export async function runHeadlessMasters(run, args = {}) {
   const requestedTimeoutMs = Number.isFinite(args.timeout_ms) ? args.timeout_ms : LIMITS.CODEX_TIMEOUT_MS;
   const timeoutMs = run.council_mode === "quick"
     ? Math.min(requestedTimeoutMs, LIMITS.QUICK_MASTER_MS)
-    : Math.min(requestedTimeoutMs, LIMITS.FULL_MASTER_MS);
+    : Math.min(requestedTimeoutMs, runPace(run).master_ms);
   const defaultConcurrency = run.council_mode === "quick"
     ? 4
     : Math.min(selected.length, LIMITS.FULL_MASTER_CONCURRENCY);
@@ -1684,12 +1820,39 @@ export async function runHeadlessMasters(run, args = {}) {
     })),
     ...plan.to_run,
   ];
+  // A frozen abstention has no reading for a worker to explain, and its deterministic statement
+  // already carries what the contract asks of an out_of_scope seat. Publish it directly instead
+  // of spending one model turn per seat to restate it.
+  const abstainedWithoutWorker = [];
+  const votingWorkerItems = workerItems.filter((item) => {
+    if (!item.frozenOpinion || needsMethodVoiceWorker(item.frozenOpinion)) return true;
+    abstainedWithoutWorker.push(item);
+    return false;
+  });
   for (const item of workerItems) {
     if (!item.frozenOpinion) continue;
     writeJson(join(dir, `${item.id}.deterministic.json`), item.frozenOpinion);
   }
 
-  const outcomes = await mapLimit(workerItems, maxConcurrency, async ({ id, decision, engine, frozenOpinion, deterministic_decline, deterministic_execution }) => {
+  const abstainedOutcomes = abstainedWithoutWorker.map(({ id, engine, frozenOpinion }) => ({
+    id,
+    engine,
+    opinion: {
+      ...frozenOpinion,
+      deterministic_summary: frozenOpinion.summary,
+      voice_statement: frozenOpinion.voice_statement || frozenOpinion.summary,
+      voice_status: "deterministic_scope",
+      voice_language: run.language,
+      statement_origin: "deterministic_scope_fallback",
+      dedicated_worker: {
+        status: "not_required_frozen_abstention",
+        language: run.language,
+        execution_mode: "deterministic_only",
+      },
+    },
+  }));
+
+  const outcomes = await mapLimit(votingWorkerItems, maxConcurrency, async ({ id, decision, engine, frozenOpinion, deterministic_decline, deterministic_execution }) => {
     const prompt = frozenOpinion
       ? masterVoicePrompt(id, run, frozenOpinion)
       : [
@@ -1827,7 +1990,7 @@ export async function runHeadlessMasters(run, args = {}) {
     raw: cleanLog(error?.message || error),
   }));
 
-  for (const outcome of outcomes) {
+  for (const outcome of [...abstainedOutcomes, ...outcomes]) {
     if (!outcome.opinion) {
       const diagnosticPath = join(dir, `${outcome.id}.failure.json`);
       writeJson(diagnosticPath, {
@@ -2153,7 +2316,7 @@ export async function synthesizeDecision(run, args) {
     : Number(args.timeout_ms || LIMITS.CODEX_TIMEOUT_MS);
   const timeoutMs = run.council_mode === "quick"
     ? Math.min(requestedSynthesisMs, LIMITS.QUICK_SYNTHESIS_MS)
-    : Math.min(requestedSynthesisMs, LIMITS.FULL_DEBATE_MS);
+    : Math.min(requestedSynthesisMs, runPace(run).debate_ms);
   const outputMode = OUTPUT_MODES.includes(args.output_mode) ? args.output_mode : "public_equity";
   run.phase = "debate";
   run.status = "running";
@@ -2319,7 +2482,7 @@ export async function synthesizeDecision(run, args) {
   });
   writeAllAgentsMarkdown(run, { bull, bear });
 
-  const pmBudget = remainingCouncilBudget(run, Math.min(requestedSynthesisMs, LIMITS.FULL_PM_MS));
+  const pmBudget = remainingCouncilBudget(run, Math.min(requestedSynthesisMs, runPace(run).pm_ms));
   const managerStep = await runDebateRole(run, "portfolio_manager", { bull, bear, outputMode }, pmBudget);
   const managerOk = !debateFailure(managerStep);
   const manager = managerOk ? managerStep.packet : managerFallback(run, args.prompt || "");

package/mcp/lib/personas/engine.mjs

@@ -10,7 +10,7 @@
 import { compiledPersonaPacks } from "../personas-v3/registry.mjs";
 import { buildFactPack } from "../personas-v3/typed-facts.mjs";
 import { typedFactPackFromGrounding } from "../personas-v3/grounding-adapter.mjs";
-import { buildAnonymousPreDecision, freezeAnonymousDecision } from "../personas-v3/runtime.mjs";
+import { buildAnonymousPreDecision, freezeAnonymousDecision, technicalIdReadableMap } from "../personas-v3/runtime.mjs";
 import { executeDeterministicPersonaPolicy } from "../personas-v3/deterministic-executor.mjs";
 import { languageKey, localized } from "../lang.mjs";
 import { displayMasterLabel } from "../markdown.mjs";
@@ -216,6 +216,25 @@ function uniqueStrings(values) {
   return [...new Set(values.filter((value) => typeof value === "string" && value.length))];
 }
 
+/**
+ * Whether a frozen seat still needs a model worker to become readable.
+ *
+ * A seat that reached a stance has a reading worth explaining: which condition decided it, at
+ * what number, and what would move it. A seat whose gate never opened has no reading. Its
+ * deterministic statement already names the condition that closed the gate and says an
+ * abstention is not a bearish vote, which is the whole of what an out_of_scope seat is asked
+ * to say -- so an isolated worker there buys prose, not information. The declined path reached
+ * this conclusion earlier for the same reason; this applies it to a seat that executed its
+ * policy and abstained. On a real seven-seat run four such seats took most of the method phase
+ * to report, at length, that they had no opinion.
+ *
+ * Set ALPHACOUNCIL_VOICE_ABSTAINING_SEATS=1 to give every seat a worker again.
+ */
+export function needsMethodVoiceWorker(opinion, { env = process.env } = {}) {
+  if (env?.ALPHACOUNCIL_VOICE_ABSTAINING_SEATS === "1") return true;
+  return (opinion?.stance || "out_of_scope") !== "out_of_scope";
+}
+
 /** Render a post-freeze, model-free opinion from the DSL result. */
 export function completedMasterOpinion(run, item) {
   if (item?.engine !== "v3_method_runtime" || !item?.completed) {
@@ -230,15 +249,21 @@ export function completedMasterOpinion(run, item) {
   const label = displayMasterLabel(item.pack.admitted_label?.[locale]
     || item.pack.admitted_label?.en || item.id);
   const copy = localized(run.language, {
-    en: { withheld: (pct) => `${pct}% coverage; score withheld`, unscored: "not scored", verdict: (stance, reason) => `${label} frozen decision: ${stance} (${reason})`, summary: (score) => `Using the ${label} method on ${run.symbol}, the PersonaPack v3 deterministic policy executed with score ${score}. Typed facts, hard vetoes, and score bands produced this stance; no language model selected it.`, hit: (id) => `score hit: ${id}`, miss: (id) => `score miss: ${id}`, eligibility: (id) => `eligibility condition ${id} becomes satisfied`, veto: (id) => `hard veto ${id} no longer triggers`, score: (id) => `score condition ${id} becomes satisfied` },
-    zh: { withheld: (pct) => `覆盖率 ${pct}%，分数被保留不发布`, unscored: "未评分", verdict: (stance, reason) => `${label}的冻结结论：${stance}（${reason}）`, summary: (score) => `按${label}方法审视 ${run.symbol}：PersonaPack v3 确定性政策已执行，得分 ${score}。该立场由结构化事实、硬否决和评分带产生，没有让语言模型选择立场。`, hit: (id) => `评分命中：${id}`, miss: (id) => `评分未命中：${id}`, eligibility: (id) => `资格条件 ${id} 变为满足`, veto: (id) => `硬否决 ${id} 不再触发`, score: (id) => `评分条件 ${id} 变为满足` },
-    ja: { withheld: (pct) => `カバレッジ ${pct}% のためスコアは非公開`, unscored: "未採点", verdict: (stance, reason) => `${label}の凍結済み判断：${stance}（${reason}）`, summary: (score) => `${label}の方法で ${run.symbol} を評価し、PersonaPack v3 の決定論的ポリシーを実行した結果、スコアは ${score}。構造化事実、ハード拒否条件、スコア帯がこの立場を生成しており、言語モデルは立場を選択していない。`, hit: (id) => `採点条件を満たす：${id}`, miss: (id) => `採点条件を満たさない：${id}`, eligibility: (id) => `適格条件 ${id} が満たされる`, veto: (id) => `ハード拒否条件 ${id} が解除される`, score: (id) => `採点条件 ${id} が満たされる` },
-    ko: { withheld: (pct) => `커버리지 ${pct}%로 점수를 공개하지 않음`, unscored: "미채점", verdict: (stance, reason) => `${label}의 동결된 판단: ${stance}(${reason})`, summary: (score) => `${label} 방법으로 ${run.symbol}을 검토하여 PersonaPack v3 결정론적 정책을 실행했으며 점수는 ${score}입니다. 구조화된 사실, 하드 거부 조건, 점수 구간이 이 입장을 만들었고 언어 모델은 입장을 선택하지 않았습니다.`, hit: (id) => `점수 조건 충족: ${id}`, miss: (id) => `점수 조건 미충족: ${id}`, eligibility: (id) => `적격 조건 ${id} 충족`, veto: (id) => `하드 거부 조건 ${id} 해제`, score: (id) => `점수 조건 ${id} 충족` },
+    en: { abstain: (reasons) => `Using the ${label} method, I do not issue a directional view on ${run.symbol} in this run: the method gate did not open (${reasons}). This is neither bearish nor a vote against the asset; the seat reassesses only once that gate can be satisfied.`, withheld: (pct) => `${pct}% coverage; score withheld`, unscored: "not scored", verdict: (stance, reason) => `${label} frozen decision: ${stance} (${reason})`, summary: (score) => `Using the ${label} method on ${run.symbol}, the PersonaPack v3 deterministic policy executed with score ${score}. Typed facts, hard vetoes, and score bands produced this stance; no language model selected it.`, hit: (id) => `score hit: ${id}`, miss: (id) => `score miss: ${id}`, eligibility: (id) => `eligibility condition ${id} becomes satisfied`, veto: (id) => `hard veto ${id} no longer triggers`, score: (id) => `score condition ${id} becomes satisfied` },
+    zh: { abstain: (reasons) => `按${label}方法审视 ${run.symbol}，本轮不作方向判断：方法闸门未打开（${reasons}）。这不是看空，也不是一张反对票；只有该闸门可被满足后，该席位才会重新评估。`, withheld: (pct) => `覆盖率 ${pct}%，分数被保留不发布`, unscored: "未评分", verdict: (stance, reason) => `${label}的冻结结论：${stance}（${reason}）`, summary: (score) => `按${label}方法审视 ${run.symbol}：PersonaPack v3 确定性政策已执行，得分 ${score}。该立场由结构化事实、硬否决和评分带产生，没有让语言模型选择立场。`, hit: (id) => `评分命中：${id}`, miss: (id) => `评分未命中：${id}`, eligibility: (id) => `资格条件 ${id} 变为满足`, veto: (id) => `硬否决 ${id} 不再触发`, score: (id) => `评分条件 ${id} 变为满足` },
+    ja: { abstain: (reasons) => `${label}の方法では、メソッドのゲートが開かなかったため（${reasons}）、今回は ${run.symbol} の方向判断を出しません。弱気判断や反対票ではなく、そのゲートが満たせるようになった時点で再評価します。`, withheld: (pct) => `カバレッジ ${pct}% のためスコアは非公開`, unscored: "未採点", verdict: (stance, reason) => `${label}の凍結済み判断：${stance}（${reason}）`, summary: (score) => `${label}の方法で ${run.symbol} を評価し、PersonaPack v3 の決定論的ポリシーを実行した結果、スコアは ${score}。構造化事実、ハード拒否条件、スコア帯がこの立場を生成しており、言語モデルは立場を選択していない。`, hit: (id) => `採点条件を満たす：${id}`, miss: (id) => `採点条件を満たさない：${id}`, eligibility: (id) => `適格条件 ${id} が満たされる`, veto: (id) => `ハード拒否条件 ${id} が解除される`, score: (id) => `採点条件 ${id} が満たされる` },
+    ko: { abstain: (reasons) => `${label} 방법으로는 방법론 게이트가 열리지 않아(${reasons}) 이번 실행에서 ${run.symbol}의 방향 판단을 내리지 않습니다. 이는 약세 판단이나 반대표가 아니며, 해당 게이트가 충족될 수 있을 때에만 재평가합니다.`, withheld: (pct) => `커버리지 ${pct}%로 점수를 공개하지 않음`, unscored: "미채점", verdict: (stance, reason) => `${label}의 동결된 판단: ${stance}(${reason})`, summary: (score) => `${label} 방법으로 ${run.symbol}을 검토하여 PersonaPack v3 결정론적 정책을 실행했으며 점수는 ${score}입니다. 구조화된 사실, 하드 거부 조건, 점수 구간이 이 입장을 만들었고 언어 모델은 입장을 선택하지 않았습니다.`, hit: (id) => `점수 조건 충족: ${id}`, miss: (id) => `점수 조건 미충족: ${id}`, eligibility: (id) => `적격 조건 ${id} 충족`, veto: (id) => `하드 거부 조건 ${id} 해제`, score: (id) => `점수 조건 ${id} 충족` },
   });
-  const vetoIds = (result.vetoes_triggered || []).map((veto) => veto.veto_id);
-  const unmet = result.eligibility?.unmet_condition_ids || [];
-  const hitIds = (result.score?.hits || []).map((rule) => rule.rule_id);
-  const missIds = (result.score?.misses || []).map((rule) => rule.rule_id);
+  // Every condition id in a frozen decision was hashed before the policy ran so the decision
+  // layer could not recognise the seat. Past this point the seat is named in the report and in
+  // the explanation worker's own prompt, so the hash only stops the seat from telling a reader
+  // which condition decided it. Resolve each id back to the one the pack declares.
+  const readableIds = technicalIdReadableMap(item.pack);
+  const readable = (id) => readableIds.get(id) || id;
+  const vetoIds = (result.vetoes_triggered || []).map((veto) => readable(veto.veto_id));
+  const unmet = (result.eligibility?.unmet_condition_ids || []).map(readable);
+  const hitIds = (result.score?.hits || []).map((rule) => readable(rule.rule_id));
+  const missIds = (result.score?.misses || []).map((rule) => readable(rule.rule_id));
   const sourceIds = uniqueStrings([
     ...(result.eligibility?.checks || []).flatMap((check) => check.source_ids || []),
     ...(result.vetoes_triggered || []).flatMap((veto) => veto.source_ids || []),
@@ -250,14 +275,29 @@ export function completedMasterOpinion(run, item) {
     : result.score
       ? `${result.score.score}/${result.score.max_possible} (${Math.round((result.ratio || 0) * 100)}%)`
     : copy.unscored;
-  const deterministicStatement = copy.summary(scoreText);
+  // An eligibility gate that closes produces a frozen out_of_scope with no score band, and the
+  // generic execution sentence says nothing a reader can use: not which condition closed the
+  // gate, and not that an abstention is not a bearish vote. The decline path has said both for
+  // a while; say the same here so no seat has to spend a model worker to state it.
+  const abstained = result.stance === "out_of_scope";
+  const abstainReasons = uniqueStrings([
+    ...(result.eligibility?.unmet_condition_ids || []).map(readable),
+    ...(result.eligibility?.uncomputable_condition_ids || []).map(readable),
+    ...(result.eligibility?.missing_required_fact_types || []),
+  ]);
+  // `summary` stays the provenance sentence -- it is what records that no language model chose
+  // the stance. Only the reader-facing statement changes, exactly as the decline path splits it.
+  const provenanceSummary = copy.summary(scoreText);
+  const deterministicStatement = abstained
+    ? copy.abstain(abstainReasons.join("; ") || result.reason || copy.unscored)
+    : provenanceSummary;
   return {
     master: item.id,
     symbol: run.symbol,
     as_of: run.as_of,
     stance: result.stance,
     verdict: copy.verdict(result.stance, result.reason),
-    summary: deterministicStatement,
+    summary: provenanceSummary,
     voice_statement: deterministicStatement,
     // The five fields, composed from the frozen decision rather than written about it: which
     // facts were read and their values, what the tools produced, which scoring conditions held
@@ -267,6 +307,7 @@ export function completedMasterOpinion(run, item) {
       result,
       policy: item.pack.components?.decision_policy,
       factPack: item.preDecision?.fact_pack,
+      readableIds,
       language: run.language,
     }),
     voice_status: "deterministic_fallback",
@@ -291,7 +332,11 @@ export function completedMasterOpinion(run, item) {
     decision_reason: result.reason,
     native_decision: result.native_decision,
     native_state: result.native_decision.state,
-    common_projection: result.common_projection,
+    // The frozen decision keeps its anonymised ids -- they are inside the hash. This is the
+    // reader-facing copy, so resolve the veto ids here and leave the frozen artifact alone.
+    common_projection: result.common_projection
+      ? { ...result.common_projection, veto_ids: (result.common_projection.veto_ids || []).map(readable) }
+      : result.common_projection,
     pack_hash: item.pack.pack_hash,
     corpus_hash: item.pack.corpus_hash,
     policy_hash: item.pack.policy_hash,

package/mcp/lib/personas-v3/runtime.mjs

@@ -153,6 +153,34 @@ function technicalIdentityAliases(value, compiledPack) {
   return aliases;
 }
 
+/**
+ * Reverse the pre-freeze aliasing for anything downstream of the freeze.
+ *
+ * The aliasing exists so the decision layer cannot recognise the seat it is deciding for. A
+ * reader is not the decision layer, and neither is the post-freeze explanation worker: its
+ * prompt opens by naming the persona, so an `anon_<hash>` there hides nothing and costs a
+ * great deal. It cost exactly this: two seats whose hard veto had been hashed guessed in
+ * their own recorded statements which condition had vetoed them, and both guessed wrong.
+ *
+ * Keyed by alias so a caller can resolve the ids that appear in a frozen decision. Only the
+ * seat's own declared condition ids are mapped; nothing else crosses back.
+ */
+export function technicalIdReadableMap(compiledPack) {
+  const policy = compiledPack?.components?.decision_policy || {};
+  const declared = [
+    ...(policy.scoring?.rules || []).map((rule) => rule?.rule_id),
+    ...(policy.hard_vetoes || []).map((veto) => veto?.veto_id),
+    ...(policy.eligibility?.all || [])
+      .map((check) => check?.condition_id || check?.check_id || check?.id),
+    // The computed values a seat cites are named by the tool that produced them, so a hashed
+    // output id turns "it computed credit_spread_gap = -0.038" into "it computed
+    // anon_69f0... = -0.038" -- a number with no stated meaning.
+    ...(compiledPack?.components?.tools || []).flatMap((tool) => [tool?.output_id, tool?.id]),
+  ].filter((id) => nonEmptyString(id));
+  const aliases = technicalIdentityAliases(declared, compiledPack);
+  return new Map([...aliases].map(([physical, alias]) => [alias, physical]));
+}
+
 function applyTechnicalAliases(value, aliases) {
   if (typeof value === "string") return aliases.get(value) || value;
   if (Array.isArray(value)) return value.map((child) => applyTechnicalAliases(child, aliases));