zigmini 0.9.0-beta.2 → 1.0.0-beta.1

package/src/work-watch.ts

@@ -1,4 +1,5 @@
 import { blockingCompaction, COMPACTION_FAILURE_KINDS, compactionOutcome, type OmoEvent } from "./omo/client.ts";
+import { say, type Text } from "./server-text.ts";
 import type { Store, WorkCommand, WorkItem, WorkUpdate } from "./store.ts";
 
 /**
@@ -58,7 +59,7 @@ export interface Verdict {
 	readonly waitingFor?: "children";
 	/** Machine-readable basis, e.g. no_activity, status_request_unanswered, model_error. */
 	readonly reason: string;
-	/** One short Korean line for the card's name view. */
+	/** One short line for the card's name view, in the language it was judged in. */
 	readonly note?: string;
 	/** When the basis of this verdict began (ms). The board shows it as the card's time. */
 	readonly since: number;
@@ -103,7 +104,28 @@ export interface JudgeInput {
 
 const TERMINAL = new Set(["completed", "failed", "cancelled"]);
 const UNSETTLED = new Set(["pending", "sending", "unknown"]);
-const ERROR_LABELS = { model_error: "모델 오류", compaction_failed: "컨텍스트 압축 실패", retry_exhausted: "재시도 실패" } as const;
+const ERROR_LABELS = {
+	model_error: { en: "Model error", ko: "모델 오류" },
+	compaction_failed: { en: "Context compaction failed", ko: "컨텍스트 압축 실패" },
+	retry_exhausted: { en: "Retry failed", ko: "재시도 실패" },
+} as const satisfies Record<string, Text>;
+const MODEL_RESPONSE_ERROR: Text = { en: "Model response error", ko: "모델 응답 오류" };
+const NOTE_CHILDREN: Text = { en: "Running child tasks: {count}", ko: "하위 작업 {count}개 실행 중" };
+const NOTE_QUIET: Text = { en: "No activity for over {duration}", ko: "{duration} 넘게 활동이 없습니다" };
+const NOTE_QUIET_IN_TOOL: Text = { en: "No activity for over {duration} while a tool ({tool}) was running", ko: "도구 실행({tool}) 중 {duration} 넘게 활동이 없습니다" };
+const NOTE_CANCEL_STOPPED: Text = { en: "The run stopped after the cancel command", ko: "취소 명령 뒤 실행이 멈췄습니다" };
+const NOTE_UNDELIVERED: Text = { en: "The command was not confirmed as received", ko: "명령 수신을 확인하지 못했습니다" };
+const NOTE_DELIVERY_CHECKING: Text = { en: "Confirming that the command was received", ko: "명령 수신을 확인하는 중입니다" };
+const NOTE_REPORT: Text = { en: "Report: {summary}", ko: "보고: {summary}" };
+const NOTE_REQUEST_UNANSWERED: Text = { en: "The status report request got no response", ko: "상태 보고 요청에 응답이 없습니다" };
+const NOTE_REQUESTED: Text = { en: "Stopped without a report, so a status report was requested", ko: "보고 없이 멈춰 상태 보고를 요청했습니다" };
+const NOTE_STOPPED: Text = { en: "Stopped without a report", ko: "보고 없이 멈췄습니다" };
+const SECONDS: Text = { en: "{count} sec", ko: "{count}초" };
+const MINUTES: Text = { en: "{count} min", ko: "{count}분" };
+const ALERT_SUMMARY: Text = {
+	en: "Work watcher verdict: failed ({note}). The stored work status was not changed, and no automatic restart or cancel was done.",
+	ko: "작업 감시자 판정: 고장 ({note}). 저장된 작업 상태는 바꾸지 않았고 자동 재시작·취소는 하지 않았습니다.",
+};
 
 function record(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -128,7 +150,7 @@ function shorten(text: string, max: number): string {
 }
 
 function duration(ms: number): string {
-	return ms < 60_000 ? `${Math.round(ms / 1000)}초` : `${Math.round(ms / 60_000)}분`;
+	return ms < 60_000 ? say(SECONDS, { count: Math.round(ms / 1000) }) : say(MINUTES, { count: Math.round(ms / 60_000) });
 }
 
 function iso(ms: number): string {
@@ -159,7 +181,7 @@ export function judge(input: JudgeInput, config: WatchConfig = DEFAULT_WATCH): V
 	const waitSince = Date.parse(reports.at(-1)?.receivedAt ?? work.createdAt);
 	const childWait = (next: number): Verdict => ({
 		state: "waiting", waitingFor: "children", reason: "children_running",
-		note: `하위 작업 ${children}개 실행 중`, since: waitSince, next,
+		note: say(NOTE_CHILDREN, { count: children }), since: waitSince, next,
 	});
 	// Without confirmed runtime evidence (no event, no reconciliation yet) the watcher shows the record and never acts.
 	if (live.streaming === null) return { state: storeState(work), reason: "runtime_unknown", since: base, next: Infinity };
@@ -176,12 +198,12 @@ export function judge(input: JudgeInput, config: WatchConfig = DEFAULT_WATCH): V
 		const unresponsiveAt = quietFrom + allowed;
 		const brokenAt = unresponsiveAt + config.brokenAfterMs;
 		const evidence = { signal: "no_activity", last_activity_at: iso(quietFrom), open_tools: tools.map((tool) => tool.name), observed_since: iso(live.observedSince) };
-		const what = tools.length > 0 ? `도구 실행(${shorten(tools[0]?.name ?? "", 24)}) 중 ` : "";
+		const quiet = (ms: number): string => tools.length > 0 ? say(NOTE_QUIET_IN_TOOL, { duration: duration(ms), tool: shorten(tools[0]?.name ?? "", 24) }) : say(NOTE_QUIET, { duration: duration(ms) });
 		if (now >= brokenAt) {
-			return { state: "broken", reason: "no_activity", note: `${what}${duration(allowed + config.brokenAfterMs)} 넘게 활동이 없습니다`, since: quietFrom, next: Infinity, evidence };
+			return { state: "broken", reason: "no_activity", note: quiet(allowed + config.brokenAfterMs), since: quietFrom, next: Infinity, evidence };
 		}
 		if (now >= unresponsiveAt) {
-			return { state: "unresponsive", reason: "no_activity", note: `${what}${duration(allowed)} 넘게 활동이 없습니다`, since: quietFrom, next: brokenAt, evidence };
+			return { state: "unresponsive", reason: "no_activity", note: quiet(allowed), since: quietFrom, next: brokenAt, evidence };
 		}
 		return { state: "running", reason: "active", since: base, next: unresponsiveAt };
 	}
@@ -191,13 +213,13 @@ export function judge(input: JudgeInput, config: WatchConfig = DEFAULT_WATCH): V
 	if (children > 0) return childWait(Infinity);
 	if (command.kind === "cancel" && command.delivery === "accepted") {
 		const at = Math.max(stoppedAt, Date.parse(command.acceptedAt ?? command.createdAt));
-		if (now >= at + config.settleMs) return { state: "cancelled", reason: "cancel_stopped", note: "취소 명령 뒤 실행이 멈췄습니다", since: at, next: Infinity };
+		if (now >= at + config.settleMs) return { state: "cancelled", reason: "cancel_stopped", note: say(NOTE_CANCEL_STOPPED), since: at, next: Infinity };
 		return { state: "unknown", reason: "cancel_settling", since: at, next: at + config.settleMs };
 	}
 	const error = live.lastError;
 	if (error && error.at >= commandAt && !(latestReport && Date.parse(latestReport.receivedAt) > error.at)) {
 		return {
-			state: "broken", reason: error.kind, note: `${ERROR_LABELS[error.kind]}: ${shorten(error.message, 80)}`, since: error.at, next: Infinity,
+			state: "broken", reason: error.kind, note: `${say(ERROR_LABELS[error.kind])}: ${shorten(error.message, 80)}`, since: error.at, next: Infinity,
 			evidence: { signal: error.kind, at: iso(error.at), message: shorten(error.message, 300) },
 		};
 	}
@@ -206,23 +228,23 @@ export function judge(input: JudgeInput, config: WatchConfig = DEFAULT_WATCH): V
 		const at = Math.max(stoppedAt, commandAt);
 		const brokenAt = at + config.reportResponseMs;
 		const evidence = { signal: "command_delivery_unknown", command_seq: command.seq, error: command.error, since: iso(at) };
-		if (now >= brokenAt) return { state: "broken", reason: "command_undelivered", note: "명령 수신을 확인하지 못했습니다", since: at, next: Infinity, evidence };
-		return { state: "unknown", reason: "command_delivery_unknown", note: "명령 수신을 확인하는 중입니다", since: at, next: brokenAt };
+		if (now >= brokenAt) return { state: "broken", reason: "command_undelivered", note: say(NOTE_UNDELIVERED), since: at, next: Infinity, evidence };
+		return { state: "unknown", reason: "command_delivery_unknown", note: say(NOTE_DELIVERY_CHECKING), since: at, next: brokenAt };
 	}
 	if (command.delivery !== "accepted") return { state: "unknown", reason: `command_${command.delivery}`, since: base, next: Infinity };
 	if (latestReport) {
-		return { state: "waiting", reason: `reported_${latestReport.kind}`, note: `보고: ${shorten(latestReport.summary, 80)}`, since: Date.parse(latestReport.receivedAt), next: Infinity };
+		return { state: "waiting", reason: `reported_${latestReport.kind}`, note: say(NOTE_REPORT, { summary: shorten(latestReport.summary, 80) }), since: Date.parse(latestReport.receivedAt), next: Infinity };
 	}
 	if (isStatusRequest(command)) {
 		const at = Math.max(stoppedAt, Date.parse(command.acceptedAt ?? command.createdAt));
 		const brokenAt = at + config.reportResponseMs;
 		if (now >= brokenAt) {
 			return {
-				state: "broken", reason: "status_request_unanswered", note: "상태 보고 요청에 응답이 없습니다", since: at, next: Infinity,
+				state: "broken", reason: "status_request_unanswered", note: say(NOTE_REQUEST_UNANSWERED), since: at, next: Infinity,
 				evidence: { signal: "status_request_unanswered", command_seq: command.seq, requested_at: command.createdAt, stopped_since: iso(at) },
 			};
 		}
-		return { state: "unknown", reason: "status_requested", note: "보고 없이 멈춰 상태 보고를 요청했습니다", since: at, next: brokenAt };
+		return { state: "unknown", reason: "status_requested", note: say(NOTE_REQUESTED), since: at, next: brokenAt };
 	}
 	// The latest command gets the full window from its own acceptance, however long the work had been stopped before it.
 	const requestFrom = Math.max(stoppedAt, Date.parse(command.acceptedAt ?? command.createdAt));
@@ -230,7 +252,7 @@ export function judge(input: JudgeInput, config: WatchConfig = DEFAULT_WATCH): V
 	const interrupted = work.statusReason === "omo_disconnected";
 	const requestAt = interrupted ? requestFrom : requestFrom + config.reportRequestMs;
 	if (now >= requestAt && !commands.some((candidate) => UNSETTLED.has(candidate.delivery))) {
-		return { state: "unknown", reason: "stopped_without_report", note: "보고 없이 멈췄습니다", since: requestFrom, next: Infinity, action: "request_status" };
+		return { state: "unknown", reason: "stopped_without_report", note: say(NOTE_STOPPED), since: requestFrom, next: Infinity, action: "request_status" };
 	}
 	return { state: "unknown", reason: "stopped", since: requestFrom, next: requestAt };
 }
@@ -368,7 +390,7 @@ export class WorkWatcher {
 				// even with errorMessage set; a work that really stops afterwards is judged by the status request (bug 23).
 				if (message.stopReason === "aborted") return false;
 				if (message.stopReason === "error" || typeof message.errorMessage === "string") {
-					live.lastError = { kind: "model_error", message: typeof message.errorMessage === "string" ? message.errorMessage : "모델 응답 오류", at: now };
+					live.lastError = { kind: "model_error", message: typeof message.errorMessage === "string" ? message.errorMessage : say(MODEL_RESPONSE_ERROR), at: now };
 				} else {
 					live.lastError = null;
 				}
@@ -388,7 +410,7 @@ export class WorkWatcher {
 			case "auto_retry_end":
 				// A user abort cancels a pending retry; that is not a breakdown.
 				if (event.success !== false || event.finalError === "Retry cancelled") return false;
-				live.lastError = { kind: "retry_exhausted", message: typeof event.finalError === "string" ? event.finalError : "재시도 실패", at: now };
+				live.lastError = { kind: "retry_exhausted", message: typeof event.finalError === "string" ? event.finalError : say(ERROR_LABELS.retry_exhausted), at: now };
 				return true;
 			case "extension_event": {
 				if (event.name !== "omo.task.updated" || !record(event.data) || !Array.isArray(event.data.tasks)) return false;
@@ -510,7 +532,7 @@ export class WorkWatcher {
 		const recorded = this.store.recordWatchAlert(work.id, {
 			sourceKey: `watch:broken:${work.id}:${command.seq}`,
 			commandSeq: command.seq,
-			summary: `작업 감시자 판정: 고장 (${verdict.note ?? verdict.reason}). 저장된 작업 상태는 바꾸지 않았고 자동 재시작·취소는 하지 않았습니다.`,
+			summary: say(ALERT_SUMMARY, { note: verdict.note ?? verdict.reason }),
 			details: { source: "watcher", verdict: "broken", reason: verdict.reason, judged_at: iso(this.clock()), evidence: verdict.evidence ?? null },
 		});
 		if (recorded) this.hooks.alerted(work);

package/web/agent-icon.js

@@ -1,3 +1,8 @@
+import dict from "./i18n/agent-icon.js";
+import { applyI18n, registerStrings, t } from "./i18n.js";
+
+registerStrings(dict);
+
 // Improvement 60: the agent's (Zig's) profile icon. Double-clicking the agent avatar opens a small editor: choose a
 // PNG/JPEG/WebP of at most 1 MB, see it center-cropped to a square, save it, or go back to the default icon. Escape closes
 // the editor without a change. The gateway keeps the image (/api/profile/icon); `agentIcon` in the profile is its version.
@@ -16,8 +21,8 @@ export function agentIconUrl(version) {
 
 /** Null when [file] can be used, else the Korean message to show. */
 export function iconFileProblem(file) {
-	if (!ICON_TYPES.includes(file?.type)) return "PNG, JPEG, WebP 이미지만 쓸 수 있습니다.";
-	if (file.size > ICON_MAX_BYTES) return "이미지가 1MB보다 큽니다. 더 작은 이미지를 고르세요.";
+	if (!ICON_TYPES.includes(file?.type)) return t("icon.problem.type");
+	if (file.size > ICON_MAX_BYTES) return t("icon.problem.size");
 	return null;
 }
 
@@ -58,17 +63,18 @@ export function editAgentIcon(host, currentUrl, { onSave, onReset }) {
 	const editor = document.createElement("div");
 	editor.className = "icon-editor";
 	editor.setAttribute("role", "dialog");
-	editor.setAttribute("aria-label", "에이전트 아이콘 바꾸기");
+	editor.setAttribute("aria-label", t("icon.editor.label"));
 	editor.innerHTML = `<img class="icon-editor-preview" alt="" width="64" height="64" />
-		<div class="icon-editor-hint">PNG, JPEG, WebP · 1MB 이하 · 가운데를 정사각형으로 자릅니다</div>
+		<div class="icon-editor-hint" data-i18n="icon.editor.hint"></div>
 		<div class="icon-editor-error" role="alert" hidden></div>
 		<input type="file" accept="${ICON_TYPES.join(",")}" hidden />
 		<div class="icon-editor-actions">
-			<button type="button" data-act="pick">이미지 선택</button>
-			<button type="button" data-act="save" disabled>저장</button>
-			<button type="button" data-act="reset">기본 아이콘</button>
-			<button type="button" data-act="cancel">취소</button>
+			<button type="button" data-act="pick" data-i18n="icon.pick"></button>
+			<button type="button" data-act="save" data-i18n="icon.save" disabled></button>
+			<button type="button" data-act="reset" data-i18n="icon.reset"></button>
+			<button type="button" data-act="cancel" data-i18n="icon.cancel"></button>
 		</div>`;
+	applyI18n(editor);
 	const preview = editor.querySelector(".icon-editor-preview");
 	const error = editor.querySelector(".icon-editor-error");
 	const input = editor.querySelector("input");
@@ -107,7 +113,7 @@ export function editAgentIcon(host, currentUrl, { onSave, onReset }) {
 		try {
 			chosen = await squarePng(file);
 		} catch {
-			showError("이미지를 읽지 못했습니다. 다른 이미지를 고르세요.");
+			showError(t("icon.readFailed"));
 			return;
 		}
 		showError(null);

package/web/agents.d.ts

@@ -0,0 +1,201 @@
+export type FieldOrigin = "package" | "defaults" | "agent" | "none";
+export type FieldWidget = "text" | "textarea" | "number" | "toggle" | "model" | "select" | "skills" | "group";
+export type FieldType = "string" | "integer" | "boolean" | "object" | "strings";
+export type EditorKind = "new" | "agent" | "defaults";
+
+/** One gateway registry row as the agent API sends it (`registry` in detail and defaults answers; an absent default is undefined). */
+export interface AgentFieldMeta {
+	readonly name: string;
+	readonly type: FieldType;
+	readonly default?: unknown;
+	readonly required: boolean;
+	readonly merge: "replace" | "keys";
+	readonly applies: "gateway" | "extension";
+	readonly widget: FieldWidget;
+	readonly forbidden: boolean;
+}
+
+/** The editor's labels and hints for one registry field name. */
+export interface FieldPresentation {
+	readonly label: string;
+	readonly help?: string;
+	readonly options?: readonly string[];
+	readonly min?: number;
+	readonly max?: number;
+}
+
+/** A registry row joined with its presentation: what editorRows() and widgetValue() work from. */
+export interface AgentFieldRow extends AgentFieldMeta {
+	readonly label: string;
+	readonly help: string;
+	readonly options?: readonly string[];
+	readonly min?: number;
+	readonly max?: number;
+}
+
+/** GET /api/agents rows and `agent.updated` payloads. */
+export interface AgentSummary {
+	readonly id: string;
+	readonly name: string;
+	readonly description: string;
+	readonly icon: string | null;
+	readonly convId: string;
+	readonly definitionSha: string;
+	readonly stale: boolean;
+}
+
+/** GET /api/agents/:id: the summary with the definition text, the merged result and the field registry. */
+export interface AgentDetail extends AgentSummary {
+	readonly source: string;
+	readonly fields: Readonly<Record<string, unknown>>;
+	readonly body: string;
+	readonly defaultsBody: string;
+	readonly origins: Readonly<Record<string, "package" | "defaults" | "agent">>;
+	readonly sha: string;
+	readonly registry: readonly AgentFieldMeta[];
+}
+
+/** GET and PUT /api/agents/defaults: the defaults.md text and the same field registry. */
+export interface AgentDefaults {
+	readonly source: string;
+	readonly registry: readonly AgentFieldMeta[];
+}
+
+export interface ConversationRow {
+	readonly id: string;
+	readonly title: string;
+	readonly threadId?: string | null;
+	readonly createdAt?: string;
+	readonly agentId: string | null;
+}
+
+export interface SourceSplit {
+	readonly ok: boolean;
+	readonly preamble: string;
+	readonly entries: readonly { readonly key: string | null; readonly raw: string }[];
+	readonly body: string;
+}
+
+export interface EditorState {
+	readonly kind: EditorKind;
+	readonly registry: readonly AgentFieldRow[];
+	readonly id: string | null;
+	readonly name: string | null;
+	readonly convId: string | null;
+	readonly stale: boolean;
+	readonly own: Record<string, unknown>;
+	readonly rawByKey: Readonly<Record<string, string>>;
+	readonly touched: ReadonlySet<string>;
+	readonly unparsed: ReadonlySet<string>;
+	readonly unknownRaw: string;
+	readonly unknownTouched: boolean;
+	readonly preamble: string;
+	readonly body: string;
+	readonly bodyTouched: boolean;
+	readonly inherited: Readonly<Record<string, unknown>>;
+	readonly origins: Readonly<Record<string, string>>;
+	readonly dirty: boolean;
+}
+
+export type EditorRow =
+	| { readonly kind: "group"; readonly name: string; readonly label: string; readonly help: string }
+	| {
+		readonly kind: "field";
+		readonly name: string;
+		readonly label: string;
+		readonly help: string;
+		readonly widget: FieldWidget;
+		readonly type: FieldType;
+		readonly required: boolean;
+		readonly value: unknown;
+		readonly own: boolean;
+		readonly origin: FieldOrigin;
+		readonly originLabel: string;
+		readonly clearable: boolean;
+		readonly unparsed: boolean;
+		readonly options?: readonly string[];
+		readonly min?: number;
+		readonly max?: number;
+	};
+
+/** What widgetValue() reads from a registry row or an editor field row. */
+export type WidgetSpec = Pick<AgentFieldRow, "widget" | "required" | "label"> & Partial<Pick<AgentFieldRow, "options" | "min" | "max">>;
+export interface EditorError { readonly name: string; readonly message: string }
+export interface ApiRequest { readonly method: "GET" | "POST" | "PUT"; readonly path: string; readonly headers?: Readonly<Record<string, string>>; readonly body?: string }
+
+export interface SidebarItem {
+	readonly convId: string;
+	readonly agentId: string;
+	readonly name: string;
+	readonly description: string;
+	readonly icon: string;
+	readonly active: boolean;
+	readonly running: boolean;
+	readonly pending: boolean;
+	readonly stale: boolean;
+}
+
+export interface SidebarView {
+	readonly current: string;
+	readonly running: ReadonlySet<string>;
+	readonly busy: (convId: string) => boolean;
+	readonly pending: ReadonlyMap<string, number>;
+}
+
+export interface HeaderView { readonly agent: boolean; readonly agentId: string | null; readonly icon: string; readonly name: string; readonly stale: boolean }
+export interface TrashRow { readonly entry: string; readonly id: string | null; readonly name: string; readonly description: string; readonly icon: string; readonly deletedAt: string | null }
+export interface FileRow { readonly path: string; readonly type: "file" | "directory"; readonly size: number; readonly depth: number; readonly name: string; readonly label: string; readonly source: boolean }
+export interface AgentUpdateResult<P, C> { readonly agents: readonly P[]; readonly conversations: readonly C[]; readonly removedConv: string | null; readonly restoredConv: string | null }
+
+export const AGENTS_PATH: string;
+export const DEFAULTS_PATH: string;
+export const TRASH_PATH: string;
+export const AGENT_MAX_BYTES: number;
+export const DESCRIPTION_MAX: number;
+export const MEMORY_MAX_BYTES: number;
+export const THINKING_LEVELS: readonly string[];
+export const ORIGIN_LABELS: Readonly<Record<FieldOrigin, string>>;
+export const DEFAULT_ICON: string;
+export const STALE_LABEL: string;
+export const STALE_TITLE: string;
+export const DELETE_HINT: string;
+export const EMPTY_AGENTS_LINE: string;
+export const EMPTY_TRASH_LINE: string;
+export const EMPTY_FILES_LINE: string;
+export const NEW_AGENT_BODY: string;
+export const FIELD_PRESENTATION: Readonly<Record<string, FieldPresentation>>;
+
+export function fieldAt(fields: unknown, name: string): unknown;
+export function editorFields(registry: readonly AgentFieldMeta[] | null | undefined): AgentFieldRow[];
+export function topLevelKeys(registry: readonly AgentFieldMeta[]): string[];
+export function parseYaml(text: string): unknown;
+export function emitScalar(value: unknown): string;
+export function emitEntry(key: string, value: unknown): string;
+export function splitSource(source: string): SourceSplit;
+export function editorState(detail: Partial<AgentDetail> | Partial<AgentDefaults> | null | undefined, kind?: EditorKind): EditorState;
+export function packageDefaults(registry: readonly AgentFieldMeta[]): Record<string, unknown>;
+export function editorRows(state: EditorState): EditorRow[];
+export function widgetValue(field: WidgetSpec, input: unknown): { value?: unknown; error?: string };
+export function setField(state: EditorState, name: string, value: unknown): EditorState;
+export function clearField(state: EditorState, name: string): EditorState;
+export function setBody(state: EditorState, body: string): EditorState;
+export function setUnknownRaw(state: EditorState, unknownRaw: string): EditorState;
+export function composeSource(state: EditorState): string;
+export function validateEditor(state: EditorState): EditorError[];
+export function saveRequest(state: EditorState): ApiRequest;
+export function deleteEnabled(typed: string, name: string | null | undefined): boolean;
+export function deleteRequest(id: string, name: string): ApiRequest;
+export function cloneRequest(id: string): ApiRequest;
+export function restoreRequest(entry: string): ApiRequest;
+export function filesPath(id: string): string;
+export function sourceUploadPath(id: string): string;
+export function errorLine(body: unknown, status: number): string;
+export function applyAgentUpdate<P extends { id: string; convId?: string }, C extends ConversationRow>(agents: readonly P[], conversations: readonly C[], data: unknown, now?: number): AgentUpdateResult<P | AgentSummary, C | ConversationRow>;
+export function applyAgentApplied<P extends { convId: string; definitionSha: string; stale: boolean }>(agents: readonly P[], convId: string, data: unknown): P[];
+export function mainConversations<C extends ConversationRow>(conversations: readonly C[]): C[];
+export function shownConversation(conversations: readonly ConversationRow[], id: string): string;
+export function agentInitial(name: unknown): string;
+export function sidebarItems(conversations: readonly ConversationRow[], agents: readonly Partial<AgentSummary>[], view: SidebarView): SidebarItem[];
+export function headerView(conv: ConversationRow | null | undefined, agents: readonly Partial<AgentSummary>[]): HeaderView;
+export function trashRows(entries: unknown): TrashRow[];
+export function fileRows(entries: unknown): FileRow[];