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

package/host/omo-bridge/agent-control.ts

@@ -0,0 +1,274 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { homedir } from "node:os";
+import { INSTALL_RULES_FILE, INSTALL_RULES_HEADING, packageRulesDrop, PACKAGE_RULES_FILE, PACKAGE_RULES_HEADING, readRulesFile } from "../../src/agent-rules.ts";
+import { applyRequestRules, loadRequestRules, type ProviderRequestEvent } from "../../src/agent-request-rules.ts";
+import { loadEngineSdk } from "../../src/engine/index.ts";
+import { validateAgentFields } from "../../src/agent/definition.ts";
+import { runtimeHome, runtimePaths } from "../../src/runtime/paths.ts";
+import { agentNamePrompt, nicknamePrompt, readAgentPromptName, readPromptProfile, type PromptProfile } from "../../src/profile-prompt.ts";
+
+type Context = { readonly cwd: string; readonly sessionManager: { getSessionId(): string }; readonly ui: { notify(message: string, level: "warning"): void } };
+type ToolCall = { readonly toolName: string; readonly toolCallId: string; readonly input: Record<string, unknown> };
+type Block = { readonly block: true; readonly reason: string };
+type Skill = { readonly name: string; readonly filePath: string };
+type Start = { readonly systemPrompt: string; readonly systemPromptOptions: { readonly skills?: readonly Skill[] } };
+type Events = {
+	session_start: unknown; session_shutdown: unknown; before_agent_start: Start;
+	before_provider_request: ProviderRequestEvent; tool_call: ToolCall; tool_result: { readonly toolCallId: string };
+	input: { readonly text: string }; agent_end: unknown; session_abort: unknown;
+};
+interface ExtensionApi {
+	readonly sessionKind: string;
+	readonly sessionContext: Readonly<Record<string, string>>;
+	readonly rpc: { emit(name: string, data: unknown): void; handle(name: string, handler: () => unknown): void };
+	on<K extends keyof Events>(event: K, handler: (event: Events[K], ctx: Context) => unknown, options?: { previewSafe: boolean }): void;
+	setActiveTools(names: string[]): void;
+	getCommands(): readonly { readonly name: string; readonly source: string }[];
+	appendEntry(name: string, data: unknown): void;
+	registerTool(tool: HistoryTool): void;
+	registerFilesystemPolicy(policy: { check(request: { operation: string; canonicalPath: string }): { allow: true } | { allow: false; reason: string } }): void;
+}
+type HistoryTool = {
+	name: string; label: string; description: string; parameters: unknown;
+	execute(id: string, params: Record<string, unknown>, signal: AbortSignal | undefined): Promise<unknown>;
+};
+type Edit = { readonly oldText: string; readonly newText: string };
+/** The runtime supplies this public SDK. Tests use the same native editor, not a replacement algorithm. */
+export interface AgentSdk {
+	createEditTool(cwd: string, options: { operations: {
+		readFile(path: string): Promise<Buffer>; writeFile(path: string, content: string): Promise<void>; access(path: string): Promise<void>;
+	} }): { execute(id: string, input: { path: string; edits: Edit[] }): Promise<unknown> };
+}
+const BASE_TOOLS = ["read", "write", "edit", "ask_user_question", "zgw_agent_history_search"];
+export const MEMORY_CAP_MESSAGE = "MEMORY.md를 요약해 줄인 뒤 다시 쓰세요.";
+const DAILY_RULES = "Record each day's facts, results and decisions chronologically in notes/daily/YYYY-MM-DD.md (KST). " +
+	"Keep only long-lived preferences, established facts and ongoing goals summarized in MEMORY.md; do not copy daily logs into it.";
+export const RESEARCH_RULES = "When you research on the web, write the results to knowledge/notes/companies/<company>.md " +
+	"(other topics knowledge/notes/research/<topic>.md) and put each source URL on the line of the fact it supports.";
+const HISTORY_LIMIT = 50;
+const blocked = (reason: string): Block => ({ block: true, reason });
+function record(value: unknown): value is Record<string, unknown> { return typeof value === "object" && value !== null && !Array.isArray(value); }
+function missing(error: unknown): boolean { return error instanceof Error && "code" in error && error.code === "ENOENT"; }
+function inside(root: string, path: string): boolean {
+	const part = relative(root, path);
+	return part === "" || (!isAbsolute(part) && part !== ".." && !part.startsWith(`..${sep}`));
+}
+/** Resolve existing links, including a new target's nearest existing parent. Dangling links fail closed. */
+export function agentPath(path: string): string {
+	try { lstatSync(path); } catch (error) {
+		if (!missing(error)) throw error;
+		return join(agentPath(dirname(path)), basename(path));
+	}
+	return realpathSync(path);
+}
+function owner(path: string): { sessionId: string; pid: number } | undefined {
+	try {
+		const data: unknown = JSON.parse(readFileSync(path, "utf8"));
+		if (record(data) && typeof data.sessionId === "string" && Number.isSafeInteger(data.pid) && typeof data.pid === "number" && data.pid > 0) return { sessionId: data.sessionId, pid: data.pid };
+		throw new Error("agent_lock_invalid");
+	} catch (error) { if (missing(error)) return undefined; throw error; }
+}
+function live(pid: number): boolean {
+	try { process.kill(pid, 0); return true; } catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ESRCH") return false;
+		throw error;
+	}
+}
+/** All lock changes share one exclusive claim directory; a conflicting claimant never removes a newer lock. */
+function claimLock(root: string, sessionId: string, release = false): boolean {
+	const claim = join(root, ".lock.claim");
+	try { mkdirSync(claim); } catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "EEXIST") return false;
+		throw error;
+	}
+	try {
+		const path = join(root, ".lock");
+		const held = owner(path);
+		const ours = held?.sessionId === sessionId && held.pid === process.pid;
+		if (release) { if (ours) unlinkSync(path); return ours; }
+		if (held && !ours && live(held.pid)) return false;
+		if (!ours) writeFileSync(path, JSON.stringify({ sessionId, pid: process.pid }), { mode: 0o600 });
+		return true;
+	} finally { rmdirSync(claim); }
+}
+
+export default function agentControl(pi: ExtensionApi, loadSdk: () => Promise<AgentSdk> = () => loadEngineSdk<AgentSdk>()): void {
+	const id = pi.sessionContext.zgw_agent;
+	if (pi.sessionContext.zgw_role !== "agent" || pi.sessionKind !== "interactive" || !id) return;
+	pi.registerTool({
+		name: "zgw_agent_history_search", label: "Agent history search",
+		description: "Search this agent's own past conversation messages for a text. Returns the newest matches first (at most 50). Other conversations are never searched.",
+		parameters: { type: "object", properties: { query: { type: "string", minLength: 1, maxLength: 200 }, limit: { type: "integer", minimum: 1, maximum: HISTORY_LIMIT } }, required: ["query"], additionalProperties: false },
+		async execute(_toolCallId, params, signal) {
+			if (typeof params.query !== "string" || params.query === "") throw new Error("agent_history_query_required");
+			const limit = typeof params.limit === "number" && Number.isInteger(params.limit) ? Math.min(Math.max(params.limit, 1), HISTORY_LIMIT) : 20;
+			const token = readFileSync(runtimePaths().omoTokenFile, "utf8").trim();
+			const base = process.env.ZGW_WORK_URL ?? `http://127.0.0.1:${process.env.ZGW_PORT ?? "8700"}`;
+			const url = new URL("/internal/agent-history", base);
+			// The agent id comes from the session context, never from the model's arguments.
+			url.search = new URLSearchParams({ agent: id, query: params.query, limit: String(limit) }).toString();
+			const response = await fetch(url, {
+				headers: { authorization: `Bearer ${token}` }, redirect: "error",
+				signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(10_000)]) : AbortSignal.timeout(10_000),
+			});
+			const result: unknown = await response.json();
+			if (!response.ok) throw new Error(`agent_history_http_${response.status}`);
+			return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+		},
+	});
+	let root = "", sessionId = "", prompt = "", ready = false, agentName = "";
+	let maxBytes = 0;
+	let tools: string[] = [], skills: string[] = [];
+	const skillSnapshots = new Map<string, string>();
+	let memoryCall: string | undefined;
+	let ui: Context["ui"] | undefined;
+	let startupWarnings: { code: string; message: string }[] = [];
+	// session_start precedes the gateway's open_session attachment. Read this snapshot after binding the owner.
+	pi.rpc.handle("zgw.agent_warnings", () => ({ warnings: startupWarnings }));
+	const warn = (code: string) => {
+		const data = { agentId: id, code };
+		const message = code === "memory_over_cap" ? `MEMORY.md가 크기 상한을 넘어 이번 세션에서 생략되었습니다. ${MEMORY_CAP_MESSAGE}` : `에이전트 요청이 제한되었습니다: ${code}`;
+		if (!ready) startupWarnings.push({ code, message });
+		pi.appendEntry("zgw.agent_warning", data);
+		pi.rpc.emit("zgw.agent_warning", data);
+		ui?.notify(message, "warning");
+	};
+	const pathDenial = (path: string, write: boolean): string | undefined => {
+		if (!ready) return "agent_not_ready";
+		if (!inside(root, path)) return "agent_path_outside_knowledge";
+		if (!write) return undefined;
+		if (inside(join(root, "source"), path)) return "agent_source_read_only";
+		if (path === root || inside(join(root, ".lock"), path) || inside(join(root, ".lock.claim"), path)) return "agent_lock_protected";
+		if (!claimLock(root, sessionId)) return "agent_knowledge_locked";
+		return undefined;
+	};
+	pi.registerFilesystemPolicy({ check: ({ operation, canonicalPath }) => {
+		try {
+			const reason = pathDenial(canonicalPath, operation === "write");
+			return reason ? { allow: false, reason } : { allow: true };
+		} catch { return { allow: false, reason: "agent_path_unavailable" }; }
+	} });
+	pi.on("session_start", async (_event, ctx) => {
+		ready = false;
+		startupWarnings = [];
+		ui = ctx.ui;
+		pi.setActiveTools([]);
+		const token = readFileSync(runtimePaths().omoTokenFile, "utf8").trim();
+		const base = process.env.ZGW_WORK_URL ?? `http://127.0.0.1:${process.env.ZGW_PORT ?? "8700"}`;
+		const response = await fetch(new URL(`/internal/agent/${encodeURIComponent(id)}`, base), {
+			headers: { authorization: `Bearer ${token}` }, redirect: "error", signal: AbortSignal.timeout(5_000),
+		});
+		if (!response.ok) throw new Error(`agent_definition_http_${response.status}`);
+		const definition: unknown = await response.json();
+		if (!record(definition) || !record(definition.fields) || typeof definition.body !== "string" || typeof definition.defaultsBody !== "string") throw new Error("agent_definition_invalid");
+		validateAgentFields(definition.fields);
+		if (typeof definition.fields.name !== "string") throw new Error("agent_name_invalid");
+		agentName = definition.fields.name;
+		const { memory, rules, tools: toolSettings, skills: allowedSkills } = definition.fields;
+		if (!record(memory) || typeof memory.maxBytes !== "number" || !record(rules) || !record(toolSettings) ||
+			!Array.isArray(allowedSkills) || !allowedSkills.every((s): s is string => typeof s === "string")) throw new Error("agent_definition_unmerged");
+		const expected = join(realpathSync(join(runtimeHome(), "agents")), id, "knowledge");
+		root = realpathSync(expected);
+		if (root !== expected) throw new Error("agent_knowledge_symlink");
+		if (realpathSync(ctx.cwd) !== root) throw new Error("agent_cwd_mismatch");
+		sessionId = ctx.sessionManager.getSessionId();
+		maxBytes = memory.maxBytes;
+		skills = allowedSkills;
+		tools = [...BASE_TOOLS, ...(toolSettings.web === true ? ["web_search", "webfetch"] : [])];
+		const sections: string[] = [];
+		for (const [enabled, path, heading] of [
+			[rules.gateway, PACKAGE_RULES_FILE, PACKAGE_RULES_HEADING],
+			[rules.install, join(runtimeHome(), INSTALL_RULES_FILE), INSTALL_RULES_HEADING],
+		] as const) {
+			if (enabled) { const source = readRulesFile(path, path === PACKAGE_RULES_FILE ? packageRulesDrop() : undefined); if (source.text) sections.push(`${heading}\n\n${source.text}`); }
+		}
+		// body already includes defaultsBody. Put the package daily rule first so defaults can override it.
+		sections.push(DAILY_RULES, definition.body);
+		if (toolSettings.web === true) sections.push(RESEARCH_RULES);
+		const memoryPath = agentPath(join(root, "MEMORY.md"));
+		if (!inside(root, memoryPath)) throw new Error("agent_memory_outside_knowledge");
+		if (existsSync(memoryPath)) {
+			if (statSync(memoryPath).size > maxBytes) warn("memory_over_cap");
+			else {
+				const snapshot = readFileSync(memoryPath);
+				if (snapshot.byteLength > maxBytes) warn("memory_over_cap");
+				else sections.push(`<agent-memory>\n${snapshot.toString("utf8")}\n</agent-memory>`);
+			}
+		}
+		prompt = sections.join("\n\n");
+		if (!claimLock(root, sessionId)) warn("knowledge_locked");
+		ready = true;
+		pi.setActiveTools(tools);
+	});
+	pi.on("session_shutdown", () => { if (root && sessionId) claimLock(root, sessionId, true); ready = false; });
+	const requestRules = loadRequestRules();
+	pi.on("before_provider_request", (event) => applyRequestRules(event, requestRules));
+	let profile: PromptProfile = { nickname: undefined, agentName: "" };
+	pi.on("before_agent_start", async (event) => {
+		if (!ready) throw new Error("agent_not_ready");
+		[profile, agentName] = await Promise.all([readPromptProfile(profile), readAgentPromptName(id, agentName)]);
+		pi.setActiveTools(tools);
+		// File tools remain confined to knowledge. Approved skill bodies are loaded here, not through a read exception.
+		for (const skill of event.systemPromptOptions.skills ?? []) {
+			if (skills.includes(skill.name) && !skillSnapshots.has(skill.name)) skillSnapshots.set(skill.name, readFileSync(skill.filePath, "utf8"));
+		}
+		const base = event.systemPrompt.replace(/<available_skills>[\s\S]*?<\/available_skills>/g, "")
+			.replace(/<skill_roots>[\s\S]*?<\/skill_roots>/g, "");
+		const selected = [...skillSnapshots].map(([name, text]) => `<agent-skill name="${name}">\n${text}\n</agent-skill>`).join("\n\n");
+		return { systemPrompt: [base, prompt, selected, agentNamePrompt(agentName), nicknamePrompt(profile.nickname)].filter(Boolean).join("\n\n") };
+	});
+	pi.on("input", (event) => {
+		if (!ready) { warn("agent_not_ready"); return { action: "handled" }; }
+		const known = new Set(pi.getCommands().filter((command) => command.source === "skill").map((command) => command.name.replace(/^skill:/, "")));
+		for (const match of event.text.matchAll(/(?:^|\s)(\/skill:|\$(?:skill:)?)([a-zA-Z][a-zA-Z0-9:_-]*)(?=\s|$)/g)) {
+			const name = match[2] ?? "";
+			if (known.has(name) && !skills.includes(name)) { warn("skill_not_allowed"); return { action: "handled" }; }
+		}
+		return { action: "continue" };
+	});
+	pi.on("tool_call", async (event) => {
+		if (!ready || !tools.includes(event.toolName)) return blocked("agent_tool_not_allowed");
+		if (!["read", "write", "edit"].includes(event.toolName)) return;
+		try {
+			if (typeof event.input.path !== "string" || event.input.path === "") return blocked("agent_path_required");
+			const expanded = event.input.path.replace(/^~(?=\/|$)/, homedir());
+			const lexical = resolve(root, expanded);
+			const path = agentPath(lexical);
+			const write = event.toolName !== "read";
+			const reason = pathDenial(lexical, write) ?? pathDenial(path, write);
+			if (reason) return blocked(reason);
+			if (write && existsSync(path) && lstatSync(path).nlink > 1) return blocked("agent_linked_file_read_only");
+			// Canonicalize the actual argument too; do not leave a checked symlink for the native tool to follow.
+			event.input.path = path;
+			if (!write || path !== agentPath(join(root, "MEMORY.md"))) return;
+			if (memoryCall !== undefined) return blocked("agent_memory_busy");
+			memoryCall = event.toolCallId;
+			let bytes: number;
+			if (event.toolName === "write") {
+				if (typeof event.input.content !== "string") throw new Error("agent_write_content_required");
+				bytes = Buffer.byteLength(event.input.content);
+			} else {
+				const edits = event.input.edits;
+				if (!Array.isArray(edits) || !edits.every((e): e is Edit => record(e) && typeof e.oldText === "string" && typeof e.newText === "string")) throw new Error("agent_edit_input_invalid");
+				// Run the pinned native editor against memory-only operations: BOM, CRLF, fuzzy and multi-edit semantics stay exact.
+				const sdk = await loadSdk();
+				let result: string | undefined;
+				await sdk.createEditTool(root, { operations: {
+					readFile: async () => readFileSync(path), access: async () => {},
+					writeFile: async (_path, content) => { result = content; },
+				} }).execute(event.toolCallId, { path, edits });
+				if (result === undefined) throw new Error("agent_edit_result_missing");
+				bytes = Buffer.byteLength(result);
+			}
+			if (bytes > maxBytes) { memoryCall = undefined; return blocked(MEMORY_CAP_MESSAGE); }
+		} catch (error) {
+			if (memoryCall === event.toolCallId) memoryCall = undefined;
+			return blocked(error instanceof Error ? error.message : "agent_path_unavailable");
+		}
+	});
+	pi.on("tool_result", (event) => { if (memoryCall === event.toolCallId) memoryCall = undefined; });
+	// A later hook/permission can refuse a call without a tool_result. Its turn end also releases the reservation.
+	pi.on("agent_end", () => { memoryCall = undefined; });
+	pi.on("session_abort", () => { memoryCall = undefined; });
+}

package/host/omo-bridge/bridge.ts

@@ -85,7 +85,7 @@ function spawnOmo(): Subprocess {
 	if (existsSync(socketPath)) rmSync(socketPath);
 	const child = Bun.spawn(engine.launchCommand({
 		home, socket: socketPath, sessionDir,
-		extensions: [join(import.meta.dir, "model-control.ts"), join(import.meta.dir, "task-control.ts")],
+		extensions: [join(import.meta.dir, "model-control.ts"), join(import.meta.dir, "task-control.ts"), join(import.meta.dir, "agent-control.ts")],
 		...(engineRoot ? { engineRoot } : {}),
 	}), {
 		cwd: process.env.HOME ?? home,

package/host/omo-bridge/continuity-control.ts

@@ -122,7 +122,7 @@ export default function continuityControl<Context extends ContinuityContext>(
 	const role = pi.sessionContext.zgw_role;
 	const isMain =
 		pi.sessionKind === "interactive" &&
-		(role === "main" || role === undefined) &&
+		(role === "main" || role === "agent" || role === undefined) &&
 		Boolean(pi.sessionContext.zgw_conv);
 	if (!isMain) return;
 

package/host/omo-bridge/task-control.ts

@@ -3,6 +3,7 @@ import { isDeepStrictEqual } from "node:util";
 import { runtimePaths } from "../../src/runtime/paths.ts";
 import { agentRules } from "../../src/agent-rules.ts";
 import { applyRequestRules, loadRequestRules, type ProviderRequestEvent } from "../../src/agent-request-rules.ts";
+import { nicknamePrompt, PROFILE_TIMEOUT_MS, readPromptProfile, type PromptProfile } from "../../src/profile-prompt.ts";
 
 // The pinned runtime supplies this SDK surface, just as it does for model-control.ts.
 type Entry = { id: string; type: string; customType?: string; data?: unknown; message?: { role: string; content: unknown; toolName?: string; details?: unknown; toolCallId?: string } };
@@ -107,21 +108,11 @@ function gatewayBase(): string {
 }
 
 export const DEFAULT_AGENT_NAME = "지그";
-export const AGENT_NAME_TIMEOUT_MS = 1_000;
+export const AGENT_NAME_TIMEOUT_MS = PROFILE_TIMEOUT_MS;
 
 /** The agent name the gateway keeps (GET /api/profile, improvement 59); `fallback` when the gateway does not answer. */
 export async function readAgentName(fallback: string): Promise<string> {
-	try {
-		const response = await fetch(new URL("/api/profile", gatewayBase()), { signal: AbortSignal.timeout(AGENT_NAME_TIMEOUT_MS) });
-		if (!response.ok) throw new Error(`profile_http_${response.status}`);
-		const data: unknown = await response.json();
-		const name = record(data) && typeof data.agentName === "string" ? data.agentName.replace(/\s+/g, " ").trim() : "";
-		if (!name) throw new Error("profile_agent_name_missing");
-		return name;
-	} catch (error) {
-		console.warn(`agent name: keeping "${fallback}":`, error instanceof Error ? error.message : String(error));
-		return fallback;
-	}
+	return (await readPromptProfile({ nickname: undefined, agentName: fallback })).agentName;
 }
 
 async function postWork(operation: string, requestKey: string, sourceSessionPath: string, payload: Params, signal: AbortSignal | undefined): Promise<unknown> {
@@ -162,13 +153,14 @@ export default function taskControl(pi: ExtensionApi): void {
 		});
 	}
 
-	// The main reads its name at the start of every turn, so a renamed agent answers to the new name from its next turn.
-	let agentName = DEFAULT_AGENT_NAME;
+	// Read every turn so profile changes also reach already-open main and work sessions.
+	let profile: PromptProfile = { nickname: undefined, agentName: DEFAULT_AGENT_NAME };
 	pi.on("before_agent_start", async (event) => {
-		if (isMain) agentName = await readAgentName(agentName);
+		profile = await readPromptProfile(profile);
+		const agentName = profile.agentName;
 		return { systemPrompt: `${event.systemPrompt}\n\n${isMain
 		? `You are the gateway main assistant. Your name is ${agentName}. The user calls you ${agentName}. ` + "Route project implementation and independent long-running work through zgw_work_start with the intended absolute project cwd; do not implement project changes in the main conversation. Keep short answers and orchestration here. These tools acknowledge durable submission, not execution or completion. Use exact work IDs for follow-up. Never replay unknown delivery automatically. Read reports and publish their results with zgw_work_publish; do not repeat published text. When you cannot answer the user immediately, first call zgw_precomment once with one line saying what you are doing now; skip it when you can answer right away, and never send periodic progress or routine work notices with it. When you need the user's answer or permission to run something, ask with ask_user_question instead of a plain chat question, so it stays open in the inbox until answered or cancelled; state the exact action and scope in the question, and cite the chat message it is about as [참조 #<message seq>] when you know its seq. Only that inbox answer covers the shown question and scope: a chat reply or an attached message reference is never permission by itself. In this main conversation the question never pauses your turn, even with waitForAnswer true: the gateway keeps it open in the inbox and returns at once with a ZGW_QUESTION_OPEN note. The answer arrives later as a ZGW_DECISION_COMMAND user message. Until then, do not take the action that answer decides, and keep handling every other message."
-		: `You own gateway work ${workId}. Read each ZGW_WORK_COMMAND envelope and preserve its command_seq. Execute with the existing permissions and native OMO capabilities. Report progress, questions, and verified outcomes with zgw_work_report. Turn end is not work completion. On cooperative cancel, clean up owned execution and report remaining activity honestly; interrupt alone is not cancellation.`}${rulesText}` };
+		: `You own gateway work ${workId}. Read each ZGW_WORK_COMMAND envelope and preserve its command_seq. Execute with the existing permissions and native OMO capabilities. Report progress, questions, and verified outcomes with zgw_work_report. Turn end is not work completion. On cooperative cancel, clean up owned execution and report remaining activity honestly; interrupt alone is not cancellation.`}${rulesText}\n\n${nicknamePrompt(profile.nickname)}` };
 	}, { previewSafe: true });
 
 	if (isMain) {
@@ -191,6 +183,24 @@ export default function taskControl(pi: ExtensionApi): void {
 		});
 	}
 
+	if (isMain) {
+		pi.registerTool({
+			name: "zgw_agent_list", label: "Agent list",
+			description: "List the user's agents read-only: name, one-line description and the web link of each agent's conversation. Use it to answer which agents exist or to give the user the link to open one. Returns no agent knowledge.",
+			parameters: { type: "object", properties: {}, additionalProperties: false },
+			async execute(_toolCallId, _params, signal) {
+				const token = readFileSync(runtimePaths().omoTokenFile, "utf8").trim();
+				const response = await fetch(new URL("/internal/agent-list", gatewayBase()), {
+					headers: { authorization: `Bearer ${token}` },
+					signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(10_000)]) : AbortSignal.timeout(10_000),
+				});
+				const result: unknown = await response.json();
+				if (!response.ok) throw new Error(`agent_list_http_${response.status}:${JSON.stringify(result)}`);
+				return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+			},
+		});
+	}
+
 	for (const operation of isMain ? ["start", "send", "list", "get", "cancel", "publish", "report"] : ["report"]) {
 		const spec = isMain && operation === "report" ? {
 			fields: { kind: { type: "string", enum: ["question"] }, summary: string, details: {} },

package/host/omo-check/patches/omo-5.1.51-compaction-long-context.patch

@@ -0,0 +1,92 @@
+--- a/@code-yeongyu/senpi/dist/core/agent-session.js
++++ b/@code-yeongyu/senpi/dist/core/agent-session.js
+@@ -65,6 +65,7 @@ import { exportSessionToHtml, renderSessionToHtml, } from "./export-html/index.j
+ import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
+ import { reportExtensionHandlerStall } from "./extension-handler-stall-report.js";
+ import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID } from "./extensions/builtin/anthropic-subscription/account-management.js";
++import { CLAUDE_CODE_DEFAULT_CONTEXT_WINDOW, LEGACY_LONG_CONTEXT_MODEL_IDS } from "./extensions/builtin/anthropic-subscription/context-window.js";
+ import { askUserAnswerDisplayText } from "./extensions/builtin/ask-user/format.js";
+ import { getPromptCachePrewarmUsage } from "./extensions/builtin/cache-keepalive/prewarm-entry.js";
+ import { ModelUsabilityBudgetError, projectModelUsabilityBudget, } from "./extensions/builtin/compaction/model-usability-budget.js";
+@@ -1053,9 +1054,9 @@ export class AgentSession {
+         const usable = (model) => chat.some((entry) => same(entry, model)) && (!available.some((entry) => entry.provider === model.provider) || available.some((entry) => same(entry, model))) &&
+             !this._retryFallback.isProviderSpent(model.provider) &&
+             this._modelRuntime.isFallbackEligible(model.provider);
+-        const fits = (model) => {
+-            const output = Math.min(32768, model.maxTokens > 0 ? model.maxTokens : 32768, Math.floor(model.contextWindow / 2));
+-            return model.contextWindow > 0 && inputTokens + Math.max(settings.reserveTokens, output) <= model.contextWindow;
++        const fits = (model, window = model.contextWindow) => {
++            const output = Math.min(32768, model.maxTokens > 0 ? model.maxTokens : 32768, Math.floor(window / 2));
++            return window > 0 && inputTokens + Math.max(settings.reserveTokens, output) <= window;
+         };
+         if (explicit) {
+             if (typeof override !== "string" || !/^[^/\s]+\/\S+$/.test(override))
+@@ -1080,11 +1081,32 @@ export class AgentSession {
+             model.provider === sessionModel.provider && family.test(model.id)) : [];
+         // Stable sort preserves registry order within the regular and fast Luna groups.
+         preferred.sort((left, right) => Number(/-luna-fast$/.test(left.id)) - Number(/-luna-fast$/.test(right.id)));
+-        const candidates = [...(family?.test(sessionModel.id) ? [sessionModel] : []), ...preferred, sessionModel];
++        // A subscription opens a legacy model's 1M window only with usage credits; a native-1M model needs none.
++        // Subscription order: the newest Sonnet of the catalog, the main model, the other Sonnets newest first, then any
++        // other available model, each within the window it opens without credits. Other providers keep light, then main.
++        const subscription = sessionModel.provider === ANTHROPIC_SUBSCRIPTION_PROVIDER_ID;
++        const creditFreeWindow = (model) => subscription && LEGACY_LONG_CONTEXT_MODEL_IDS.has(model.id) ? Math.min(model.contextWindow, CLAUDE_CODE_DEFAULT_CONTEXT_WINDOW) : model.contextWindow;
++        const version = (model) => {
++            const match = /^claude-sonnet-(\d{1,3})(?:-(\d{1,3}))?(?=-|$)/.exec(model.id);
++            return match ? Number(match[1]) * 1000 + Number(match[2] ?? 0) : 0;
++        };
++        const light = [...(family?.test(sessionModel.id) ? [sessionModel] : []), ...preferred];
++        const sonnets = subscription ? chat.filter((model) => model.provider === sessionModel.provider && family?.test(model.id)).sort((left, right) => version(right) - version(left)) : [];
++        const candidates = subscription ? [...sonnets.slice(0, 1), sessionModel, ...sonnets.slice(1), ...available] : [...light, sessionModel];
++        // A subscription candidate with a recorded summary block yields to the next one; if every fitting
++        // candidate is blocked, the first block is the reported cause.
++        let blocked;
+         for (const candidate of candidates) {
+-            if (candidate.provider === sessionModel.provider && usable(candidate) && fits(candidate))
++            if (candidate.provider === sessionModel.provider && usable(candidate) && fits(candidate, creditFreeWindow(candidate))) {
++                if (subscription && summaryUnavailable(this.sessionManager, candidate)) {
++                    blocked ??= candidate;
++                    continue;
++                }
+                 return admit(candidate);
++            }
+         }
++        if (blocked)
++            return admit(blocked);
+         return fail(usable(sessionModel) ? "context_budget" : "model_unavailable");
+     }
+     _logCompactionModelFallback(override, reason, sessionModel) {
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js
+@@ -252,7 +252,31 @@ export function canStartSummary(context, snapshot) {
+         return true;
+     }
+ }
++/**
++ * Gateway: a summary that a quota or account block stops moves once to the next model the resolver offers.
++ * The failed request recorded its block, so automatic selection skips that model; an explicit model, a model
++ * already tried and every other failure end the run. When every candidate is blocked the first error is thrown.
++ */
+ export async function runExtensionCompaction(context, snapshot, signal, onProgress) {
++    const tried = new Set();
++    let first;
++    for (;;) {
++        let selectedModel;
++        try { ({ selectedModel } = selectSummaryModel(context, snapshot)); }
++        catch (error) { throw first ?? error; }
++        const key = selectedModel.provider + "/" + selectedModel.id;
++        if (tried.has(key))
++            throw first;
++        tried.add(key);
++        try { return await runExtensionCompactionOnce(context, snapshot, signal, onProgress); }
++        catch (error) {
++            if (signal?.aborted || (error?.failure?.kind !== "quota" && error?.failure?.kind !== "account_blocked"))
++                throw error;
++            first ??= error;
++        }
++    }
++}
++async function runExtensionCompactionOnce(context, snapshot, signal, onProgress) {
+     if (signal?.aborted)
+         return undefined;
+     const { prompt, messages, inputTokens, selectedModel } = selectSummaryModel(context, snapshot);