@cjhyy/code-shell-core 0.5.0-rc.0 → 0.5.0-rc.2

package/dist/agent/agent-definition-registry.d.ts

@@ -0,0 +1,29 @@
+import { type AgentDefinition } from "./agent-definition.js";
+export interface AgentSourceDir {
+    dir: string;
+    source: "project" | "user" | "plugin";
+}
+/**
+ * Loads reusable sub-agent role definitions from one or more directories
+ * of `*.md` files. Non-recursive. Malformed files are skipped with a
+ * warning rather than failing the whole load — one bad role file must
+ * not break the agent system.
+ *
+ * When multiple dirs define the same role name, the LAST dir wins. This is
+ * pure mechanism — the project>user POLICY lives in the caller's dir ORDER
+ * (loadAgentDefinitionsForCwd passes [user, ...plugins, project] so a repo's
+ * in-tree agent wins; see spec §7.2). The shadowing def is marked
+ * `override: true` and records the sources it shadowed in `shadowedSources`.
+ * Names in `disabled` are filtered out entirely after the merge, so the LLM
+ * never sees them.
+ */
+export declare class AgentDefinitionRegistry {
+    private defs;
+    readonly warnings: string[];
+    /** Back-compat single-dir loader (project source, no disabled filter). */
+    static loadFromDir(dir: string): AgentDefinitionRegistry;
+    static loadFromDirs(dirs: AgentSourceDir[], disabled: string[]): AgentDefinitionRegistry;
+    has(name: string): boolean;
+    get(name: string): AgentDefinition | undefined;
+    list(): AgentDefinition[];
+}

package/dist/agent/agent-definition-registry.js

@@ -0,0 +1,74 @@
+import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { parseAgentDefinition } from "./agent-definition.js";
+/**
+ * Loads reusable sub-agent role definitions from one or more directories
+ * of `*.md` files. Non-recursive. Malformed files are skipped with a
+ * warning rather than failing the whole load — one bad role file must
+ * not break the agent system.
+ *
+ * When multiple dirs define the same role name, the LAST dir wins. This is
+ * pure mechanism — the project>user POLICY lives in the caller's dir ORDER
+ * (loadAgentDefinitionsForCwd passes [user, ...plugins, project] so a repo's
+ * in-tree agent wins; see spec §7.2). The shadowing def is marked
+ * `override: true` and records the sources it shadowed in `shadowedSources`.
+ * Names in `disabled` are filtered out entirely after the merge, so the LLM
+ * never sees them.
+ */
+export class AgentDefinitionRegistry {
+    defs = new Map();
+    warnings = [];
+    /** Back-compat single-dir loader (project source, no disabled filter). */
+    static loadFromDir(dir) {
+        return AgentDefinitionRegistry.loadFromDirs([{ dir, source: "project" }], []);
+    }
+    static loadFromDirs(dirs, disabled) {
+        const reg = new AgentDefinitionRegistry();
+        for (const { dir, source } of dirs) {
+            if (!existsSync(dir) || !statSync(dir).isDirectory())
+                continue;
+            for (const entry of readdirSync(dir).sort()) {
+                if (!entry.endsWith(".md"))
+                    continue;
+                const full = join(dir, entry);
+                try {
+                    if (!statSync(full).isFile())
+                        continue;
+                    const def = parseAgentDefinition(readFileSync(full, "utf8"), entry);
+                    def.source = source;
+                    def.filePath = full;
+                    // A later dir overriding an earlier one. Carry forward the shadowed
+                    // sources (the prev def's own source + anything it already shadowed)
+                    // so a project def that shadows a plugin def that shadowed a user
+                    // def reports both.
+                    const prev = reg.defs.get(def.name);
+                    if (prev) {
+                        def.override = true;
+                        const shadowed = new Set(prev.shadowedSources ?? []);
+                        if (prev.source)
+                            shadowed.add(prev.source);
+                        def.shadowedSources = [...shadowed];
+                    }
+                    reg.defs.set(def.name, def);
+                }
+                catch (err) {
+                    reg.warnings.push(`${entry}: ${err.message}`);
+                }
+            }
+        }
+        // Filter disabled roles after the merge so a user override of a
+        // disabled name is still removed.
+        for (const name of new Set(disabled))
+            reg.defs.delete(name);
+        return reg;
+    }
+    has(name) {
+        return this.defs.has(name);
+    }
+    get(name) {
+        return this.defs.get(name);
+    }
+    list() {
+        return [...this.defs.values()];
+    }
+}

package/dist/agent/agent-definition.d.ts

@@ -0,0 +1,37 @@
+/** A reusable sub-agent role, loaded from a Markdown file. */
+export interface AgentDefinition {
+    /** Unique role key, e.g. "researcher". Matched against Agent({ agent_type }). */
+    name: string;
+    /** Human-facing summary of when to use this role. */
+    description: string;
+    /** Optional ModelPool key (e.g. "flash"). Undefined → inherit parent model. */
+    model?: string;
+    /** Optional turn cap for this role. Undefined → caller/default decides. */
+    maxTurns?: number;
+    /** Optional tool allowlist. Undefined → inherit parent's full tool set. */
+    tools?: string[];
+    /** Markdown body — becomes the child Engine's appendSystemPrompt. */
+    systemPrompt: string;
+    /** Where this def was loaded from. Runtime-only; never serialized. */
+    source?: "project" | "user" | "plugin";
+    /** Absolute path of the file it came from. Runtime-only. */
+    filePath?: string;
+    /** True when this def shadows a same-named def from a lower-priority dir. */
+    override?: boolean;
+    /** Sources whose same-named def this one shadows (runtime-only). Drives the
+     *  UI "this project overrides your user version" warning (spec §7.2). */
+    shadowedSources?: Array<"project" | "user" | "plugin">;
+}
+/**
+ * Parse a Markdown agent-definition file (YAML frontmatter + body).
+ * Pure: no filesystem access. `sourceName` is only used in error messages.
+ */
+export declare function parseAgentDefinition(raw: string, sourceName: string): AgentDefinition;
+/**
+ * Serialize an AgentDefinition back to a Markdown file body (YAML
+ * frontmatter + system prompt). Inverse of parseAgentDefinition.
+ * Optional fields that are unset are omitted entirely so an inheriting
+ * role (e.g. model undefined → inherit parent) stays clean on disk.
+ * Runtime-only metadata (source/filePath/override) is never written.
+ */
+export declare function serializeAgentDefinition(def: AgentDefinition): string;

package/dist/agent/agent-definition.js

@@ -0,0 +1,59 @@
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+/**
+ * Parse a Markdown agent-definition file (YAML frontmatter + body).
+ * Pure: no filesystem access. `sourceName` is only used in error messages.
+ */
+export function parseAgentDefinition(raw, sourceName) {
+    const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(raw.trim());
+    if (!match) {
+        throw new Error(`${sourceName}: missing YAML frontmatter (expected leading '---' block)`);
+    }
+    const [, yamlSrc, body] = match;
+    let fm;
+    try {
+        fm = (parseYaml(yamlSrc) ?? {});
+    }
+    catch (err) {
+        throw new Error(`${sourceName}: invalid YAML frontmatter — ${err.message}`, { cause: err });
+    }
+    if (typeof fm.name !== "string" || fm.name.trim().length === 0) {
+        throw new Error(`${sourceName}: frontmatter must include a non-empty 'name'`);
+    }
+    if (typeof fm.description !== "string" || fm.description.trim().length === 0) {
+        throw new Error(`${sourceName}: frontmatter must include a non-empty 'description'`);
+    }
+    const def = {
+        name: fm.name.trim(),
+        description: fm.description.trim(),
+        systemPrompt: body.trim(),
+    };
+    if (typeof fm.model === "string" && fm.model.trim())
+        def.model = fm.model.trim();
+    if (typeof fm.maxTurns === "number")
+        def.maxTurns = fm.maxTurns;
+    if (Array.isArray(fm.tools)) {
+        def.tools = fm.tools.filter((t) => typeof t === "string");
+    }
+    return def;
+}
+/**
+ * Serialize an AgentDefinition back to a Markdown file body (YAML
+ * frontmatter + system prompt). Inverse of parseAgentDefinition.
+ * Optional fields that are unset are omitted entirely so an inheriting
+ * role (e.g. model undefined → inherit parent) stays clean on disk.
+ * Runtime-only metadata (source/filePath/override) is never written.
+ */
+export function serializeAgentDefinition(def) {
+    const fm = {
+        name: def.name,
+        description: def.description,
+    };
+    if (def.model !== undefined)
+        fm.model = def.model;
+    if (def.maxTurns !== undefined)
+        fm.maxTurns = def.maxTurns;
+    if (def.tools !== undefined)
+        fm.tools = def.tools;
+    const yaml = stringifyYaml(fm).trimEnd();
+    return `---\n${yaml}\n---\n${def.systemPrompt}\n`;
+}

package/dist/arena/arena.js

@@ -28,6 +28,15 @@ import { runDetailExpansion } from "./phases/planning-detail-expansion.js";
 import { withLanguage } from "./strategies/language-wrapper.js";
 import { ArenaLedger } from "./ledger.js";
 import { registerClaims } from "./phases/claim-registry.js";
+/** Bucket claims by status. Shared by the two consensus phases. */
+function summarizeClaims(all) {
+    return {
+        verified: all.filter((c) => c.status === "verified"),
+        contested: all.filter((c) => c.status === "contested"),
+        unresolved: all.filter((c) => c.status === "unresolved"),
+        rejected: all.filter((c) => c.status === "rejected"),
+    };
+}
 export class Arena {
     config;
     strategy;
@@ -192,12 +201,7 @@ export class Arena {
         signal?.throwIfAborted();
         // ─── Roadmap Consensus ───────────────────────────────────
         const allClaims = ledger.getAllClaims();
-        const claimSummary = {
-            verified: allClaims.filter((c) => c.status === "verified"),
-            contested: allClaims.filter((c) => c.status === "contested"),
-            unresolved: allClaims.filter((c) => c.status === "unresolved"),
-            rejected: allClaims.filter((c) => c.status === "rejected"),
-        };
+        const claimSummary = summarizeClaims(allClaims);
         logger.info("arena.planning_consensus_phase", { concluder: concluder.name });
         const consensus = await buildConsensus({
             concluder,
@@ -295,12 +299,7 @@ export class Arena {
         signal?.throwIfAborted();
         // ─── Consensus (claim-aware) ─────────────────────────────
         const allClaims = ledger.getAllClaims();
-        const claimSummary = {
-            verified: allClaims.filter((c) => c.status === "verified"),
-            contested: allClaims.filter((c) => c.status === "contested"),
-            unresolved: allClaims.filter((c) => c.status === "unresolved"),
-            rejected: allClaims.filter((c) => c.status === "rejected"),
-        };
+        const claimSummary = summarizeClaims(allClaims);
         logger.info("arena.consensus_phase", {
             concluder: concluder.name,
             verified: claimSummary.verified.length,

package/dist/arena/context/context-tools.js

@@ -9,6 +9,7 @@
 import { readFileSync, existsSync, readdirSync, statSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { resolve, join } from "node:path";
+import { isWithinRoot } from "./within-root.js";
 export const MAX_TOOL_RESULT = 15_000; // chars per tool call
 // 5 was too generous for thinking-mode models — they'd spend the
 // entire budget on read_file with textLen=0, then need an
@@ -112,10 +113,7 @@ export function executeContextTool(tc) {
  */
 function validatePath(filePath) {
     const resolved = resolve(filePath);
-    if (resolved === REPO_ROOT || resolved.startsWith(REPO_ROOT + "/")) {
-        return resolved;
-    }
-    return null;
+    return isWithinRoot(REPO_ROOT, resolved) ? resolved : null;
 }
 function executeReadFile(args) {
     const filePath = args.path;

package/dist/arena/context/within-root.d.ts

@@ -0,0 +1,7 @@
+/**
+ * True when `target` is the root itself or a descendant of it. Uses the
+ * platform separator (the old check hardcoded "/", which broke on Windows)
+ * and avoids the sibling-prefix trap (/repo vs /repo-evil). Both inputs are
+ * assumed already resolved to absolute paths.
+ */
+export declare function isWithinRoot(root: string, target: string): boolean;

package/dist/arena/context/within-root.js

@@ -0,0 +1,15 @@
+import * as path from "node:path";
+/**
+ * True when `target` is the root itself or a descendant of it. Uses the
+ * platform separator (the old check hardcoded "/", which broke on Windows)
+ * and avoids the sibling-prefix trap (/repo vs /repo-evil). Both inputs are
+ * assumed already resolved to absolute paths.
+ */
+export function isWithinRoot(root, target) {
+    if (target === root)
+        return true;
+    const rel = path.relative(root, target);
+    // Outside the root iff the relative path climbs out ("..") or is absolute
+    // (different drive on Windows).
+    return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+}

package/dist/arena/iterate/phases/argue.js

@@ -61,7 +61,7 @@ export async function runArgueRound(args) {
 // ─── Single-shot argue (no tools) ─────────────────────────────────────
 async function argueSingleShot(args) {
     const { critic, subject, format, draft, idPrefix, signal } = args;
-    const client = await createLLMClient({ ...critic.llm, enableStreaming: false });
+    const client = await createLLMClient(critic.llm, critic.clientDefaults);
     const resp = await client.createMessage({
         systemPrompt: format.argueSystem(format.format),
         messages: [{ role: "user", content: format.argueUser(subject, draft) }],
@@ -78,7 +78,7 @@ async function argueSingleShot(args) {
 // ─── Tool-use argue (with web search) ─────────────────────────────────
 async function argueWithToolLoop(args) {
     const { critic, subject, format, draft, idPrefix, maxToolRounds, signal } = args;
-    const client = await createLLMClient({ ...critic.llm, enableStreaming: false });
+    const client = await createLLMClient(critic.llm, critic.clientDefaults);
     const messages = [
         { role: "user", content: format.argueUser(subject, draft) },
     ];
@@ -149,6 +149,12 @@ async function argueWithToolLoop(args) {
         });
         finalText = resp.text;
     }
+    if (!finalText) {
+        // Both the tool loop and the force-conclude fallback produced no text
+        // (e.g. repeated max-token truncation). Log it — parseCritiquesResponse
+        // will just yield no critiques rather than silently parsing "".
+        logger.warn("arena.iterate.argue_empty_response", { critic: critic.name, toolRounds });
+    }
     const critiques = parseCritiquesResponse(finalText, critic.name, idPrefix);
     logger.info("arena.iterate.argue_toolloop", {
         critic: critic.name,

package/dist/arena/iterate/phases/revise.js

@@ -7,7 +7,7 @@ import { parseReviseResponse } from "../parse.js";
 export async function runRevise(args) {
     const { subject, format, previous, critiques, author, minDraftLength, signal, onProgress } = args;
     onProgress?.({ type: "revise_start", round: previous.version + 1, participant: author.name });
-    const client = await createLLMClient({ ...author.llm, enableStreaming: false });
+    const client = await createLLMClient(author.llm, author.clientDefaults);
     const prompt = format.revisePrompt(subject, previous, critiques, minDraftLength);
     const resp = await client.createMessage({
         systemPrompt: prompt,

package/dist/arena/iterate/phases/tournament.js

@@ -11,7 +11,7 @@ export async function runTournamentCandidates(args) {
     onProgress?.({ type: "v1_tournament_start", data: { count: participants.length } });
     const tasks = participants.map(async (p, idx) => {
         signal?.throwIfAborted();
-        const client = await createLLMClient({ ...p.llm, enableStreaming: false });
+        const client = await createLLMClient(p.llm, p.clientDefaults);
         const prompt = format.draftPrompt(subject, minDraftLength);
         // Long-form generation needs a high output ceiling; the default 8k from
         // LLMClientBase is too low for a substantive PRD or design doc and
@@ -66,7 +66,7 @@ export async function runTournamentCandidates(args) {
 export async function mergeCandidatesToV1(args) {
     const { subject, format, author, candidates, minDraftLength, signal, onProgress } = args;
     onProgress?.({ type: "v1_merge_start", participant: author.name });
-    const client = await createLLMClient({ ...author.llm, enableStreaming: false });
+    const client = await createLLMClient(author.llm, author.clientDefaults);
     const prompt = format.mergePrompt(subject, candidates, minDraftLength);
     const resp = await client.createMessage({
         systemPrompt: prompt,
@@ -95,7 +95,7 @@ export async function mergeCandidatesToV1(args) {
 /** Single-author v1 (tournament disabled) — author writes alone. */
 export async function singleAuthorV1(args) {
     const { subject, format, author, minDraftLength, signal } = args;
-    const client = await createLLMClient({ ...author.llm, enableStreaming: false });
+    const client = await createLLMClient(author.llm, author.clientDefaults);
     const prompt = format.draftPrompt(subject, minDraftLength);
     const resp = await client.createMessage({
         systemPrompt: prompt,

package/dist/arena/phases/adjudication.js

@@ -33,10 +33,7 @@ export async function runAdjudication(options) {
         verified: verifiedClaims.length,
     });
     // Adjudicate contested claims via LLM
-    const client = await createLLMClient({
-        ...concluder.llm,
-        enableStreaming: false,
-    });
+    const client = await createLLMClient(concluder.llm, concluder.clientDefaults);
     for (const claim of contestedClaims) {
         signal?.throwIfAborted();
         const digest = buildDigest(ledger, {

package/dist/arena/phases/build-consensus.js

@@ -18,10 +18,7 @@ import { isStrategyV2 } from "../types.js";
 export async function buildConsensus(options) {
     const { concluder, strategy, topic, reports, reviews, claimSummary, signal, onProgress } = options;
     onProgress?.({ type: "consensus_start" });
-    const client = await createLLMClient({
-        ...concluder.llm,
-        enableStreaming: false,
-    });
+    const client = await createLLMClient(concluder.llm, concluder.clientDefaults);
     const systemPrompt = strategy.consensusSystemPrompt();
     // Choose user prompt: claim-aware (V2) or standard (V1)
     let userContent;

package/dist/arena/phases/cross-review.js

@@ -28,10 +28,7 @@ export async function runCrossReview(options) {
             return [];
         if (!myReport)
             return [];
-        const client = await createLLMClient({
-            ...p.llm,
-            enableStreaming: false,
-        });
+        const client = await createLLMClient(p.llm, p.clientDefaults);
         const systemPrompt = strategy.crossReviewSystemPrompt(p.name);
         const userContent = strategy.crossReviewUserPrompt(topic, myReport, otherReports);
         let response = await client.createMessage({
@@ -110,10 +107,7 @@ export async function runVerificationReview(options) {
         const myClaims = claimsToReview.filter((c) => c.owner !== p.name);
         if (myClaims.length === 0)
             return;
-        const client = await createLLMClient({
-            ...p.llm,
-            enableStreaming: false,
-        });
+        const client = await createLLMClient(p.llm, p.clientDefaults);
         const systemPrompt = strategy.crossReviewSystemPrompt(p.name);
         if (v2) {
             // V2 path: claim-aware verification review (or merge review for planning)

package/dist/arena/phases/debate-rounds.js

@@ -75,10 +75,7 @@ async function debateClaim(options) {
         });
         // Each debater produces a turn
         const turnPromises = debaters.map(async (p) => {
-            const client = await createLLMClient({
-                ...p.llm,
-                enableStreaming: false,
-            });
+            const client = await createLLMClient(p.llm, p.clientDefaults);
             const systemPrompt = strategy.crossReviewSystemPrompt(p.name);
             let userContent;
             if (v2) {

package/dist/arena/phases/participant-research.js

@@ -27,10 +27,7 @@ export async function runParticipantResearchWithDossiers(options) {
     const tools = enableContextTools ? (contextTools ?? CONTEXT_TOOLS) : undefined;
     const tasks = participants.map(async (p) => {
         onProgress?.({ type: "research_start", participant: p.name });
-        const client = await createLLMClient({
-            ...p.llm,
-            enableStreaming: false,
-        });
+        const client = await createLLMClient(p.llm, p.clientDefaults);
         const messages = [
             {
                 role: "user",

package/dist/arena/phases/planning-detail-expansion.js

@@ -31,10 +31,7 @@ export async function runDetailExpansion(options) {
     onProgress?.({ type: "roadmap_expansion_start", phaseCount: toExpand.length });
     logger.info("arena.detail_expansion_start", { phaseCount: toExpand.length });
     const details = [];
-    const client = await createLLMClient({
-        ...concluder.llm,
-        enableStreaming: false,
-    });
+    const client = await createLLMClient(concluder.llm, concluder.clientDefaults);
     const systemPrompt = strategy.detailExpansionSystemPrompt();
     // Expand each phase sequentially
     for (const phase of toExpand) {
@@ -45,13 +42,18 @@ export async function runDetailExpansion(options) {
         const userContent = strategy.detailExpansionUserPrompt(topic, phase, digest);
         const messages = [{ role: "user", content: userContent }];
         let finalText = "";
-        // Tool-use loop: allow LLM to verify file paths and interfaces
+        // Tool-use loop: allow LLM to verify file paths and interfaces.
+        // `maxRounds` bounds the number of tool rounds; after the last one we make
+        // one final call (without tools) so the model produces text FROM the tool
+        // results rather than the empty text it emitted alongside the tool calls.
         const maxRounds = tools ? Math.min(MAX_EXPANSION_TOOL_ROUNDS, MAX_TOOL_ROUNDS) : 0;
         for (let round = 0; round <= maxRounds; round++) {
+            // On the final round, stop offering tools so the model must answer.
+            const offerTools = round < maxRounds ? tools : undefined;
             const response = await client.createMessage({
                 systemPrompt,
                 messages,
-                tools,
+                tools: offerTools,
                 signal,
             });
             const hasTools = response.toolCalls && response.toolCalls.length > 0;
@@ -90,10 +92,6 @@ export async function runDetailExpansion(options) {
                 });
             }
             messages.push({ role: "user", content: toolResultBlocks });
-            // Last round: force a text response
-            if (round === maxRounds) {
-                finalText = response.text;
-            }
         }
         // Retry if truncated
         if (!finalText) {

package/dist/arena/planner.js

@@ -67,7 +67,6 @@ export async function planArena(topic, llmConfig, flags, signal) {
         signal?.throwIfAborted();
         const client = await createLLMClient({
             ...llmConfig,
-            enableStreaming: false,
             maxTokens: 1024,
         });
         const response = await client.createMessage({

package/dist/arena/providers/docs.d.ts

@@ -4,3 +4,4 @@
  */
 import type { ArenaContextProvider } from "../types.js";
 export declare const docsProvider: ArenaContextProvider;
+export declare function truncate(content: string): string;

package/dist/arena/providers/docs.js

@@ -99,10 +99,13 @@ function safeReadDoc(filePath) {
         return null;
     }
 }
-function truncate(content) {
+export function truncate(content) {
     if (content.length <= MAX_DOC_CHARS)
         return content;
     const t = content.slice(0, MAX_DOC_CHARS);
     const lastNl = t.lastIndexOf("\n");
-    return t.slice(0, lastNl) + `\n... (truncated, ${content.length} chars total)`;
+    // No newline in the window → lastNl is -1 and slice(0,-1) would drop just
+    // the last char; cut at MAX_DOC_CHARS instead.
+    const body = lastNl > 0 ? t.slice(0, lastNl) : t;
+    return body + `\n... (truncated, ${content.length} chars total)`;
 }

package/dist/arena/providers/repo.d.ts

@@ -4,3 +4,4 @@
  */
 import type { ArenaContextProvider } from "../types.js";
 export declare const repoProvider: ArenaContextProvider;
+export declare function truncate(content: string): string;

package/dist/arena/providers/repo.js

@@ -192,12 +192,15 @@ function safeReadFile(filePath) {
         return null;
     }
 }
-function truncate(content) {
+export function truncate(content) {
     if (content.length <= MAX_FILE_CHARS)
         return content;
     const t = content.slice(0, MAX_FILE_CHARS);
     const lastNl = t.lastIndexOf("\n");
-    return t.slice(0, lastNl) + `\n... (truncated, ${content.length} chars total)`;
+    // No newline in the window (e.g. a minified file) → lastNl is -1 and
+    // slice(0,-1) would drop just the last char; cut at MAX_FILE_CHARS instead.
+    const body = lastNl > 0 ? t.slice(0, lastNl) : t;
+    return body + `\n... (truncated, ${content.length} chars total)`;
 }
 async function safeGrep(pattern) {
     try {

package/dist/arena/strategies/utils.js

@@ -68,11 +68,44 @@ export function extractJSONArray(text) {
     const fenced = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
     if (fenced)
         return fenced[1].trim();
-    const arrayMatch = text.match(/\[[\s\S]*\]/);
-    if (arrayMatch)
-        return arrayMatch[0];
+    // Return the FIRST balanced top-level array. A greedy /\[[\s\S]*\]/ spanned
+    // to the last ']', merging two arrays (or trailing prose) into one invalid
+    // blob. Scan for bracket balance, ignoring brackets inside strings.
+    const balanced = firstBalancedArray(text);
+    if (balanced)
+        return balanced;
     return text;
 }
+function firstBalancedArray(text) {
+    const start = text.indexOf("[");
+    if (start === -1)
+        return undefined;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (ch === "\\")
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === "[")
+            depth++;
+        else if (ch === "]") {
+            depth--;
+            if (depth === 0)
+                return text.slice(start, i + 1);
+        }
+    }
+    return undefined; // unbalanced
+}
 /** Format base context into a readable text block for LLM prompts */
 export function formatBaseContext(ctx) {
     const sections = [];

package/dist/arena/transitions.d.ts

@@ -5,9 +5,14 @@
  * consistent state transitions across phases.
  *
  * State machine:
- *   proposed → under_review
- *   under_review → verified | contested | rejected
+ *   proposed → under_review | unresolved
+ *   under_review → verified | contested | rejected | unresolved
  *   contested → under_review | unresolved | verified | rejected
+ *
+ * `unresolved` is reachable from proposed/under_review (not just contested):
+ * adjudication sweeps any claims left in those states when the round/budget
+ * is exhausted (adjudication.ts) — without these edges markUnresolved() would
+ * silently no-op and the claims would be dropped from the consensus summary.
  */
 import type { ClaimRecord, ClaimStatus, ClaimChallenge } from "./types.js";
 /**

package/dist/arena/transitions.js

@@ -5,14 +5,19 @@
  * consistent state transitions across phases.
  *
  * State machine:
- *   proposed → under_review
- *   under_review → verified | contested | rejected
+ *   proposed → under_review | unresolved
+ *   under_review → verified | contested | rejected | unresolved
  *   contested → under_review | unresolved | verified | rejected
+ *
+ * `unresolved` is reachable from proposed/under_review (not just contested):
+ * adjudication sweeps any claims left in those states when the round/budget
+ * is exhausted (adjudication.ts) — without these edges markUnresolved() would
+ * silently no-op and the claims would be dropped from the consensus summary.
  */
 /** Valid transitions from each status */
 const VALID_TRANSITIONS = {
-    proposed: ["under_review"],
-    under_review: ["verified", "contested", "rejected"],
+    proposed: ["under_review", "unresolved"],
+    under_review: ["verified", "contested", "rejected", "unresolved"],
     contested: ["under_review", "unresolved", "verified", "rejected"],
     verified: [],
     rejected: [],