@gajae-code/coding-agent 0.13.2 → 0.14.0

package/src/sdk/elevation/allowlist.ts

@@ -1,54 +0,0 @@
-import { findOperation } from "../protocol/operation-registry";
-
-/**
- * Exact elevation-gated allowlist, fully qualified and enumerative.
- *
- * The elevation allowlist is the exact set of registry operations below (the
- * raw destructive lifecycle and workflow-approval operations). It is declared
- * ONCE here as a `Set<string>` of `"kind:sdkId"` keys and mechanically pinned
- * against `operation-registry.ts` by the allowlist unit test: every key must
- * resolve via `findOperation(kind, sdkId)` and no elevatable operation may be
- * silently missing. Any operation NOT in this set is rejected at issue with
- * `elevation_not_allowlisted` before any ledger reservation. There is no
- * generalized policy engine: this is the deterministic predicate.
- */
-export const ELEVATION_ALLOWLIST_KEYS = [
-	"global:session.close",
-	"global:session.delete",
-	"control:session.delete",
-	"control:session.close",
-	"control:context.clear",
-	"control:session.cwd.move",
-	"control:compaction.run",
-	"control:bash.execute",
-	"control:bash.background",
-	"control:queue.message.remove",
-	"control:queue.message.update",
-	"control:retry.abort",
-	"control:retry.now",
-	"control:bash.abort",
-	"control:retry.auto.set",
-	"control:compaction.auto.set",
-	"control:extension.set_enabled",
-	"control:queue.interrupt_mode.set",
-	"control:queue.follow_up_mode.set",
-	"control:queue.steering_mode.set",
-	"control:tools.active.set",
-	"control:permission_mode.set",
-	"control:service_tier.set",
-	"control:workflow.gate_answer",
-	"control:workflow.plan_approve",
-] as const;
-const elevationAllowlistKeySet = new Set<string>(ELEVATION_ALLOWLIST_KEYS);
-
-/**
- * Whether `(kind, sdkId)` is the fully qualified identity of an allowlisted
- * elevation-gated operation. The pair is validated against the operation
- * registry before any elevation is admitted, so a key can never name an
- * operation that does not exist.
- */
-export function isElevationAllowlisted(kind: unknown, sdkId: unknown): boolean {
-	if (typeof kind !== "string" || typeof sdkId !== "string") return false;
-	if (!elevationAllowlistKeySet.has(`${kind}:${sdkId}`)) return false;
-	return findOperation(kind as "control" | "global" | "query" | "reverse", sdkId) !== undefined;
-}

package/src/sdk/elevation/audit.ts

@@ -1,208 +0,0 @@
-import * as fsSync from "node:fs";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { assertSupportedStateVersion, SDK_STATE_VERSION } from "../broker/state-version";
-import { classifyProcessIncarnationLiveness } from "./owner";
-
-/**
- * Durable elevation audit trail.
- *
- * Append-only JSONL under the same elevation-local lock as the grant ledger,
- * mode 0600. Every state transition of a grant — issue, operator answer,
- * expiry, misuse, duplicate answer, claim, and dispatch outcome — is
- * recorded with the exact identity evidence the transition consumed, so an
- * auditor can reproduce why a grant reached its terminal state without
- * trusting in-memory state.
- *
- * The audit stream is an evidence trail, never an authority: audit rows are
- * append-only, are never re-read to drive decisions, and a corrupted row is
- * quarantined (like ledger rows) instead of failing the ledger.
- */
-export type ElevationAuditEvent =
-	| { kind: "issued" }
-	| {
-			kind: "answered";
-			outcome: "granted" | "denied" | "expired" | "misused" | "target_unavailable" | "duplicate_answer";
-	  }
-	| { kind: "expired" }
-	| { kind: "misused" }
-	| { kind: "duplicate_answer" }
-	| { kind: "claimed"; claim: { ownerId: string; epoch: number; pid: number; incarnation: string } }
-	| {
-			kind: "dispatched";
-			dispatch: { ownerId: string; epoch: number; dispatchedAt: number };
-			outcome: { status: "ok" | "failed"; code?: string; message?: string; dispatchedAt: number };
-	  }
-	| { kind: "consumed"; message: string }
-	| { kind: "unavailable"; reason: string };
-
-export interface ElevationAuditEntry {
-	version: typeof SDK_STATE_VERSION;
-	ts: number;
-	elevationRequestId: string;
-	issueIndex: number;
-	event: ElevationAuditEvent;
-}
-
-export type ElevationAuditEventName = ElevationAuditEvent["kind"];
-
-export function isElevationAuditEntry(value: unknown): value is ElevationAuditEntry {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const entry = value as {
-		version?: unknown;
-		ts?: unknown;
-		elevationRequestId?: unknown;
-		issueIndex?: unknown;
-		event?: unknown;
-	};
-	if (
-		entry.version !== SDK_STATE_VERSION ||
-		!Number.isSafeInteger(entry.ts) ||
-		(entry.ts as number) <= 0 ||
-		typeof entry.elevationRequestId !== "string" ||
-		entry.elevationRequestId.length === 0 ||
-		!Number.isSafeInteger(entry.issueIndex) ||
-		(entry.issueIndex as number) <= 0 ||
-		typeof entry.event !== "object" ||
-		entry.event === null ||
-		Array.isArray(entry.event)
-	)
-		return false;
-	const event = entry.event as { kind?: unknown };
-	return typeof event.kind === "string" && event.kind.length > 0;
-}
-
-const AUDIT_FILE_NAME = "audit.jsonl";
-const MAX_AUDIT_FILE_BYTES = 64 * 1024 * 1024;
-const MAX_AUDIT_LINE_BYTES = 8 * 1024 * 1024;
-
-export interface ElevationAuditOptions {
-	/** Injectable clock. */
-	now?: () => number;
-	/**
-	 * Injectable tri-state process-incarnation liveness classifier, defaulting
-	 * to `classifyProcessIncarnationLiveness`. The audit trail records the
-	 * liveness verdict behind `consumed`/`unavailable` settlements so the
-	 * crash-truth settlement is reproducible; the verdict never drives the
-	 * settlement itself (that lives in the ledger).
-	 */
-	classifyLiveness?: typeof classifyProcessIncarnationLiveness;
-}
-
-export class ElevationAudit {
-	readonly #dir: string;
-	readonly #file: string;
-	#now: () => number;
-	#classifyLiveness: typeof classifyProcessIncarnationLiveness;
-	#warnings: string[] = [];
-
-	constructor(agentDir: string, options: ElevationAuditOptions = {}) {
-		this.#dir = path.join(agentDir, "sdk", "elevation");
-		this.#file = path.join(this.#dir, AUDIT_FILE_NAME);
-		this.#now = options.now ?? Date.now;
-		this.#classifyLiveness = options.classifyLiveness ?? classifyProcessIncarnationLiveness;
-	}
-
-	get warnings(): readonly string[] {
-		return this.#warnings;
-	}
-
-	/**
-	 * Appends one audit row for an elevation grant transition. Callers MUST
-	 * hold the same elevation-local lock that guards the grant ledger; the
-	 * audit row and the grant row therefore commit together.
-	 */
-	async append(entry: Omit<ElevationAuditEntry, "version">): Promise<void> {
-		const record: ElevationAuditEntry = { version: SDK_STATE_VERSION, ...entry };
-		const line = Buffer.from(`${JSON.stringify(record)}\n`);
-		if (line.length - 1 > MAX_AUDIT_LINE_BYTES)
-			throw new Error("Elevation audit row exceeds the maximum byte length");
-		const handle = await fs.open(
-			this.#file,
-			fsSync.constants.O_WRONLY | fsSync.constants.O_APPEND | fsSync.constants.O_CREAT | fsSync.constants.O_NOFOLLOW,
-			0o600,
-		);
-		try {
-			if (!(await handle.stat()).isFile()) throw new Error("Elevation audit target is not a regular file.");
-			await handle.writeFile(line);
-			await handle.sync();
-		} finally {
-			await handle.close();
-		}
-	}
-
-	/**
-	 * Opens the audit stream: creates the 0600 directory/file if absent and
-	 * quarantines any corrupt tail so subsequent appends are always readable.
-	 * Called under the same lock as `ElevationLedger.open()`.
-	 */
-	async open(): Promise<this> {
-		await fs.mkdir(this.#dir, { recursive: true, mode: 0o700 });
-		let source: Buffer | undefined;
-		let handle: fs.FileHandle | undefined;
-		try {
-			handle = await fs.open(this.#file, fsSync.constants.O_RDONLY | fsSync.constants.O_NOFOLLOW);
-			const stat = await handle.stat({ bigint: true });
-			if (!stat.isFile()) throw new Error(`Elevation audit target is not a regular file: ${this.#file}`);
-			if (stat.size > BigInt(MAX_AUDIT_FILE_BYTES))
-				throw new Error(`Elevation audit file exceeds the maximum byte length: ${this.#file}`);
-			const bytes = Buffer.alloc(Number(stat.size) + 1);
-			const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
-			source = bytes.subarray(0, bytesRead);
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-		} finally {
-			if (handle) await handle.close();
-		}
-		if (!source) return this;
-		const tornTail = source.length > 0 && source.at(-1) !== 0x0a;
-		let lineStart = 0;
-		for (let offset = 0; offset <= source.length; offset += 1) {
-			if (offset !== source.length && source[offset] !== 0x0a) continue;
-			const line = source.subarray(lineStart, offset);
-			lineStart = offset + 1;
-			if (line.length === 0) continue;
-			if (line.length > MAX_AUDIT_LINE_BYTES) throw new Error("Elevation audit row exceeds the maximum byte length");
-			try {
-				const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(line));
-				assertSupportedStateVersion(this.#file, value);
-				if (!isElevationAuditEntry(value)) throw new Error("invalid elevation audit entry");
-			} catch (error) {
-				if (error instanceof Error && "code" in error && error.code === "unsupported_state_version") throw error;
-				const quarantine = await fs.open(
-					`${this.#file}.corrupt`,
-					fsSync.constants.O_WRONLY |
-						fsSync.constants.O_APPEND |
-						fsSync.constants.O_CREAT |
-						fsSync.constants.O_NOFOLLOW,
-					0o600,
-				);
-				try {
-					await quarantine.writeFile(line);
-					await quarantine.writeFile("\n");
-					await quarantine.sync();
-				} finally {
-					await quarantine.close();
-				}
-				this.#warnings.push("Malformed elevation audit entry quarantined");
-			}
-		}
-		if (tornTail) {
-			const seal = await fs.open(
-				this.#file,
-				fsSync.constants.O_WRONLY |
-					fsSync.constants.O_APPEND |
-					fsSync.constants.O_CREAT |
-					fsSync.constants.O_NOFOLLOW,
-				0o600,
-			);
-			try {
-				await seal.writeFile("\n");
-				await seal.sync();
-			} finally {
-				await seal.close();
-			}
-		}
-		return this;
-	}
-}

package/src/sdk/elevation/capability.ts

@@ -1,41 +0,0 @@
-import { createHmac, timingSafeEqual } from "node:crypto";
-import * as path from "node:path";
-import { canonicalElevationJson } from "./digest";
-
-const CAPABILITY_PATTERN = /^([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\.([0-9a-f]{64})$/;
-
-function payload(requestId: string, sdkId: string, input: Record<string, unknown>): string {
-	return canonicalElevationJson({ requestId, kind: "control", sdkId, input });
-}
-
-export function signElevationCapability(
-	authorityToken: string,
-	requestId: string,
-	sdkId: string,
-	input: Record<string, unknown>,
-): string {
-	const signature = createHmac("sha256", authorityToken)
-		.update(payload(requestId, sdkId, input))
-		.digest("hex");
-	return `${requestId}.${signature}`;
-}
-
-export function verifyElevationCapability(
-	authorityToken: string,
-	capability: string,
-	sdkId: string,
-	input: Record<string, unknown>,
-): boolean {
-	const match = CAPABILITY_PATTERN.exec(capability);
-	if (!match) return false;
-	const requestId = match[1]!;
-	const supplied = Buffer.from(match[2]!, "hex");
-	const expected = createHmac("sha256", authorityToken)
-		.update(payload(requestId, sdkId, input))
-		.digest();
-	return supplied.length === expected.length && timingSafeEqual(supplied, expected);
-}
-
-export function elevationAuthorityPath(stateRoot: string, sessionId: string): string {
-	return path.join(stateRoot, "sdk", ".authority", `${sessionId}.json`);
-}

package/src/sdk/elevation/digest.ts

@@ -1,129 +0,0 @@
-import { createHash } from "node:crypto";
-import { ELEVATION_ALLOWLIST_KEYS, isElevationAllowlisted } from "./allowlist";
-
-/**
- * Fully qualified elevation request digest.
- *
- * An elevation grant binds the exact operation the operator approved. The
- * digest covers the complete `{kind, sdkId, input}` triple so substituting a
- * different operation or different input bytes changes the digest and the
- * gate presentation fails closed (`misused`). The top-level
- * `elevationRequestId` correlation field is deliberately excluded: it is the
- * durable correlation ID assigned to a request, not part of the approved
- * content, and the same content re-issued under a new ID must produce the
- * same digest.
- *
- * Only allowlisted operations can be elevated; anything else is refused so a
- * caller cannot mint a grant for an operation outside the elevation policy.
- */
-export const ELEVATION_OPERATION_KINDS = ["control", "query", "global"] as const;
-export type ElevationOperationKind = (typeof ELEVATION_OPERATION_KINDS)[number];
-
-export interface ElevationOperation {
-	kind: ElevationOperationKind;
-	sdkId: string;
-}
-
-/**
- * Operations that require an elevation grant. Default SDK scope
- * (list/query/send/tail) stays grant-free; destructive lifecycle operations
- * and workflow approval operations are elevatable and therefore gated.
- */
-export const ELEVATION_ALLOWLIST: readonly { kind: ElevationOperationKind; sdkId: string }[] =
-	ELEVATION_OPERATION_KINDS.flatMap(kind =>
-		[...ELEVATION_ALLOWLIST_KEYS]
-			.filter(key => key.startsWith(`${kind}:`))
-			.map(key => ({ kind, sdkId: key.slice(kind.length + 1) })),
-	);
-
-export function isElevatableOperation(kind: unknown, sdkId: unknown): boolean {
-	return isElevationAllowlisted(kind, sdkId);
-}
-
-/**
- * Whether the `(kind, sdkId)` pair names a registry operation that the
- * elevation allowlist recognizes. Used by the ledger row validator so a
- * persisted row can never bind an operation outside the allowlist.
- */
-export function isKnownElevationOperation(kind: unknown, sdkId: unknown): boolean {
-	return isElevationAllowlisted(kind, sdkId);
-}
-
-/**
- * Canonical JSON encoding for elevation digest leaves.
- *
- * Intentionally byte-compatible with the broker's identity canonicalization
- * (`canonicalJson` in `sdk/broker/broker.ts`): object keys sorted, compact
- * separators, `undefined` fields preserved verbatim, arrays joined without
- * separators. The broker computes the request digest at issue time and the
- * ledger recomputes/compares the same encoding, so digest verification is
- * stable across issue, gate presentation, and answer.
- */
-export function canonicalElevationJson(value: unknown): string {
-	if (value === null || typeof value !== "object") return JSON.stringify(value);
-	if (Array.isArray(value)) return `[${value.map(canonicalElevationJson).join(",")}]`;
-	const record = value as Record<string, unknown>;
-	return `{${Object.keys(record)
-		.sort()
-		.map(key => `${JSON.stringify(key)}:${canonicalElevationJson(record[key])}`)
-		.join(",")}}`;
-}
-
-export type ElevationDigestResult =
-	| { ok: true; digest: string }
-	| { ok: false; error: { code: string; message: string } };
-
-const MAX_SDK_ID_LENGTH = 128;
-const MAX_INPUT_JSON_DEPTH = 64;
-const MAX_INPUT_JSON_FIELDS = 1024;
-
-function isBoundedInputJson(value: unknown, depth = 0, budget = { fields: 0 }): boolean {
-	if (depth > MAX_INPUT_JSON_DEPTH) return false;
-	if (value === null || typeof value !== "object") return true;
-	if (Array.isArray(value)) {
-		if (value.length > MAX_INPUT_JSON_FIELDS) return false;
-		return value.every(item => isBoundedInputJson(item, depth + 1, budget));
-	}
-	const record = value as Record<string, unknown>;
-	const keys = Object.keys(record);
-	budget.fields += keys.length;
-	return (
-		budget.fields <= MAX_INPUT_JSON_FIELDS && keys.every(key => isBoundedInputJson(record[key], depth + 1, budget))
-	);
-}
-
-/**
- * Computes the fully qualified digest for an elevation request.
- *
- * `input` is digested exactly as supplied except that a top-level
- * `elevationRequestId` field is removed first (it is the correlation ID, not
- * approved content). Operations outside `ELEVATION_ALLOWLIST` are refused
- * with `elevation_not_required` so the broker never mints a grant for an
- * operation that does not need one.
- */
-export function elevationRequestDigest(request: {
-	kind: unknown;
-	sdkId: unknown;
-	input: unknown;
-}): ElevationDigestResult {
-	const kind = request.kind;
-	if (!ELEVATION_OPERATION_KINDS.includes(kind as ElevationOperationKind))
-		return { ok: false, error: { code: "invalid_input", message: "kind must be control, query, or global" } };
-	if (typeof request.sdkId !== "string" || request.sdkId.length === 0 || request.sdkId.length > MAX_SDK_ID_LENGTH)
-		return { ok: false, error: { code: "invalid_input", message: "sdkId must be a non-empty bounded string" } };
-	if (!isElevatableOperation(kind, request.sdkId))
-		return {
-			ok: false,
-			error: { code: "elevation_not_required", message: `${request.sdkId} does not require elevation` },
-		};
-	if (typeof request.input !== "object" || request.input === null || Array.isArray(request.input))
-		return { ok: false, error: { code: "invalid_input", message: "input must be a JSON object" } };
-	if (!isBoundedInputJson(request.input))
-		return { ok: false, error: { code: "invalid_input", message: "input exceeds the bounded JSON limits" } };
-	const input = { ...(request.input as Record<string, unknown>) };
-	delete input.elevationRequestId;
-	const digest = createHash("sha256")
-		.update(canonicalElevationJson({ kind: kind as ElevationOperationKind, sdkId: request.sdkId, input }))
-		.digest("hex");
-	return { ok: true, digest };
-}

package/src/sdk/elevation/dispatch-receipt.ts

@@ -1,184 +0,0 @@
-import { isProcessIncarnation } from "../broker/process-incarnation";
-
-export const ELEVATION_RECEIPT_VERSION = 1;
-
-/**
- * Identity of the broker tenure that claims a grant and dispatches it.
- *
- * `ownerId` is the broker instance owner id and `epoch` increments per broker
- * start, so a restart (even of the same object) yields a new tenure. `pid` and
- * `incarnation` are retained for truthful tri-state liveness replay.
- */
-export interface ElevationClaimIdentity {
-	ownerId: string;
-	epoch: number;
-	pid: number;
-	incarnation: string;
-}
-
-export type ElevationReceiptState = "claimed" | "dispatched" | "uncertain";
-
-/**
- * Durable dispatch outcome. `unknown` is the crash truth: the grant was
- * consumed by a claim but the dispatch outcome is not knowable, so retry
- * requires a new grant.
- */
-export type ElevationDispatchOutcome =
-	| { status: "ok"; dispatchedAt: number }
-	| { status: "failed"; code: string; message: string; dispatchedAt: number }
-	| { status: "unknown"; message: string; dispatchedAt: number };
-
-/**
- * Owner/epoch-bound dispatch receipt.
- *
- * State machine: `claimed` (grant spent, dispatch in flight, bound to the
- * claiming broker tenure) -> `dispatched` (terminal, outcome recorded) or
- * `uncertain` (terminal truth: the claim's outcome is unknowable after its
- * broker tenure died). Replay never fabricates an outcome: a receipt left in
- * `claimed` by a dead tenure is truthfully terminalized to `uncertain`.
- */
-export interface ElevationDispatchReceipt {
-	version: typeof ELEVATION_RECEIPT_VERSION;
-	elevationRequestId: string;
-	issueIndex: number;
-	state: ElevationReceiptState;
-	claim: ElevationClaimIdentity & { claimedAt: number };
-	dispatch?: { ownerId: string; epoch: number; dispatchedAt: number };
-	outcome?: ElevationDispatchOutcome;
-	ts: number;
-}
-
-const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-
-export function isElevationRequestId(value: unknown): value is string {
-	return typeof value === "string" && UUID_V4.test(value);
-}
-
-export function isElevationClaimIdentity(value: unknown): value is ElevationClaimIdentity {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const identity = value as { ownerId?: unknown; epoch?: unknown; pid?: unknown; incarnation?: unknown };
-	return (
-		typeof identity.ownerId === "string" &&
-		identity.ownerId.length > 0 &&
-		Number.isSafeInteger(identity.epoch) &&
-		(identity.epoch as number) > 0 &&
-		Number.isSafeInteger(identity.pid) &&
-		(identity.pid as number) > 0 &&
-		isProcessIncarnation(identity.incarnation)
-	);
-}
-
-export function isElevationDispatchOutcome(value: unknown): value is ElevationDispatchOutcome {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const outcome = value as { status?: unknown; code?: unknown; message?: unknown; dispatchedAt?: unknown };
-	if (!Number.isSafeInteger(outcome.dispatchedAt) || (outcome.dispatchedAt as number) <= 0) return false;
-	if (outcome.status === "ok") return true;
-	if (outcome.status === "unknown") return typeof outcome.message === "string";
-	if (outcome.status === "failed")
-		return typeof outcome.code === "string" && outcome.code.length > 0 && typeof outcome.message === "string";
-	return false;
-}
-
-export function isElevationDispatchReceipt(value: unknown): value is ElevationDispatchReceipt {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const receipt = value as Partial<ElevationDispatchReceipt>;
-	if (
-		receipt.version !== ELEVATION_RECEIPT_VERSION ||
-		!isElevationRequestId(receipt.elevationRequestId) ||
-		!Number.isSafeInteger(receipt.issueIndex) ||
-		(receipt.issueIndex as number) <= 0 ||
-		(receipt.state !== "claimed" && receipt.state !== "dispatched" && receipt.state !== "uncertain") ||
-		!isElevationClaimIdentity(receipt.claim) ||
-		!Number.isSafeInteger(receipt.claim.claimedAt) ||
-		(receipt.claim.claimedAt as number) <= 0 ||
-		!Number.isSafeInteger(receipt.ts) ||
-		(receipt.ts as number) <= 0
-	)
-		return false;
-	if (receipt.state === "claimed") return receipt.dispatch === undefined && receipt.outcome === undefined;
-	if (receipt.state === "uncertain") {
-		const outcome = receipt.outcome;
-		return receipt.dispatch === undefined && isElevationDispatchOutcome(outcome) && outcome.status === "unknown";
-	}
-	const dispatch = receipt.dispatch;
-	if (dispatch === undefined) return false;
-	return (
-		typeof dispatch.ownerId === "string" &&
-		dispatch.ownerId.length > 0 &&
-		Number.isSafeInteger(dispatch.epoch) &&
-		dispatch.epoch > 0 &&
-		Number.isSafeInteger(dispatch.dispatchedAt) &&
-		dispatch.dispatchedAt > 0 &&
-		isElevationDispatchOutcome(receipt.outcome) &&
-		receipt.outcome.status !== "unknown"
-	);
-}
-
-export function claimReceipt(
-	requestId: string,
-	issueIndex: number,
-	claim: ElevationClaimIdentity,
-	claimedAt: number,
-): ElevationDispatchReceipt {
-	return {
-		version: ELEVATION_RECEIPT_VERSION,
-		elevationRequestId: requestId,
-		issueIndex,
-		state: "claimed",
-		claim: { ...claim, claimedAt },
-		ts: claimedAt,
-	};
-}
-
-export function dispatchReceipt(
-	receipt: ElevationDispatchReceipt,
-	dispatch: { ownerId: string; epoch: number; dispatchedAt: number },
-	outcome: ElevationDispatchOutcome,
-): ElevationDispatchReceipt {
-	return {
-		...receipt,
-		state: "dispatched",
-		dispatch,
-		outcome,
-		ts: dispatch.dispatchedAt,
-	};
-}
-
-export function uncertainReceipt(receipt: ElevationDispatchReceipt, at: number): ElevationDispatchReceipt {
-	return {
-		...receipt,
-		state: "uncertain",
-		outcome: {
-			status: "unknown",
-			message: "Claiming broker tenure ended before dispatch outcome was recorded",
-			dispatchedAt: at,
-		},
-		ts: at,
-	};
-}
-
-export function receiptClaimMatches(receipt: ElevationDispatchReceipt, identity: ElevationClaimIdentity): boolean {
-	return receipt.claim.ownerId === identity.ownerId && receipt.claim.epoch === identity.epoch;
-}
-
-/**
- * Who may answer an elevation gate.
- *
- * Internal operator-only: the answer boundary is the broker's internal
- * operator attestation (`local_operator`), reached only through broker-owned
- * surfaces. There is no public `elevation.answer` operation and no
- * requester-correlation check: the answerer is structurally an operator
- * attestation, so requester self-approval is impossible by construction.
- */
-export type ElevationAnswerAuthority = { source: "local_operator"; attestedBy: string };
-
-/** Structural guard for the internal operator attestation. */
-export function isElevationAnswerAuthority(value: unknown): value is ElevationAnswerAuthority {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const authority = value as { source?: unknown; attestedBy?: unknown };
-	return (
-		authority.source === "local_operator" &&
-		typeof authority.attestedBy === "string" &&
-		authority.attestedBy.length > 0
-	);
-}