@pruddiman/hem 0.0.1-beta-6f925fe → 0.0.1-beta-1aff12a

package/dist/agents/arbiter-agent.d.ts

@@ -12,53 +12,24 @@
  *   2. `wrapUp()` — called after all workers complete.  Sends a final
  *                    prompt so the arbiter can issue any remaining
  *                    DECISION messages.  Non-fatal on failure.
+ *
+ * Lifecycle methods are inherited from {@link BaseArbiter}; this class
+ * supplies only the configuration values and the prompt body.
  */
-import type { Provider } from "../providers/types.js";
-import { BaseAgent } from "./base-agent.js";
-import type { WorkerAssignment } from "./organization-agent.js";
+import { BaseArbiter, type BaseArbiterPromptParams } from "./base-arbiter.js";
 /** Parameters for the arbiter prompt. */
-export interface ArbiterPromptParams {
-    /** Project name. */
-    projectName: string;
-    /** Absolute path to the destination directory. */
-    destinationPath: string;
-    /** ALL documentation files (for full awareness). */
-    allDocFiles: string[];
-    /** Worker assignments mapping each worker label to its owned files. */
-    workerAssignments: WorkerAssignment[];
-}
+export type ArbiterPromptParams = BaseArbiterPromptParams;
 /**
  * A coordinator agent that monitors worker broadcasts and issues
  * DECISION directives to resolve cross-subset issues.
  *
  * Does NOT edit files — directs workers to make all changes.
  */
-export declare class ArbiterAgent extends BaseAgent {
-    constructor(provider: Provider);
-    /**
-     * Create the arbiter session and send the initial prompt.
-     *
-     * The initial prompt is sent via `promptAsync` (fire-and-forget) because
-     * the arbiter sits idle until it receives broadcasts from workers.
-     *
-     * @returns The session ID so the caller can register it in the SSE
-     *          relay map and later call `wrapUp()`.
-     * @throws {AuthExpiredError} If session creation or the initial prompt
-     *         fails due to authentication expiry.
-     */
-    run(params: ArbiterPromptParams, verbose?: (msg: string) => void): Promise<{
-        sessionId: string;
-    }>;
-    /**
-     * Send the wrap-up prompt after all workers have completed.
-     *
-     * Asks the arbiter to issue any remaining DECISION messages and then
-     * output its final `{ "status": "complete" }` response.
-     *
-     * This is intentionally **non-fatal** — if the arbiter fails, workers
-     * have already produced their manifests and the pipeline can continue.
-     */
-    wrapUp(sessionId: string, verbose?: (msg: string) => void): Promise<void>;
+export declare class ArbiterAgent extends BaseArbiter<ArbiterPromptParams> {
+    protected readonly tag = "arbiter";
+    protected readonly sessionTitle = "Hem: arbiter";
+    protected readonly agentField = "hem-org";
+    protected makePrompt(params: ArbiterPromptParams): string;
     /**
      * Builds the arbiter prompt.
      *

package/dist/agents/arbiter-agent.js

@@ -12,9 +12,11 @@
  *   2. `wrapUp()` — called after all workers complete.  Sends a final
  *                    prompt so the arbiter can issue any remaining
  *                    DECISION messages.  Non-fatal on failure.
+ *
+ * Lifecycle methods are inherited from {@link BaseArbiter}; this class
+ * supplies only the configuration values and the prompt body.
  */
-import { isAuthExpired, AuthExpiredError } from "../auth.js";
-import { BaseAgent } from "./base-agent.js";
+import { BaseArbiter, } from "./base-arbiter.js";
 // ── Agent ───────────────────────────────────────────────────────────────
 /**
  * A coordinator agent that monitors worker broadcasts and issues
@@ -22,82 +24,12 @@ import { BaseAgent } from "./base-agent.js";
  *
  * Does NOT edit files — directs workers to make all changes.
  */
-export class ArbiterAgent extends BaseAgent {
-    constructor(provider) {
-        super(provider);
-    }
-    /**
-     * Create the arbiter session and send the initial prompt.
-     *
-     * The initial prompt is sent via `promptAsync` (fire-and-forget) because
-     * the arbiter sits idle until it receives broadcasts from workers.
-     *
-     * @returns The session ID so the caller can register it in the SSE
-     *          relay map and later call `wrapUp()`.
-     * @throws {AuthExpiredError} If session creation or the initial prompt
-     *         fails due to authentication expiry.
-     */
-    async run(params, verbose) {
-        const tag = "arbiter";
-        // 1. Build prompt
-        const prompt = ArbiterAgent.buildPrompt(params);
-        if (verbose) {
-            verbose(`[${tag}] prompt ${prompt.length.toLocaleString()} chars`);
-        }
-        // 2. Create session
-        const sessionId = await this.createSession("Hem: arbiter");
-        if (verbose) {
-            verbose(`[${tag}] session ${sessionId}`);
-        }
-        // 3. Fire the initial prompt (fire-and-forget — arbiter waits for broadcasts)
-        try {
-            await this.provider.session.promptAsync({
-                path: { id: sessionId },
-                body: {
-                    parts: [{ type: "text", text: prompt }],
-                    agent: "hem-org",
-                },
-            });
-        }
-        catch (err) {
-            if (isAuthExpired(err)) {
-                throw new AuthExpiredError("the configured provider", err);
-            }
-            throw err;
-        }
-        if (verbose) {
-            verbose(`[${tag}] initial prompt sent (listening for broadcasts)`);
-        }
-        return { sessionId };
-    }
-    /**
-     * Send the wrap-up prompt after all workers have completed.
-     *
-     * Asks the arbiter to issue any remaining DECISION messages and then
-     * output its final `{ "status": "complete" }` response.
-     *
-     * This is intentionally **non-fatal** — if the arbiter fails, workers
-     * have already produced their manifests and the pipeline can continue.
-     */
-    async wrapUp(sessionId, verbose) {
-        const tag = "arbiter";
-        if (verbose) {
-            verbose(`[${tag}] all workers done, sending wrap-up prompt`);
-        }
-        try {
-            const wrapUpResponse = await this.provider.prompt(sessionId, "All workers have completed their tasks. If you have any remaining " +
-                "DECISION messages to issue, broadcast them now. Otherwise, output your " +
-                'final `{ "status": "complete" }` response.', { agent: "hem-org" });
-            if (verbose) {
-                verbose(`[${tag}] wrap-up response (${(wrapUpResponse ?? "").length} chars)`);
-            }
-        }
-        catch (err) {
-            // Arbiter failure is not fatal — workers already produced manifests
-            if (verbose) {
-                verbose(`[${tag}] ⚠ wrap-up failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
+export class ArbiterAgent extends BaseArbiter {
+    tag = "arbiter";
+    sessionTitle = "Hem: arbiter";
+    agentField = "hem-org";
+    makePrompt(params) {
+        return ArbiterAgent.buildPrompt(params);
     }
     /**
      * Builds the arbiter prompt.

package/dist/agents/architecture-agent.d.ts

@@ -144,5 +144,5 @@ export declare class ArchitectureAgent extends BaseAgent {
      * normal-mode `buildPrompt()`, but substitutes chunk summaries for
      * the raw findings.
      */
-    static buildSynthesisPrompt(params: ArchPromptParams, chunkSummaries: ArchChunkSummary[]): string;
+    static buildSynthesisPrompt(params: ArchPromptParams, chunkSummaries: ArchChunkSummary[], failedChunks?: number): string;
 }

package/dist/agents/architecture-agent.js

@@ -120,6 +120,7 @@ export class ArchitectureAgent extends BaseAgent {
         // Collect results; use empty fallback for failed chunks so synthesis still runs.
         // Re-throw AuthExpiredError immediately.
         const chunkSummaries = [];
+        let failedChunks = 0;
         for (let i = 0; i < settled.length; i++) {
             const result = settled[i];
             if (result.status === "fulfilled") {
@@ -129,19 +130,26 @@ export class ArchitectureAgent extends BaseAgent {
                 if (result.reason instanceof AuthExpiredError) {
                     throw result.reason;
                 }
+                failedChunks++;
+                const msg = result.reason instanceof Error ? result.reason.message : String(result.reason);
                 if (verbose) {
-                    const msg = result.reason instanceof Error ? result.reason.message : String(result.reason);
                     verbose(`[${tag}] chunk-${i + 1}/${chunks.length} failed: ${msg}`);
                 }
                 // Push an empty fallback so the synthesis index is not skewed
                 chunkSummaries.push(ArchitectureAgent.parseChunkSummary("", i));
             }
         }
+        // Always surface chunk failures to stderr so users running without --verbose
+        // know the architecture overview was synthesized from incomplete data.
+        if (failedChunks > 0) {
+            console.warn(`[${tag}] WARNING: ${failedChunks}/${chunks.length} chunk summarisation(s) failed; ` +
+                `architecture overview will be synthesized from incomplete data.`);
+        }
         // 3. Final synthesis — combine chunk summaries into architecture.md
         if (verbose) {
             verbose(`[${tag}] Running synthesis from ${chunkSummaries.length} chunk summaries`);
         }
-        const synthesisPrompt = ArchitectureAgent.buildSynthesisPrompt(params, chunkSummaries);
+        const synthesisPrompt = ArchitectureAgent.buildSynthesisPrompt(params, chunkSummaries, failedChunks);
         if (verbose) {
             verbose(`[${tag}] Synthesis prompt: ${synthesisPrompt.length.toLocaleString()} chars`);
         }
@@ -378,11 +386,14 @@ export class ArchitectureAgent extends BaseAgent {
      * normal-mode `buildPrompt()`, but substitutes chunk summaries for
      * the raw findings.
      */
-    static buildSynthesisPrompt(params, chunkSummaries) {
+    static buildSynthesisPrompt(params, chunkSummaries, failedChunks = 0) {
         const { projectName, sourceRoot, destinationPath, allDocFiles } = params;
         const parts = [];
         // 1. System-level instructions
         parts.push(`Generate a comprehensive architecture overview that gives readers a mental model`, `of the entire system before they dive into individual feature or module pages.`, "", `**Write files directly using the edit tool.** Do NOT return Markdown content`, `in the response text. Instead, use the edit tool to create \`architecture.md\``, `in the destination directory. When done, stop.`, "", `**NOTE**: This project is too large for a single-pass analysis. The findings`, `below are pre-summarised from ${chunkSummaries.length} analysis chunks.`, `Synthesize them into a unified architecture overview.`, "");
+        if (failedChunks > 0) {
+            parts.push(`**DATA QUALITY CAVEAT**: ${failedChunks} of ${chunkSummaries.length} chunk`, `summarisation pass(es) failed and were replaced with empty placeholders.`, `Some areas of the codebase therefore have no findings in this synthesis.`, `Acknowledge this gap explicitly in the architecture overview rather than`, `inventing details about the missing chunks.`, "");
+        }
         // 2. Where to write
         parts.push("## Destination", "", `Write the architecture overview to: \`${destinationPath}/architecture.md\``, "");
         // 3. Quality standards (same as buildPrompt)

package/dist/agents/base-arbiter.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared base class for Hem's parallel-pass coordinator agents.
+ *
+ * Both {@link ArbiterAgent} (organization pass) and
+ * {@link CrossRefArbiterAgent} (cross-reference pass) follow the same
+ * two-phase lifecycle:
+ *
+ *   1. `run()`     — create the session and fire the initial prompt via
+ *                    `promptAsync` (fire-and-forget). Returns `{ sessionId }`
+ *                    so the caller can register it in the SSE relay map.
+ *   2. `wrapUp()`  — send a final prompt asking the arbiter to issue any
+ *                    remaining DECISION messages. Intentionally non-fatal:
+ *                    workers have already produced their edits.
+ *
+ * The only differences between the two arbiters are:
+ *   - log tag (`arbiter` vs `xref-arbiter`)
+ *   - session title (`Hem: arbiter` vs `Hem: xref-arbiter`)
+ *   - OpenCode agent field (`hem-org` vs `hem-xref`)
+ *   - the body of the initial prompt (provided by subclass `makePrompt`)
+ *
+ * `BaseArbiter` factors out the lifecycle skeleton; subclasses provide
+ * the four configuration values above.
+ */
+import type { Provider } from "../providers/types.js";
+import { BaseAgent } from "./base-agent.js";
+import type { WorkerAssignment } from "./organization-agent.js";
+/**
+ * Shared shape for arbiter prompt parameters. Both
+ * {@link ArbiterPromptParams} and {@link CrossRefArbiterPromptParams}
+ * are structural aliases for this type.
+ */
+export interface BaseArbiterPromptParams {
+    /** Project name. */
+    projectName: string;
+    /** Absolute path to the destination directory. */
+    destinationPath: string;
+    /** ALL documentation files (for full awareness). */
+    allDocFiles: string[];
+    /** Worker assignments mapping each worker label to its owned files. */
+    workerAssignments: WorkerAssignment[];
+}
+/**
+ * Abstract base for arbiter coordinator agents. Concrete subclasses
+ * override the four `protected` configuration fields and `makePrompt`.
+ */
+export declare abstract class BaseArbiter<P extends BaseArbiterPromptParams = BaseArbiterPromptParams> extends BaseAgent {
+    /** Short tag used in verbose log lines. */
+    protected abstract readonly tag: string;
+    /** Human-readable session title shown in the OpenCode session UI. */
+    protected abstract readonly sessionTitle: string;
+    /** OpenCode agent name routed to in `body.agent`. */
+    protected abstract readonly agentField: string;
+    constructor(provider: Provider);
+    /**
+     * Subclass hook: build the initial prompt body. Called once from {@link run}.
+     */
+    protected abstract makePrompt(params: P): string;
+    /**
+     * Create the arbiter session and fire its initial prompt.
+     *
+     * The initial prompt uses `promptAsync` (fire-and-forget) because the
+     * arbiter sits idle until it receives broadcasts from workers.
+     *
+     * @returns `{ sessionId }` so the caller can register the session for
+     *   SSE relaying and later call {@link wrapUp}.
+     * @throws {AuthExpiredError} If session creation or the initial prompt
+     *   fails due to authentication expiry.
+     */
+    run(params: P, verbose?: (msg: string) => void): Promise<{
+        sessionId: string;
+    }>;
+    /**
+     * Send the wrap-up prompt after all workers have completed.
+     *
+     * Asks the arbiter to issue any remaining DECISION messages and emit
+     * its final `{ "status": "complete" }` response.
+     *
+     * Intentionally **non-fatal** — workers have already made their edits;
+     * a wrap-up failure does not block the pipeline.
+     */
+    wrapUp(sessionId: string, verbose?: (msg: string) => void): Promise<void>;
+}

package/dist/agents/base-arbiter.js

@@ -0,0 +1,101 @@
+/**
+ * Shared base class for Hem's parallel-pass coordinator agents.
+ *
+ * Both {@link ArbiterAgent} (organization pass) and
+ * {@link CrossRefArbiterAgent} (cross-reference pass) follow the same
+ * two-phase lifecycle:
+ *
+ *   1. `run()`     — create the session and fire the initial prompt via
+ *                    `promptAsync` (fire-and-forget). Returns `{ sessionId }`
+ *                    so the caller can register it in the SSE relay map.
+ *   2. `wrapUp()`  — send a final prompt asking the arbiter to issue any
+ *                    remaining DECISION messages. Intentionally non-fatal:
+ *                    workers have already produced their edits.
+ *
+ * The only differences between the two arbiters are:
+ *   - log tag (`arbiter` vs `xref-arbiter`)
+ *   - session title (`Hem: arbiter` vs `Hem: xref-arbiter`)
+ *   - OpenCode agent field (`hem-org` vs `hem-xref`)
+ *   - the body of the initial prompt (provided by subclass `makePrompt`)
+ *
+ * `BaseArbiter` factors out the lifecycle skeleton; subclasses provide
+ * the four configuration values above.
+ */
+import { isAuthExpired, AuthExpiredError } from "../auth.js";
+import { BaseAgent } from "./base-agent.js";
+/**
+ * Abstract base for arbiter coordinator agents. Concrete subclasses
+ * override the four `protected` configuration fields and `makePrompt`.
+ */
+export class BaseArbiter extends BaseAgent {
+    constructor(provider) {
+        super(provider);
+    }
+    /**
+     * Create the arbiter session and fire its initial prompt.
+     *
+     * The initial prompt uses `promptAsync` (fire-and-forget) because the
+     * arbiter sits idle until it receives broadcasts from workers.
+     *
+     * @returns `{ sessionId }` so the caller can register the session for
+     *   SSE relaying and later call {@link wrapUp}.
+     * @throws {AuthExpiredError} If session creation or the initial prompt
+     *   fails due to authentication expiry.
+     */
+    async run(params, verbose) {
+        const prompt = this.makePrompt(params);
+        if (verbose) {
+            verbose(`[${this.tag}] prompt ${prompt.length.toLocaleString()} chars`);
+        }
+        const sessionId = await this.createSession(this.sessionTitle);
+        if (verbose) {
+            verbose(`[${this.tag}] session ${sessionId}`);
+        }
+        try {
+            await this.provider.session.promptAsync({
+                path: { id: sessionId },
+                body: {
+                    parts: [{ type: "text", text: prompt }],
+                    agent: this.agentField,
+                },
+            });
+        }
+        catch (err) {
+            if (isAuthExpired(err)) {
+                throw new AuthExpiredError("the configured provider", err);
+            }
+            throw err;
+        }
+        if (verbose) {
+            verbose(`[${this.tag}] initial prompt sent (listening for broadcasts)`);
+        }
+        return { sessionId };
+    }
+    /**
+     * Send the wrap-up prompt after all workers have completed.
+     *
+     * Asks the arbiter to issue any remaining DECISION messages and emit
+     * its final `{ "status": "complete" }` response.
+     *
+     * Intentionally **non-fatal** — workers have already made their edits;
+     * a wrap-up failure does not block the pipeline.
+     */
+    async wrapUp(sessionId, verbose) {
+        if (verbose) {
+            verbose(`[${this.tag}] all workers done, sending wrap-up prompt`);
+        }
+        try {
+            const wrapUpResponse = await this.provider.prompt(sessionId, "All workers have completed their tasks. If you have any remaining " +
+                "DECISION messages to issue, broadcast them now. Otherwise, output your " +
+                'final `{ "status": "complete" }` response.', { agent: this.agentField });
+            if (verbose) {
+                verbose(`[${this.tag}] wrap-up response (${(wrapUpResponse ?? "").length} chars)`);
+            }
+        }
+        catch (err) {
+            if (verbose) {
+                verbose(`[${this.tag}] ⚠ wrap-up failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+}

package/dist/agents/crossref-agent.d.ts

@@ -95,11 +95,6 @@ export declare class CrossRefAgent extends BaseAgent {
      * 10. Kills the arbiter session.
      */
     runParallel(params: CrossRefPromptParams, verbose?: (msg: string) => void): Promise<void>;
-    /**
-     * Kill a session: abort any running work, then delete the session.
-     * Best-effort — failures are logged but not thrown.
-     */
-    private killSession;
     /**
      * Spawn a recalled worker session to apply specific fixes.
      *

package/dist/agents/crossref-agent.js

@@ -20,6 +20,7 @@ import { BaseAgent } from "./base-agent.js";
 import { computeMaxConcurrency } from "../resources.js";
 import { CrossRefArbiterAgent } from "./crossref-arbiter-agent.js";
 import { BROADCAST_TOOL_NAME } from "./organization-agent.js";
+import { buildRecallPrompt, killSession } from "./parallel-coordinator.js";
 // ── Constants ───────────────────────────────────────────────────────────
 /** File count threshold: use parallel workers above this, single agent below. */
 export const XREF_PARALLEL_THRESHOLD = 8;
@@ -344,7 +345,7 @@ export class CrossRefAgent extends BaseAgent {
                 // and delete the session.
                 completedSessions.add(sessionId);
                 allSessions.delete(sessionId);
-                await this.killSession(sessionId, assignment.label, verbose);
+                await killSession(this.provider, sessionId, assignment.label, "xref-parallel", verbose);
             });
             // 6. Wait for all workers to complete
             const results = await Promise.allSettled(workerPromises);
@@ -367,7 +368,7 @@ export class CrossRefAgent extends BaseAgent {
             // 10. Kill the arbiter session
             completedSessions.add(arbiterSessionId);
             allSessions.delete(arbiterSessionId);
-            await this.killSession(arbiterSessionId, "xref-arbiter", verbose);
+            await killSession(this.provider, arbiterSessionId, "xref-arbiter", "xref-parallel", verbose);
             // 11. Log any worker failures (the pipeline discovers files via disk scan)
             for (let i = 0; i < results.length; i++) {
                 const result = results[i];
@@ -396,29 +397,6 @@ export class CrossRefAgent extends BaseAgent {
             ]);
         }
     }
-    /**
-     * Kill a session: abort any running work, then delete the session.
-     * Best-effort — failures are logged but not thrown.
-     */
-    async killSession(sessionId, label, verbose) {
-        try {
-            await this.provider.session.abort({ path: { id: sessionId } });
-        }
-        catch {
-            // Session may already be idle — abort failing is fine
-        }
-        try {
-            await this.provider.session.delete({ path: { id: sessionId } });
-            if (verbose) {
-                verbose(`[xref-parallel] 🗑 Killed session ${label} (${sessionId.slice(0, 8)}…)`);
-            }
-        }
-        catch (err) {
-            if (verbose) {
-                verbose(`[xref-parallel] ⚠ Failed to delete session ${label}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-    }
     /**
      * Spawn a recalled worker session to apply specific fixes.
      *
@@ -429,29 +407,22 @@ export class CrossRefAgent extends BaseAgent {
      */
     async runRecalledWorker(projectName, destinationPath, assignment, _allDocFiles, _totalWorkers, instructions, verbose) {
         const tag = `recall-${assignment.label}`;
-        const prompt = [
-            `Worker **${assignment.label}** (recalled). Previously added cross-reference`,
-            `links for **${projectName}** and the arbiter found link consistency issues.`,
-            "",
-            "## Destination directory",
-            "",
-            `All documentation files are in: \`${destinationPath}\``,
-            "",
-            "## Your assigned files",
-            "",
-            ...assignment.files.map((f) => `- \`${destinationPath}/${f}\``),
-            "",
-            "## Fix instructions from the arbiter",
-            "",
+        const prompt = buildRecallPrompt({
+            destinationPath,
+            assignmentLabel: assignment.label,
+            assignmentFiles: assignment.files,
             instructions,
-            "",
-            "## Rules",
-            "",
-            "- Use the edit tool to make the requested fixes directly.",
-            "- Only modify files in your assigned list unless the arbiter specifically",
-            "  instructed otherwise.",
-            "- When you have completed all fixes, stop.",
-        ].join("\n");
+            intro: [
+                `Worker **${assignment.label}** (recalled). Previously added cross-reference`,
+                `links for **${projectName}** and the arbiter found link consistency issues.`,
+            ],
+            rules: [
+                "- Use the edit tool to make the requested fixes directly.",
+                "- Only modify files in your assigned list unless the arbiter specifically",
+                "  instructed otherwise.",
+                "- When you have completed all fixes, stop.",
+            ],
+        });
         if (verbose) {
             verbose(`[${tag}] Recall prompt: ${prompt.length.toLocaleString()} chars`);
         }
@@ -467,7 +438,7 @@ export class CrossRefAgent extends BaseAgent {
         }
         finally {
             // Always kill the recall session
-            await this.killSession(sessionId, tag, verbose);
+            await killSession(this.provider, sessionId, tag, "xref-parallel", verbose);
         }
     }
     /**

package/dist/agents/crossref-arbiter-agent.d.ts

@@ -12,53 +12,24 @@
  *   2. `wrapUp()` — called after all workers complete.  Sends a final
  *                    prompt so the arbiter can issue any remaining
  *                    DECISION messages.  Non-fatal on failure.
+ *
+ * Lifecycle methods are inherited from {@link BaseArbiter}; this class
+ * supplies only the configuration values and the prompt body.
  */
-import type { Provider } from "../providers/types.js";
-import { BaseAgent } from "./base-agent.js";
-import type { WorkerAssignment } from "./organization-agent.js";
+import { BaseArbiter, type BaseArbiterPromptParams } from "./base-arbiter.js";
 /** Parameters for the cross-ref arbiter prompt. */
-export interface CrossRefArbiterPromptParams {
-    /** Project name. */
-    projectName: string;
-    /** Absolute path to the destination directory. */
-    destinationPath: string;
-    /** ALL documentation files (for full awareness). */
-    allDocFiles: string[];
-    /** Worker assignments mapping each worker label to its owned files. */
-    workerAssignments: WorkerAssignment[];
-}
+export type CrossRefArbiterPromptParams = BaseArbiterPromptParams;
 /**
  * A coordinator agent that monitors cross-ref worker broadcasts and issues
  * DECISION directives to resolve cross-worker link consistency issues.
  *
  * Does NOT edit files — directs workers to make all changes.
  */
-export declare class CrossRefArbiterAgent extends BaseAgent {
-    constructor(provider: Provider);
-    /**
-     * Create the arbiter session and send the initial prompt.
-     *
-     * The initial prompt is sent via `promptAsync` (fire-and-forget) because
-     * the arbiter sits idle until it receives broadcasts from workers.
-     *
-     * @returns The session ID so the caller can register it in the SSE
-     *          relay map and later call `wrapUp()`.
-     * @throws {AuthExpiredError} If session creation or the initial prompt
-     *         fails due to authentication expiry.
-     */
-    run(params: CrossRefArbiterPromptParams, verbose?: (msg: string) => void): Promise<{
-        sessionId: string;
-    }>;
-    /**
-     * Send the wrap-up prompt after all workers have completed.
-     *
-     * Asks the arbiter to issue any remaining DECISION messages and then
-     * output its final `{ "status": "complete" }` response.
-     *
-     * This is intentionally **non-fatal** — if the arbiter fails, workers
-     * have already made their edits and the pipeline can continue.
-     */
-    wrapUp(sessionId: string, verbose?: (msg: string) => void): Promise<void>;
+export declare class CrossRefArbiterAgent extends BaseArbiter<CrossRefArbiterPromptParams> {
+    protected readonly tag = "xref-arbiter";
+    protected readonly sessionTitle = "Hem: xref-arbiter";
+    protected readonly agentField = "hem-xref";
+    protected makePrompt(params: CrossRefArbiterPromptParams): string;
     /**
      * Builds the cross-ref arbiter prompt.
      *