@iowarp/clio-coder 0.3.9 → 0.4.1

package/src/tools/panes-surface.ts

@@ -0,0 +1,38 @@
+import { Type } from "typebox";
+import { ToolNames } from "../core/tool-names.js";
+import { PANES_PRESET_IDS } from "../domains/mux/operations.js";
+import { StringEnum } from "../engine/ai.js";
+import type { ToolSurface } from "./lazy-tool.js";
+
+/**
+ * The model's door to the pane layer.
+ *
+ * There is no argv field, and there never will be. Arbitrary argv is
+ * operator-only through `/panes open`, which is what keeps this tool out of
+ * shell-escape territory (spec 4.8, risk register "tool misuse"). `preset` is a
+ * closed enum, so an argv string cannot arrive spelled as a preset name either.
+ */
+export const panesToolSurface = {
+	name: ToolNames.Panes,
+	description:
+		"Look at, focus, and manage the terminal panes Clio owns beside this session. Use show to bring a dispatched run's live viewer pane to the front when the operator asks to see an agent (\"show me the tester\"). open starts one of the fixed utility presets; there is no way to run an arbitrary command. close removes a pane Clio created. list reports the current inventory and the pane layer's health.",
+	parameters: Type.Object({
+		action: StringEnum(["show", "open", "close", "list"], {
+			description:
+				"show focuses a run's viewer pane; open starts a preset utility pane; close removes a Clio-owned pane; list reports the inventory.",
+		}),
+		target: Type.Optional(
+			Type.String({
+				description:
+					'action=show: an agent id or run id prefix, most recent match wins. action=close: a pane id, a pane label, an agent id, or "all".',
+			}),
+		),
+		preset: Type.Optional(
+			StringEnum([...PANES_PRESET_IDS], {
+				description: "action=open: which fixed utility pane to start.",
+			}),
+		),
+	}),
+	baseActionClass: "read",
+	executionMode: "sequential",
+} satisfies ToolSurface;

package/src/tools/panes.ts

@@ -0,0 +1,112 @@
+import type { PanesOperations } from "../domains/mux/operations.js";
+import { PANES_PRESET_IDS } from "../domains/mux/operations.js";
+import { panesToolSurface } from "./panes-surface.js";
+import type { ToolResult, ToolSpec } from "./registry.js";
+
+/**
+ * The `panes` tool: the model's read-class door to the pane layer.
+ *
+ * It is registered only when the mux answered detection, so its presence in the
+ * prompt is itself the statement that panes exist in this session. Every action
+ * routes through the same `PanesOperations` the `/panes` slash command drives,
+ * so the two surfaces cannot describe the same pane differently.
+ *
+ * The one asymmetry with the operator's surface is deliberate: `open` accepts a
+ * preset and nothing else. A caller that fabricates an `argv` field gets a
+ * refusal rather than a shell.
+ */
+
+export interface PanesToolDeps {
+	panes: PanesOperations;
+}
+
+function describeInventory(deps: PanesToolDeps): ToolResult {
+	const status = deps.panes.status();
+	const header = `panes mode=${status.mode} ${status.available ? "available" : "unavailable"}; notifications=${status.settings.notifications}`;
+	const rows = status.panes.map((pane) => `- ${pane.paneId} ${pane.purpose} ${pane.label}`);
+	return {
+		kind: "ok",
+		output: [header, ...(rows.length > 0 ? rows : ["- no Clio-owned panes"])].join("\n"),
+		details: { action: "list", mode: status.mode, available: status.available, panes: status.panes },
+	};
+}
+
+export function createPanesTool(deps: PanesToolDeps): ToolSpec {
+	return {
+		...panesToolSurface,
+		async run(args): Promise<ToolResult> {
+			const action = typeof args.action === "string" ? args.action : "";
+			// An argv field never reaches the operations layer. Refusing loudly is
+			// better than ignoring it, because a model that believed it opened a
+			// command pane would report work it did not do.
+			if ("argv" in args) {
+				return {
+					kind: "error",
+					message:
+						"panes: argv panes are operator-only; use action=open with a preset, or ask the operator to run /panes open <command>",
+				};
+			}
+			const target = typeof args.target === "string" ? args.target.trim() : "";
+			if (action === "list") return describeInventory(deps);
+			if (action === "show") {
+				if (target.length === 0) return { kind: "error", message: "panes: action=show requires target" };
+				const result = await deps.panes.show(target);
+				if (result.status === "watching") {
+					return {
+						kind: "ok",
+						output: `the watch pane is now rendering ${result.agentId} (run ${result.runId}).`,
+						details: { action: "show", runId: result.runId, agentId: result.agentId },
+					};
+				}
+				if (result.status === "not-found") {
+					const known = result.candidates.length > 0 ? ` Live runs: ${result.candidates.join(", ")}.` : "";
+					return { kind: "error", message: `panes: no live run matches '${result.target}'.${known}` };
+				}
+				return { kind: "error", message: `panes: ${result.reason}` };
+			}
+			if (action === "open") {
+				const preset = typeof args.preset === "string" ? args.preset : "";
+				if (!(PANES_PRESET_IDS as ReadonlyArray<string>).includes(preset)) {
+					return {
+						kind: "error",
+						message: `panes: action=open requires preset, one of ${PANES_PRESET_IDS.join(", ")}`,
+					};
+				}
+				const result = await deps.panes.open({ preset });
+				if (result.status === "opened") {
+					return {
+						kind: "ok",
+						output:
+							result.paneId === null
+								? `completed the ${result.label} chooser.`
+								: `opened the ${result.label} pane (${result.paneId}).`,
+						details: { action: "open", preset, paneId: result.paneId },
+					};
+				}
+				if (result.status === "missing-binary") {
+					return {
+						kind: "error",
+						message: `panes: ${result.detail}`,
+					};
+				}
+				return { kind: "error", message: `panes: ${result.reason}` };
+			}
+			if (action === "close") {
+				if (target.length === 0) return { kind: "error", message: "panes: action=close requires target" };
+				const result = await deps.panes.close(target);
+				if (result.status === "closed") {
+					return {
+						kind: "ok",
+						output: `closed ${result.closed} pane(s)${result.labels.length > 0 ? `: ${result.labels.join(", ")}` : ""}.`,
+						details: { action: "close", closed: result.closed },
+					};
+				}
+				if (result.status === "not-found") {
+					return { kind: "error", message: `panes: no Clio-owned pane matches '${result.target}'` };
+				}
+				return { kind: "error", message: `panes: ${result.reason}` };
+			}
+			return { kind: "error", message: `panes: action must be show, open, close, or list; got '${action}'` };
+		},
+	};
+}

package/src/tools/policy.ts

@@ -49,6 +49,10 @@ export const TOOL_PLANES: Readonly<Record<BuiltinToolName, PlaneExpectation>> =
 	// review the board depends on. Sequential so two posts in one batch do not
 	// interleave against the local post cap.
 	[ToolNames.Ledger]: { plane: "orchestrate", actionClass: "read", executionMode: "sequential" },
+	// panes projects Clio's own runs onto a pane host and opens preset utility
+	// panes. It mutates no workspace, so it stays read class; sequential because
+	// two pane operations in one batch would race the same pane registry.
+	[ToolNames.Panes]: { plane: "orchestrate", actionClass: "read", executionMode: "sequential" },
 	[ToolNames.WebFetch]: { plane: "retrieve", actionClass: "read", executionMode: "parallel" },
 	[ToolNames.AskUser]: { plane: "interact", actionClass: "read", executionMode: "sequential" },
 	[ToolNames.Artifact]: { plane: "artifact", actionClass: "write", executionMode: "sequential" },
@@ -75,6 +79,8 @@ const OBSERVE_ENVELOPE_SELF_CAPS: ReadonlyArray<[BuiltinToolName, () => number]>
 const SESSION_BOUND_TOOLS = new Set<ToolName>([]);
 const DISPATCH_BOUND_TOOLS = new Set<ToolName>([ToolNames.Dispatch, ToolNames.Monitor, ToolNames.Steer]);
 const INTERACTIVE_BOUND_TOOLS = new Set<ToolName>([ToolNames.AskUser]);
+/** Registered only when a pane host answered detection and the mux is live. */
+const PANES_BOUND_TOOLS = new Set<ToolName>([ToolNames.Panes]);
 /** The RETRIEVE plane, omitted wholesale by a hermetic run (tools/network-policy.ts). */
 const NETWORK_BOUND_TOOLS = new Set<ToolName>([ToolNames.WebFetch]);
 
@@ -82,8 +88,9 @@ export interface BuiltinToolPolicyOptions {
 	includeSessionTools?: boolean;
 	includeDispatchTools?: boolean;
 	includeInteractiveTools?: boolean;
+	includePanesTools?: boolean;
 	/**
-	 * Unlike the other three, this defaults to true: every registry registers
+	 * Unlike the other four, this defaults to true: every registry registers
 	 * the network plane unless a run explicitly asked to be hermetic, so an
 	 * unset option must keep demanding it.
 	 */
@@ -132,12 +139,14 @@ function validateBuiltinToolPolicy(specs: ReadonlyArray<ToolSpec>, options: Buil
 	const includeSessionTools = options.includeSessionTools ?? false;
 	const includeDispatchTools = options.includeDispatchTools ?? false;
 	const includeInteractiveTools = options.includeInteractiveTools ?? false;
+	const includePanesTools = options.includePanesTools ?? false;
 	const includeNetworkTools = options.includeNetworkTools ?? true;
 	const required = new Set<ToolName>(Object.values(ToolNames));
 	for (const tool of [...required]) {
 		if (!includeSessionTools && SESSION_BOUND_TOOLS.has(tool)) required.delete(tool);
 		if (!includeDispatchTools && DISPATCH_BOUND_TOOLS.has(tool)) required.delete(tool);
 		if (!includeInteractiveTools && INTERACTIVE_BOUND_TOOLS.has(tool)) required.delete(tool);
+		if (!includePanesTools && PANES_BOUND_TOOLS.has(tool)) required.delete(tool);
 		if (!includeNetworkTools && NETWORK_BOUND_TOOLS.has(tool)) required.delete(tool);
 	}
 	for (const tool of required) {

package/src/tools/presentation.ts

@@ -67,6 +67,7 @@ export const TOOL_PRESENTATION: Readonly<Record<string, ToolPresentationPolicy>>
 	[ToolNames.Steer]: FOLDED,
 	[ToolNames.Tasks]: FOLDED,
 	[ToolNames.Ledger]: FOLDED,
+	[ToolNames.Panes]: FOLDED,
 	[ToolNames.WebFetch]: FOLDED,
 	[ToolNames.AskUser]: FOLDED,
 	[ToolNames.Artifact]: FOLDED,

package/src/tools/task-worktree.ts

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
-import { existsSync, mkdirSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 
 export type TaskWorktreeApply = "merge" | "preserve";
@@ -25,7 +25,9 @@ export interface TaskWorktreeReceipt {
 
 const SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
 const OWNER_FILE_SUFFIX = ".task-owner.json";
-const COMMIT_IDENTITY = "clio-task";
+const TASK_WORKTREE_KIND = "clio-coder-task-worktree";
+const LEGACY_TASK_WORKTREE_KIND = "clio-task-worktree";
+const COMMIT_IDENTITY = "clio-coder-task";
 
 function gitBytes(root: string, args: string[]): Buffer {
 	return execFileSync("git", ["-C", root, ...args], {
@@ -160,7 +162,7 @@ export function createTaskWorktree(root: string, runId: string, base?: string):
 	const resolvedBase = base ?? git(canonical, ["rev-parse", "HEAD"]);
 	const parent = join(canonical, ".clio-coder", "worktrees");
 	const path = join(parent, runId);
-	const branch = `clio/task/${runId}`;
+	const branch = `clio-coder/task/${runId}`;
 	mkdirSync(parent, { recursive: true });
 	if (!isCanonicalWorktreePathInside(parent, path))
 		throw new Error(`task worktree path escapes its parent for run ${runId}`);
@@ -168,7 +170,7 @@ export function createTaskWorktree(root: string, runId: string, base?: string):
 	const ownerToken = randomBytes(16).toString("hex");
 	writeFileSync(
 		`${path}${OWNER_FILE_SUFFIX}`,
-		`${JSON.stringify({ version: 1, kind: "clio-task-worktree", root: canonical, runId, branch, base: resolvedBase, ownerToken }, null, 2)}\n`,
+		`${JSON.stringify({ version: 1, kind: TASK_WORKTREE_KIND, root: canonical, runId, branch, base: resolvedBase, ownerToken }, null, 2)}\n`,
 		{ encoding: "utf8", flag: "wx" },
 	);
 	return { root: canonical, runId, path, branch, base: resolvedBase, ownerToken };
@@ -182,11 +184,30 @@ function assertOwnership(worktree: TaskWorktree): void {
 	) {
 		throw new Error(`task worktree ${worktree.runId} has an invalid ownership path`);
 	}
-	if (!existsSync(`${worktree.path}${OWNER_FILE_SUFFIX}`))
-		throw new Error(`task worktree ${worktree.runId} has no ownership file`);
+	const ownerPath = `${worktree.path}${OWNER_FILE_SUFFIX}`;
+	if (!existsSync(ownerPath)) throw new Error(`task worktree ${worktree.runId} has no ownership file`);
+	let marker: Record<string, unknown>;
+	try {
+		const value = JSON.parse(readFileSync(ownerPath, "utf8")) as unknown;
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("not an object");
+		marker = value as Record<string, unknown>;
+	} catch {
+		throw new Error(`task worktree ${worktree.runId} has an invalid ownership file`);
+	}
+	if (
+		marker.version !== 1 ||
+		(marker.kind !== TASK_WORKTREE_KIND && marker.kind !== LEGACY_TASK_WORKTREE_KIND) ||
+		marker.root !== worktree.root ||
+		marker.runId !== worktree.runId ||
+		marker.branch !== worktree.branch ||
+		marker.base !== worktree.base ||
+		marker.ownerToken !== worktree.ownerToken
+	) {
+		throw new Error(`task worktree ${worktree.runId} ownership facts do not match`);
+	}
 }
 
-function commitTaskWorktree(worktree: TaskWorktree, message = `Clio task ${worktree.runId}`): boolean {
+function commitTaskWorktree(worktree: TaskWorktree, message = `Clio Coder task ${worktree.runId}`): boolean {
 	assertOwnership(worktree);
 	return commitWorktreePath(worktree.path, COMMIT_IDENTITY, message);
 }

package/src/tools/verify/authoring.ts

@@ -234,7 +234,7 @@ function boundedId(base: string, suffix = ""): string {
 }
 
 /** Allocate the same stable suffix for the same ordered set of occupied IDs. */
-export function deterministicVerifierId(preferredId: string, occupied: ReadonlySet<string>): string {
+function deterministicVerifierId(preferredId: string, occupied: ReadonlySet<string>): string {
 	const base = boundedId(slug(preferredId, "check"));
 	if (!occupied.has(base) && base !== "frontend") return base;
 	for (let index = 2; index <= PROJECT_VERIFIER_CATALOG_CAPS.checks + 2; index += 1) {
@@ -892,7 +892,7 @@ function serializeVerifierDraft(draft: VerifierDraft): string {
 }
 
 /** Validate with the same production parser used by verify(). */
-export function validateVerifierDraft(draft: VerifierDraft): VerifierDraftValidation {
+function validateVerifierDraft(draft: VerifierDraft): VerifierDraftValidation {
 	const text = serializeVerifierDraft(draft);
 	const parsed = parseProjectVerifierCatalogText(text, draft.workspaceRoot, draft.catalogPath);
 	if (!parsed.ok) return { ok: false, reason: parsed.reason, text };
@@ -944,10 +944,7 @@ function cloneDraft(draft: VerifierDraft): VerifierDraft {
 }
 
 /** Apply edits to a copy so a collision or schema failure leaves the prior draft intact. */
-export function reviseVerifierDraft(
-	draft: VerifierDraft,
-	revisions: ReadonlyArray<VerifierRevision>,
-): VerifierRevisionResult {
+function reviseVerifierDraft(draft: VerifierDraft, revisions: ReadonlyArray<VerifierRevision>): VerifierRevisionResult {
 	const next = cloneDraft(draft);
 	const diagnostics: string[] = [];
 	for (const revision of revisions) {

package/src/tools/verify/frontend.ts

@@ -447,7 +447,7 @@ async function checkModuleJavaScript(
 	label: string,
 	options: ValidationOptions,
 ): Promise<string | null> {
-	const dir = mkdtempSync(path.join(tmpdir(), "clio-frontend-check-"));
+	const dir = mkdtempSync(path.join(tmpdir(), "clio-coder-frontend-check-"));
 	const file = path.join(dir, "module.mjs");
 	try {
 		writeFileSync(file, source, "utf8");

package/src/tools/web-fetch.ts

@@ -256,7 +256,7 @@ function htmlToMarkdown(html: string, baseUrl: string): string {
 		.trim();
 }
 
-export function extractWebFetchContent(
+function extractWebFetchContent(
 	rawText: string,
 	contentType: string,
 	finalUrl: string,

package/src/worker/entry.ts

@@ -122,7 +122,7 @@ async function main(): Promise<number> {
 	setResidencyNoticeSink((notice) => {
 		process.stderr.write(`[worker] residency ${notice.kind}: ${notice.message}\n`);
 		if (notice.kind === "will-not-fit") {
-			emitEvent({ type: "clio_run_outcome", payload: { outcomeCode: "vram_capacity_fit_failure" } });
+			emitEvent({ type: "clio_coder_run_outcome", payload: { outcomeCode: "vram_capacity_fit_failure" } });
 		}
 	});
 	const demux = createWorkerStdinDemux();
@@ -227,12 +227,13 @@ async function main(): Promise<number> {
 	const handle = startWorkerRun(input, (event) => emitEvent(projectWorkerEventForStdout(event)));
 	// The demux buffers lines that landed before the runtime handle existed.
 	// Single-shot subprocesses expose no steer method, and an SDK query can race
-	// completion. The runtime emits the receipt-bearing clio_steer_received event
+	// completion. The runtime emits the receipt-bearing clio_coder_steer_received event
 	// only after it accepts the message; rejected input is diagnostic-only.
 	demux.onSteer(
 		createOrderedSteerHandler(
 			(text) => handle.steer?.(text) ?? false,
-			({ text, sequence }) => emitEvent({ type: "clio_steer_received", payload: { chars: text.trim().length, sequence } }),
+			({ text, sequence }) =>
+				emitEvent({ type: "clio_coder_steer_received", payload: { chars: text.trim().length, sequence } }),
 			(reason) => process.stderr.write(`[worker] dropped steer: ${reason}\n`),
 		),
 	);

package/src/worker/protocol.ts

@@ -22,6 +22,7 @@
  */
 
 import { createHash } from "node:crypto";
+import { normalizeClioCoderEventRecord } from "../core/naming-events.js";
 
 /** Current wire protocol. A peer announcing anything else is not executed. */
 export const WORKER_PROTOCOL_VERSION = 1;
@@ -291,7 +292,7 @@ const HEX_64 = /^[0-9a-f]{64}$/;
  * always present and never leaks absence as an empty string.
  */
 export function endpointIdentityHash(url: string | undefined): string {
-	if (url === undefined || url.trim().length === 0) return sha256Hex("clio.endpoint:none");
+	if (url === undefined || url.trim().length === 0) return sha256Hex("clio-coder.endpoint:none");
 	const raw = url.trim();
 	let canonical: string;
 	try {
@@ -301,17 +302,17 @@ export function endpointIdentityHash(url: string | undefined): string {
 	} catch {
 		canonical = raw.replace(/\/+$/u, "");
 	}
-	return sha256Hex(`clio.endpoint:${canonical}`);
+	return sha256Hex(`clio-coder.endpoint:${canonical}`);
 }
 
 /** Digest of one WorkerSpec document, computed identically on both ends. */
 export function workerSpecDigest(spec: unknown): string {
-	return sha256Hex(`clio.workerSpec:${canonicalJson(spec)}`);
+	return sha256Hex(`clio-coder.workerSpec:${canonicalJson(spec)}`);
 }
 
 /** Stable signature of the effective tool surface a worker will expose. */
 export function toolSignatureOf(names: ReadonlyArray<string>): string {
-	return sha256Hex(`clio.tools:${[...names].sort().join(",")}`);
+	return sha256Hex(`clio-coder.tools:${[...names].sort().join(",")}`);
 }
 
 /**
@@ -365,7 +366,8 @@ function parseJsonObject(line: string, maxBytes: number, lane: string): FramePar
 
 /** Parse one bulk stdout line under the bulk ceiling. */
 export function parseBulkFrame(line: string): FrameParseResult<Record<string, unknown>> {
-	return parseJsonObject(line, WORKER_BULK_FRAME_MAX_BYTES, "bulk");
+	const parsed = parseJsonObject(line, WORKER_BULK_FRAME_MAX_BYTES, "bulk");
+	return parsed.ok ? { ok: true, value: normalizeClioCoderEventRecord(parsed.value) } : parsed;
 }
 
 /** True when a raw stderr line belongs to the structured control lane. */
@@ -507,15 +509,15 @@ export function parseControlFrame(line: string): FrameParseResult<WorkerControlF
  */
 const RECEIPT_BEARING_BULK_TYPES = new Set([
 	"message_end",
-	"clio_run_outcome",
-	"clio_permission_escalated",
-	"clio_permission_resolved",
-	"clio_steer_received",
-	"clio_tool_activity",
-	"clio_skill_activation",
-	"clio_safety_decision",
-	"clio_verification",
-	"clio_usage",
+	"clio_coder_run_outcome",
+	"clio_coder_permission_escalated",
+	"clio_coder_permission_resolved",
+	"clio_coder_steer_received",
+	"clio_coder_tool_activity",
+	"clio_coder_skill_activation",
+	"clio_coder_safety_decision",
+	"clio_coder_verification",
+	"clio_coder_usage",
 	"tool_execution_end",
 	"spawn_error",
 ]);

package/src/worker/spec-contract.ts

@@ -143,7 +143,7 @@ interface WorkerSpecFields {
 	 * Non-stall posture for permission-requiring tool calls. "deny" converts
 	 * the call into a structured tool denial and the run continues; "fail"
 	 * aborts the run, which then exits with WORKER_EXIT_PERMISSION_REQUIRED;
-	 * "escalate" parks the call, emits clio_permission_escalated, and waits for
+	 * "escalate" parks the call, emits clio_coder_permission_escalated, and waits for
 	 * an operator permission_decision on stdin (falling back to the configured
 	 * deny/fail on timeout). Default "deny".
 	 */
@@ -229,7 +229,7 @@ const TOOL_PROFILE_NAMES = [
 	"council-read-only",
 ] as const satisfies ReadonlyArray<ToolProfileName>;
 const WORKER_PRODUCTS = ["orientation"] as const satisfies ReadonlyArray<AgentProduct>;
-const TARGET_LIFECYCLES = ["user-managed", "clio-managed"] as const;
+const TARGET_LIFECYCLES = ["user-managed", "clio-coder-managed"] as const;
 const RESIDENCY_ROLES = ["chat", "memory", "worker", "target-default"] as const satisfies ReadonlyArray<ResidencyRole>;
 const MIDDLEWARE_HOOKS = ["before_tool", "after_tool", "turn_start", "turn_end", "on_compaction"] as const;
 const MIDDLEWARE_EFFECT_KINDS = [

package/src/worker/stdin-demux.ts

@@ -13,7 +13,7 @@ export interface WorkerStdinDemux {
 	/**
 	 * Register the handler for post-spec steer lines
 	 * (`{"type":"steer","text":"...","sequence":1}`). The sequence is assigned by
-	 * the parent and is what lets `clio_steer_received` acknowledge one exact
+	 * the parent and is what lets `clio_coder_steer_received` acknowledge one exact
 	 * receipt entry, so a line without a positive integer sequence is dropped
 	 * rather than delivered unattributed. Steers that arrive before registration
 	 * are buffered in order and flushed to the handler. Single handler; a second
@@ -54,7 +54,7 @@ export interface WorkerSteerMessage {
 
 /**
  * Preserve stdin order while a runtime accepts guidance asynchronously.
- * `clio_steer_received` echoes the parent-assigned sequence, so an
+ * `clio_coder_steer_received` echoes the parent-assigned sequence, so an
  * acknowledgement closes out one exact receipt entry. Ordering still matters
  * for the runtime itself: a later steer must never reach it ahead of an earlier
  * pending one, or the guidance arrives out of the order the operator sent it.

package/dist/chunk-D73KXYPF.js

@@ -1,37 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  durableAssistantTextFromEvent
-} from "./chunk-TEO2TLVN.js";
-import {
-  responseModelIdObservationFromRecord
-} from "./chunk-LXPJXFM5.js";
-import {
-  init_esm_shims
-} from "./chunk-3R73A4XB.js";
-
-// src/tools/dispatch-event-text.ts
-init_esm_shims();
-function assistantTextFromEvent(event) {
-  return durableAssistantTextFromEvent(event).trim();
-}
-function receiptResponseModelIdObservationLabel(receipt) {
-  const responses = receipt.upstreamResponses ?? [];
-  if (responses.length === 0) return null;
-  const labels = responses.map((response) => {
-    const observation = responseModelIdObservationFromRecord(
-      response,
-      "legacy-difference-only"
-    );
-    if (observation.state === "reported") return `reported:${observation.reportedModelId}`;
-    if (observation.state === "not-reported") return "not-reported";
-    if (observation.state === "not-observed") return "not-observed";
-    return `legacy-difference-only:${observation.differingModelId ?? "none"}`;
-  });
-  return `response_model_id_observation=${labels.join(",")}`;
-}
-
-export {
-  assistantTextFromEvent,
-  receiptResponseModelIdObservationLabel
-};
-//# sourceMappingURL=chunk-D73KXYPF.js.map