zigmini 0.8.0-beta.4 → 0.8.0-beta.6

package/src/hub.ts

@@ -47,6 +47,14 @@ export interface HubOptions {
 	media?: { dir: string; hostDir?: string };
 	now?: () => number;
 	rotation?: { maxAgeMs?: number; idleMs?: number; forceMaxBytes?: number; forceUpdateCompactions?: number };
+	/** Bug 152: bounded native ownership reconciliation; timers are injectable for deterministic tests. */
+	closeRecovery?: {
+		intervalMs?: number;
+		maxAttempts?: number;
+		timeoutMs?: number;
+		setTimeout?: (callback: () => void, ms: number) => ReturnType<typeof setTimeout>;
+		clearTimeout?: (timer: ReturnType<typeof setTimeout>) => void;
+	};
 	/** Answers `/version` as a notice; the command never reaches omo. */
 	versionReport?: () => Promise<string>;
 	/** Answers `/usage` (model account usage) as a notice; the command never reaches omo. */
@@ -89,6 +97,7 @@ export interface RotationStatus {
 	/** First sweep that found it held in this gateway run; null when not held or not yet swept. */
 	readonly blockedSince: string | null;
 	readonly blockers: readonly RotationBlocker[];
+	readonly closeRecovery?: { readonly state: "recovering" | "exhausted"; readonly attempts: number; readonly maxAttempts: number };
 }
 
 /** omo writes a new session file with its first entry; until then the session has no size. */
@@ -120,6 +129,23 @@ interface OpenResult {
 	streaming: boolean;
 }
 
+interface CloseRecovery {
+	attempts: number;
+	exhausted: boolean;
+	timer?: ReturnType<typeof setTimeout>;
+	flight?: Promise<void>;
+	cancel?: () => void;
+}
+
+interface SessionRetirement {
+	sessionId: string;
+	sessionPath: string;
+	from: string | null;
+	reason: RotationReason;
+	handoff: string;
+	closeAcknowledged?: boolean;
+}
+
 export interface SlashCommand {
 	name: string;
 	description: string;
@@ -230,7 +256,7 @@ export const MAIN_QUESTION_RELEASED =
 const PERMISSION_PREFIX = "Permission required:";
 const AUTO_CONTINUE_LIMIT = 2;
 const CONTINUE_PROMPT =
-	"[게이트웨이 알림] 게이트웨이나 omo가 재시작되면서 이전 작업이 중간에 끊겼습니다. 세션 기록에서 마지막으로 한 일을 확인하고, 이미 끝난 단계는 반복하지 말고 끊긴 지점부터 이어서 마무리해 주세요.";
+	"[게이트웨이 알림] 게이트웨이나 엔진이 재시작되면서 이전 작업이 중간에 끊겼습니다. 세션 기록에서 마지막으로 한 일을 확인하고, 이미 끝난 단계는 반복하지 말고 끊긴 지점부터 이어서 마무리해 주세요.";
 
 /** A model as omo reports it (get_available_models / get_state); only the fields the gateway uses. */
 interface OmoModel {
@@ -274,6 +300,7 @@ export class Hub {
 	private readonly questions = new Map<string, QuestionCard>();
 	private readonly rotationHeld = new Map<string, { since: number; logged: boolean }>();
 	private readonly rotationFailures = new Map<string, { message: string; at: number }>();
+	private readonly closeRecoveries = new Map<string, CloseRecovery>();
 	private readonly legacyQuestionHistoryAliases = new Map<string, string>();
 	private readonly uiOwners = new Map<string, ScopedUiOwner>();
 	private readonly uiSessionScopes = new Map<string, string>();
@@ -668,6 +695,11 @@ export class Hub {
 		this.eventCount += 1;
 		if (status !== "ready") {
 			this.generation += 1;
+			for (const recovery of this.closeRecoveries.values()) {
+				if (recovery.timer !== undefined) this.clearCloseTimer(recovery.timer);
+				recovery.cancel?.();
+			}
+			this.closeRecoveries.clear();
 			this.sessionToConv.clear();
 			for (const owner of this.uiOwners.values()) this.decisions?.release(owner);
 			this.uiOwners.clear();
@@ -681,7 +713,7 @@ export class Hub {
 				rt.wake = null;
 				rt.notified.clear();
 				const scope = this.conversationScope(conv);
-				this.dialogs.cancelScope(scope, "omo 연결이 끊겼습니다.");
+				this.dialogs.cancelScope(scope, "엔진 연결이 끊겼습니다.");
 				for (const [id, card] of this.questions) {
 					if (card.scope !== scope) continue;
 					this.questions.delete(id);
@@ -709,17 +741,22 @@ export class Hub {
 		for (const conv of conversations) {
 			if (this.omoStatus !== "ready" || generation !== this.generation) return;
 			try {
+				if (this.closeUncertain(conv.id)) {
+					await this.reconcileClose(conv.id);
+					if (this.closeUncertain(conv.id) || generation !== this.generation) continue;
+				}
+				const current = this.store.getConversation(conv.id) ?? conv;
 				const pendingUsers = this.store.pendingMainUsers(conv.id);
 				if (pendingUsers.length > 0) {
-					await this.ensureSession(conv);
+					await this.ensureSession(current);
 					for (const user of pendingUsers) {
 						const data = user.data as { text: string; images?: string[]; references?: MessageReference[] };
 						const input = referencedInput(data.text, data.images ?? [], data.references);
 						await this.prompt(conv.id, input.text, input.images, user.seq, true);
 					}
-				} else if (this.hasUnfinishedTurn(conv.id)) await this.recoverConversation(conv);
-				else if (this.openQuestionCards(conv.id, this.conversationScope(conv.id)).size > 0) await this.ensureSession(conv);
-				else if (this.store.unreportedWorkUpdates(conv.id).length > 0 || this.workSummary(conv.id).length > 0) await this.ensureSession(conv);
+				} else if (this.hasUnfinishedTurn(conv.id)) await this.recoverConversation(current);
+				else if (this.openQuestionCards(conv.id, this.conversationScope(conv.id)).size > 0) await this.ensureSession(current);
+				else if (this.store.unreportedWorkUpdates(conv.id).length > 0 || this.workSummary(conv.id).length > 0) await this.ensureSession(current);
 				// Opening main comes first. A notification ACK or worker reconciliation cannot hold readiness.
 				void this.notifyWorkUpdates(conv.id);
 			} catch (error) {
@@ -763,7 +800,13 @@ export class Hub {
 		this.decisions?.refresh();
 		const rotationDone = this.rt(convId).rotationDone;
 		if (rotationDone) await rotationDone;
-		if (this.closeUncertain(convId)) throw new Error("session_close_unknown");
+		if (this.closeUncertain(convId)) {
+			if (this.closeRecoveries.get(convId)?.exhausted) throw new Error("session_close_recovery_exhausted");
+			this.scheduleCloseRecovery(convId);
+			this.emit(convId, "notice", { kind: "session-close-recovery", level: "info",
+				message: "세션 닫기 상태를 확인하고 있습니다. 메시지는 확인 후 전달합니다." });
+			return;
+		}
 		await this.prompt(convId, prompt.text, prompt.images, input.seq, true);
 	}
 
@@ -998,7 +1041,7 @@ export class Hub {
 						&& (event.data as { input_seq?: number }).input_seq === input.seq).at(-1);
 					if ((previous?.data as { kind?: string } | undefined)?.kind !== kind) this.emit(conv, "notice", {
 						kind, input_seq: input.seq, level: "warning",
-						message: queued ? "메시지가 OMO 대기열에 남아 있습니다. 자동 재전송하지 않습니다."
+						message: queued ? "메시지가 엔진 대기열에 남아 있습니다. 자동 재전송하지 않습니다."
 							: "메시지의 실행 소비를 확인하지 못했습니다. 기록을 보존하며 자동 재전송하지 않습니다.",
 					});
 					if (queued && data.native_identity && rt.atomicQueuedResume && state &&
@@ -1129,49 +1172,31 @@ export class Hub {
 			}
 			// Any rotation hands main's open waits of the closed session to the next one (inbox resume); bug 72.
 			this.retireScopedQuestions(convId, sessionId);
+			const retirement: SessionRetirement = {
+				sessionId, sessionPath: source, from, reason,
+				handoff: this.buildHandoff(convId, reason, source, handoffThrough),
+			};
+			let closeAcknowledged = false;
 			try {
 				await this.requireOmo().command("close_session", { sessionId });
-				const listed = await this.requireOmo().command<{
-					sessions?: { sessionId?: string; sessionPath?: string }[];
-				}>("list_sessions", { include_all: true, include_workers: true });
+				closeAcknowledged = true;
+				const listed = await this.requireOmo().command("list_sessions", { include_all: true, include_workers: true });
 				if (
-					generation !== this.generation || this.omoStatus !== "ready" || !Array.isArray(listed.sessions) ||
-					listed.sessions.some(
-						(entry) =>
-							!entry ||
-							typeof entry.sessionId !== "string" ||
-							typeof entry.sessionPath !== "string" ||
-							entry.sessionId === sessionId ||
-							entry.sessionPath === source,
-					)
+					generation !== this.generation || this.omoStatus !== "ready" ||
+					this.targetSessionPresent(listed, sessionId, source)
 				) {
 					throw new Error("session_retirement_unconfirmed");
 				}
 			} catch (error) {
 				this.emit(convId, "session.close.unknown", {
-					sessionPath: source,
-					sessionId,
+					...retirement,
+					closeAcknowledged,
 					message: errorMessage(error),
 				});
+				this.scheduleCloseRecovery(convId);
 				throw error;
 			}
-			const owner = this.ownerForConversation(convId, sessionId);
-			this.sessionToConv.delete(sessionId);
-			if (owner) this.releaseScopedUiOwner(owner);
-			rt.sessionId = null;
-			rt.itemId = null;
-			rt.itemText = "";
-			rt.notified.clear();
-			const to = `${this.options.sessionDir.replace(/\/$/, "")}/zgw-${conv.id}-${fileStamp(this.now())}-${crypto.randomUUID().slice(0, 8)}.jsonl`;
-			const handoff = this.buildHandoff(convId, reason, source, handoffThrough);
-			this.store.rotateThread(convId, to, new Date(this.now()).toISOString(), handoff);
-			this.emit(convId, "conversation.thread", { threadId: to });
-			this.emit(convId, "session.rotated", { reason, from, to });
-			this.emit(convId, "notice", {
-				kind: "session-rotated",
-				level: "info",
-				message: `새 omo 세션으로 교체했습니다 (${this.reasonLabel(reason)}). 화면의 대화 기록은 그대로이고, 다음 메시지부터 새 세션에서 이어집니다.`,
-			});
+			this.finishRetirement(convId, retirement);
 			return this.store.getConversation(convId) ?? conv;
 		} finally {
 			rt.rotating = false;
@@ -1187,7 +1212,120 @@ export class Hub {
 	}
 
 	private closeUncertain(conv: string): boolean {
-		return this.store.lastSeq(conv, "session.close.unknown") > this.store.lastSeq(conv, "session.rotated");
+		return this.store.lastSeq(conv, "session.close.unknown") >
+			Math.max(this.store.lastSeq(conv, "session.rotated"), this.store.lastSeq(conv, "session.close.resolved"));
+	}
+
+	/** A valid native inventory proves absence by target identity, not by the shape of unrelated worker entries. */
+	private targetSessionPresent(listed: unknown, sessionId: string, sessionPath: string): boolean {
+		if (typeof listed !== "object" || listed === null || !("sessions" in listed) || !Array.isArray(listed.sessions)) {
+			throw new Error("session_list_invalid");
+		}
+		return listed.sessions.some((entry: unknown) => typeof entry === "object" && entry !== null &&
+			(("sessionId" in entry && entry.sessionId === sessionId) || ("sessionPath" in entry && entry.sessionPath === sessionPath)));
+	}
+
+	private finishRetirement(convId: string, retirement: SessionRetirement): void {
+		const rt = this.rt(convId);
+		const owner = this.ownerForConversation(convId, retirement.sessionId);
+		this.sessionToConv.delete(retirement.sessionId);
+		if (owner) this.releaseScopedUiOwner(owner);
+		rt.sessionId = null;
+		rt.itemId = null;
+		rt.itemText = "";
+		rt.notified.clear();
+		const to = `${this.options.sessionDir.replace(/\/$/, "")}/zgw-${convId}-${fileStamp(this.now())}-${crypto.randomUUID().slice(0, 8)}.jsonl`;
+		this.store.rotateThread(convId, to, new Date(this.now()).toISOString(), retirement.handoff);
+		this.emit(convId, "conversation.thread", { threadId: to });
+		this.emit(convId, "session.rotated", { reason: retirement.reason, from: retirement.from, to });
+		this.emit(convId, "notice", { kind: "session-rotated", level: "info",
+			message: `새 엔진 세션으로 교체했습니다 (${this.reasonLabel(retirement.reason)}). 화면의 대화 기록은 그대로이고, 다음 메시지부터 새 세션에서 이어집니다.` });
+	}
+
+	private closeTimer(callback: () => void, ms: number): ReturnType<typeof setTimeout> {
+		const schedule = this.options.closeRecovery?.setTimeout;
+		return schedule ? schedule(callback, ms) : setTimeout(callback, ms);
+	}
+
+	private clearCloseTimer(timer: ReturnType<typeof setTimeout>): void {
+		(this.options.closeRecovery?.clearTimeout ?? clearTimeout)(timer);
+	}
+
+	private scheduleCloseRecovery(convId: string): void {
+		if (this.omoStatus !== "ready" || !this.closeUncertain(convId)) return;
+		const recovery = this.closeRecoveries.get(convId) ?? { attempts: 0, exhausted: false };
+		this.closeRecoveries.set(convId, recovery);
+		if (recovery.exhausted || recovery.timer !== undefined || recovery.flight) return;
+		recovery.timer = this.closeTimer(() => {
+			recovery.timer = undefined;
+			return this.reconcileClose(convId).then(() => {
+				if (this.omoStatus === "ready" && !this.closeUncertain(convId)) return this.recover();
+			});
+		}, this.options.closeRecovery?.intervalMs ?? 5_000);
+	}
+
+	/** Never re-close an uncertain native or send to it before a fresh inventory establishes ownership. */
+	private reconcileClose(convId: string): Promise<void> {
+		const recovery = this.closeRecoveries.get(convId) ?? { attempts: 0, exhausted: false };
+		this.closeRecoveries.set(convId, recovery);
+		if (recovery.flight) return recovery.flight;
+		if (recovery.exhausted || this.omoStatus !== "ready" || this.rt(convId).rotating) return Promise.resolve();
+		if (recovery.timer !== undefined) this.clearCloseTimer(recovery.timer);
+		recovery.timer = undefined;
+		const generation = this.generation;
+		const event = this.store.getEvent(this.store.lastSeq(convId, "session.close.unknown"));
+		if (!event || !this.closeUncertain(convId)) return Promise.resolve();
+		recovery.attempts += 1;
+		recovery.flight = (async () => {
+			let timeout: ReturnType<typeof setTimeout> | undefined;
+			try {
+				const cancelled = new Promise<never>((_resolve, reject) => {
+					recovery.cancel = () => reject(new Error("session_close_recovery_disconnected"));
+					timeout = this.closeTimer(() => reject(new Error("session_close_verification_timeout")),
+						this.options.closeRecovery?.timeoutMs ?? 10_000);
+				});
+				const listed = await Promise.race([
+					this.requireOmo().command("list_sessions", { include_all: true, include_workers: true }), cancelled,
+				]);
+				if (generation !== this.generation || this.omoStatus !== "ready") return;
+				const data = event.data as Partial<SessionRetirement>;
+				if (typeof data.sessionId !== "string" || typeof data.sessionPath !== "string") throw new Error("session_close_identity_missing");
+				const present = this.targetSessionPresent(listed, data.sessionId, data.sessionPath);
+				const current = this.store.getConversation(convId);
+				if (current?.threadId === data.sessionPath && !present) {
+					const reason = data.reason ?? "manual";
+					this.finishRetirement(convId, { sessionId: data.sessionId, sessionPath: data.sessionPath, from: data.from ?? data.sessionPath,
+						reason, handoff: data.handoff ?? this.buildHandoff(convId, reason, data.sessionPath, event.seq - 1) });
+				} else {
+					// A successful close releases this connection even when another attachment keeps the native alive.
+					// Reopen that source before sending again; a rejected close must not duplicate a still-owned attachment.
+					if (present && data.closeAcknowledged && current?.threadId === data.sessionPath) {
+						this.sessionToConv.delete(data.sessionId);
+						this.rt(convId).sessionId = null;
+					} else if (present && this.rt(convId).sessionId === data.sessionId && current?.threadId === data.sessionPath) {
+						// The rejected close kept its trusted open_session attachment; restore the UI authority retired above.
+						this.bindScopedUiOwner({ conv: convId, scope: this.conversationScope(convId), sessionId: data.sessionId, sessionPath: data.sessionPath });
+					}
+					this.emit(convId, "session.close.resolved", { sessionId: data.sessionId, sessionPath: data.sessionPath,
+						outcome: present ? "retained" : "superseded", attempts: recovery.attempts });
+					this.emit(convId, "notice", { kind: "session-close-resolved", level: "info",
+						message: "세션 닫기 상태를 확인했습니다. 기존 대화에서 메시지 처리를 계속합니다." });
+				}
+				this.closeRecoveries.delete(convId);
+			} catch (error) {
+				if (generation !== this.generation) return;
+				if (recovery.attempts >= (this.options.closeRecovery?.maxAttempts ?? 3)) {
+					recovery.exhausted = true;
+					this.emit(convId, "error", { message: `session_close_recovery_exhausted: ${errorMessage(error)}. 메시지는 보관 중입니다. 엔진 연결과 세션 목록을 확인한 뒤 게이트웨이를 다시 시작하세요.` });
+				}
+			} finally {
+				if (timeout !== undefined) this.clearCloseTimer(timeout);
+				recovery.cancel = undefined;
+				recovery.flight = undefined;
+				if (generation === this.generation && this.closeUncertain(convId)) this.scheduleCloseRecovery(convId);
+			}
+		})();
+		return recovery.flight;
 	}
 
 	private rotationBlocked(conv: string, inboxDecisions = true): boolean {
@@ -1255,7 +1393,10 @@ export class Hub {
 			if (!conv.threadId?.startsWith("/")) continue;
 			const blockers = this.rotationHolds(conv.id);
 			const held = blockers.length > 0 ? this.rotationHeld.get(conv.id) : undefined;
-			status[conv.id] = { blocked: blockers.length > 0, blockedSince: held ? new Date(held.since).toISOString() : null, blockers };
+			const recovery = this.closeRecoveries.get(conv.id);
+			status[conv.id] = { blocked: blockers.length > 0, blockedSince: held ? new Date(held.since).toISOString() : null, blockers,
+				...(recovery ? { closeRecovery: { state: recovery.exhausted ? "exhausted" as const : "recovering" as const,
+					attempts: recovery.attempts, maxAttempts: this.options.closeRecovery?.maxAttempts ?? 3 } } : {}) };
 		}
 		return status;
 	}
@@ -1396,7 +1537,7 @@ export class Hub {
 			lines.unshift(line);
 		}
 		return [
-			`[게이트웨이 알림] 이 대화는 새 omo 세션으로 교체됐습니다 (${this.reasonLabel(reason)}).`,
+			`[게이트웨이 알림] 이 대화는 새 엔진 세션으로 교체됐습니다 (${this.reasonLabel(reason)}).`,
 			from ? `이전 세션의 전체 기록은 ${from} 에 남아 있습니다. 파일이 크니 필요할 때 필요한 부분만 검색해서 보세요.` : "",
 			...this.handoffOpenItems(conv),
 			"아래는 직전 대화의 최근 부분입니다. 맥락으로만 참고하세요.",
@@ -1466,7 +1607,7 @@ export class Hub {
 		if (!CONTEXT_OVERFLOW.test(message)) return { message };
 		return {
 			kind: "continuity-protected",
-			message: `${message}. 같은 omo 세션을 유지합니다. 원인을 해결한 뒤 계속할 지시를 보내 주세요. 이전 입력은 자동 재전송하지 않습니다.`,
+			message: `${message}. 같은 엔진 세션을 유지합니다. 원인을 해결한 뒤 계속할 지시를 보내 주세요. 이전 입력은 자동 재전송하지 않습니다.`,
 		};
 	}
 

package/src/main.ts

@@ -44,7 +44,7 @@ import { activeRecord, readRegistry, slotUrl } from "./runtime/slots.ts";
 import { NATIVE_LIFECYCLE_PREFIX } from "./omo/lifecycle.ts";
 import { RECOVERY_RECEIPT_PREFIX } from "./omo/recovery-receipt.ts";
 import { fileScheduleSource, notionRoutineSource, ReminderLoop } from "./schedule/reminders.ts";
-import { type ClientMessage, type Envelope, PROTOCOL_VERSION, type Source } from "./protocol.ts";
+import { type ClientMessage, type Envelope, PROTOCOL_VERSION, ROTATION_HELD_MESSAGE, type Source } from "./protocol.ts";
 import { QuestionNotifications } from "./question-notifications.ts";
 import { DecisionStoreError, Store } from "./store.ts";
 import { TranscriptLog } from "./transcript.ts";
@@ -475,7 +475,7 @@ async function handleClient(ws: ServerWebSocket<Conn>, raw: string): Promise<voi
 			return;
 		case "conversation.rotate":
 			await hub.rotateSession(msg.conv, "manual").catch((e) => {
-				const message = e instanceof Error && e.message === "turn_running" ? "진행 중이거나 확인되지 않은 작업이 있어 같은 세션을 유지합니다." : String(e);
+				const message = e instanceof Error && e.message === "turn_running" ? ROTATION_HELD_MESSAGE : String(e);
 				ws.send(envelope("error", { message }, msg.conv));
 			});
 			return;

package/src/omo-check.ts

@@ -45,8 +45,8 @@ export class OmoCheckScheduler {
 		const version = body.version;
 		const result = this.store.createOmoCheck(version, {
 			ownerConv: "main",
-			title: `OMO ${version} 검증`,
-			goal: `OMO ${version} 후보 패치와 교체 가능 여부 검증 (운영 교체 금지)`,
+			title: `엔진 ${version} 검증`,
+			goal: `엔진 ${version} 후보 패치와 교체 가능 여부 검증 (운영 교체 금지)`,
 			cwd: this.options.cwd,
 			sessionPath: join(this.options.sessionDir, `zgw-omo-check-${version}.jsonl`),
 			requestKey: `omo-check:${version}`,

package/src/protocol.ts

@@ -1,5 +1,8 @@
 export const PROTOCOL_VERSION = 1;
 
+/** The `error` message a refused `conversation.rotate` gets when a turn or an open wait holds the session (hub `turn_running`). */
+export const ROTATION_HELD_MESSAGE = "진행 중이거나 확인되지 않은 작업이 있어 같은 세션을 유지합니다.";
+
 export type Channel = "web" | "app" | "home" | "hud" | "discord";
 export type Trust = "owner" | "owner-voice" | "unknown";
 

package/src/transcript.ts

@@ -62,7 +62,7 @@ export function toRecord(type: string, data: unknown, base: { ts: string; conv:
 	if (type === "message.user" && typeof d.text === "string") return { ...base, role: "user", text: d.text, src: d.src, trust: d.trust };
 	if (type === "message.final" && typeof d.text === "string") return { ...base, role: "assistant", text: d.text };
 	if (type === "session.rotated") {
-		return { ...base, role: "system", event: "session.rotated", text: `omo 세션 교체 (${String(d.reason)}): ${String(d.from)} -> ${String(d.to)}` };
+		return { ...base, role: "system", event: "session.rotated", text: `엔진 세션 교체 (${String(d.reason)}): ${String(d.from)} -> ${String(d.to)}` };
 	}
 	return null;
 }

package/src/update/handoff.ts

@@ -59,7 +59,7 @@ export const POLL_MS = 1000;
 
 export type HandoffResult = "promoted" | "untouched_failure" | "failure";
 
-const NOT_UP = `${BRIDGE_START_WAIT_MS / 1000}초 안에 OMO가 뜨지 않았습니다`;
+const NOT_UP = `${BRIDGE_START_WAIT_MS / 1000}초 안에 엔진이 뜨지 않았습니다`;
 
 function legacyRegistry(port: number, version: string, now: number): SlotRegistry {
 	return { schema: 1, slots: [{ slot: "a", state: "active", port, version, snapshot: null, engine: null, since: new Date(now).toISOString() }] };

package/src/usage.ts

@@ -279,7 +279,7 @@ function stamp(ms: number, timeZone: string | undefined): string {
 	return `${part("month")}/${part("day")} ${part("hour")}:${part("minute")}`;
 }
 
-const STATUS_TEXT = { expired: "토큰 만료 (OMO가 다음 사용 때 갱신)", unsupported: "사용량 API 없음" } as const;
+const STATUS_TEXT = { expired: "토큰 만료 (엔진이 다음 사용 때 갱신)", unsupported: "사용량 API 없음" } as const;
 
 export function formatUsageReport(rows: readonly UsageRow[], timeZone?: string): string {
 	if (rows.length === 0) return "계정 사용량\n로그인한 모델 계정이 없습니다.";

package/src/version.ts

@@ -3,7 +3,7 @@ import { CORE_NAME, ENGINE_PACKAGE, PLUGIN, OMO_REGISTRY_URL, readEnginePin, for
 export { OMO_REGISTRY_URL } from "./engine/index.ts";
 
 /** `/version`: the gateway answers it with a notice and never forwards it to omo. */
-export const VERSION_COMMAND = { name: "version", description: "게이트웨이·OMO 버전 보기 (게이트웨이가 바로 답함)", source: "extension" };
+export const VERSION_COMMAND = { name: "version", description: "게이트웨이·엔진 버전 보기 (게이트웨이가 바로 답함)", source: "extension" };
 
 export function isVersionCommand(text: string): boolean {
 	return /^\/version$/i.test(text.trim());
@@ -104,22 +104,22 @@ export function formatVersionReport(facts: VersionFacts): string {
 	const build = facts.gateway.build ? `빌드 커밋 ${facts.gateway.build}` : "빌드 커밋 알 수 없음";
 	lines.push(`· 게이트웨이: ${facts.gateway.version ?? "알 수 없음"} (${build})`);
 	const pin = facts.pin?.omo
-		? ` · 저장소 고정 omo ${formatEnginePin(facts.pin)}`
+		? ` · 저장소 고정 엔진 ${formatEnginePin(facts.pin)}`
 		: " · 저장소 고정 버전 읽기 실패";
 	let running: string | null = null;
-	if (!facts.omo) lines.push(`· 게이트웨이 OMO: 확인 실패 (OMO 연결 상태 ${facts.omoStatus})${pin}`);
+	if (!facts.omo) lines.push(`· 엔진: 확인 실패 (엔진 연결 상태 ${facts.omoStatus})${pin}`);
 	else {
 		running = facts.omo.install;
 		const engine = facts.omo.engine ? ` (${CORE_NAME} ${facts.omo.engine})` : "";
-		lines.push(`· 게이트웨이 OMO: ${facts.omo.install ?? "설치 경로 확인 실패"}${engine}${pin}`);
+		lines.push(`· 엔진: ${facts.omo.install ?? "설치 경로 확인 실패"}${engine}${pin}`);
 	}
 	if ("version" in facts.latest) {
-		lines.push(`· 최신 OMO: ${facts.latest.version} (npm ${ENGINE_PACKAGE})`);
+		lines.push(`· 최신 엔진: ${facts.latest.version} (npm ${ENGINE_PACKAGE})`);
 		const current = running ?? facts.pin?.omo ?? null;
 		if (current && isNewer(facts.latest.version, current)) {
 			lines.push(`업데이트 가능: ${current} → ${facts.latest.version} (자동으로 업데이트하지 않습니다)`);
 		}
-	} else lines.push(`· 최신 OMO: 확인 실패 (${facts.latest.error})`);
+	} else lines.push(`· 최신 엔진: 확인 실패 (${facts.latest.error})`);
 	return lines.join("\n");
 }