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

package/src/hub.ts

@@ -11,13 +11,24 @@ import { type TranscriptLog, toRecord } from "./transcript.ts";
 import { MaintenanceError, nativeMaintenanceBlocker } from "./maintenance.ts";
 import { isVersionCommand, VERSION_COMMAND } from "./version.ts";
 import { isUsageCommand, USAGE_COMMAND } from "./usage.ts";
+import { COMPACT_COMMAND, compactInstructions } from "./compact.ts";
 import { MessageReferenceError, referencedInput, resolveMessageReferences } from "./message-references.ts";
 import { readProfile } from "./profile.ts";
-import type { MessageGuard } from "./security-check.ts";
+import type { MessageGuard, SecurityChecker } from "./security-check.ts";
 import { SecurityRuntimeError, type SecurityReceipt } from "./security-allow.ts";
 import { nativeReplyEntry, type NativeReplyObserver } from "./reply-notifications.ts";
 import { notificationHistory } from "./notification-history.ts";
 import { messageTimestamp, nativeTurnStarted, nativeTurnStats } from "./turn-stats.ts";
+import { join } from "node:path";
+import { mergeAgentDefinition, AgentDefinitionError, type MergedAgentDefinition } from "./agent/definition.ts";
+import { AgentFileStore } from "./agent/files.ts";
+import { type Language, say, serverLanguage, type Text, textIn } from "./server-text.ts";
+
+class AgentSessionError extends Error {
+	constructor() {
+		super("agent_definition_invalid");
+	}
+}
 
 export type Broadcast = (envelope: Envelope) => void;
 
@@ -41,6 +52,7 @@ const HISTORY_MAX_RESUME = 1000;
 
 export interface HubOptions {
 	replies?: NativeReplyObserver;
+	agents?: AgentFileStore;
 	cwd: string;
 	sessionDir: string;
 	permissionPreset: string;
@@ -52,7 +64,7 @@ export interface HubOptions {
 	/** Where attached images live (`dir`, as this process sees it) and the same folder's path on the Mac, for the agent. */
 	media?: { dir: string; hostDir?: string };
 	now?: () => number;
-	rotation?: { maxAgeMs?: number; idleMs?: number; forceMaxBytes?: number; forceUpdateCompactions?: number };
+	rotation?: { maxAgeMs?: number; idleMs?: number; forceMaxBytes?: number; forceUpdateCompactions?: number; freshSessionCompactionFailures?: number };
 	/** Bug 152: bounded native ownership reconciliation; timers are injectable for deterministic tests. */
 	closeRecovery?: {
 		intervalMs?: number;
@@ -74,22 +86,91 @@ const PROMPT_IMAGE_MAX_BYTES = 5 * 1024 * 1024;
 const MAX_ATTACHMENTS = 4;
 
 const COMPACTION_RECOVERY = {
-	invalid_model: { action: "settings", message: "요약 모델 설정을 확인하거나 compaction.model을 auto로 바꾼 뒤 다시 진행해 주세요." },
-	auth_missing: { action: "login", message: "요약에 사용하는 제공자에 로그인한 뒤 다시 진행해 주세요." },
-	auth_expired: { action: "login", message: "요약에 사용하는 제공자에 다시 로그인한 뒤 다시 진행해 주세요." },
-	quota: { action: "quota", message: "제공자의 사용 한도가 복구된 뒤 다시 진행해 주세요." },
-	org_denied: { action: "account", message: "해당 제공자의 계정과 조직 권한을 확인한 뒤 다시 진행해 주세요." },
-	model_unavailable: { action: "settings", message: "요약 모델의 사용 가능 여부와 설정을 확인한 뒤 다시 진행해 주세요." },
-	refused: { action: "retry", message: "제공자가 요약을 거절했습니다. 원인을 해결한 뒤 다시 진행해 주세요." },
-	timeout: { action: "retry", message: "요약 요청 시간이 초과됐습니다. 원인을 해결한 뒤 다시 진행해 주세요." },
-	incomplete: { action: "retry", message: "요약 응답이 완전하지 않습니다. 원인을 해결한 뒤 다시 진행해 주세요." },
-	empty: { action: "retry", message: "요약 응답이 비어 있습니다. 원인을 해결한 뒤 다시 진행해 주세요." },
-	context_budget: { action: "retry", message: "요약 결과가 대화 모델의 입력 한도에 맞지 않습니다. 원인을 해결한 뒤 다시 진행해 주세요." },
-	stale: { action: "retry", message: "요약 중 대화가 바뀌었습니다. 최신 대화에서 다시 진행해 주세요." },
-	provider: { action: "retry", message: "원인을 해결한 뒤 다시 진행해 주세요." },
-} as const satisfies Record<CompactionFailureKind, { readonly action: string; readonly message: string }>;
-
-export type RotationReason = "manual" | "age" | ForcedRotationReason;
+	invalid_model: { action: "settings", message: { en: "Check the summary model setting or change compaction.model to auto, then try again.", ko: "요약 모델 설정을 확인하거나 compaction.model을 auto로 바꾼 뒤 다시 진행해 주세요." } },
+	auth_missing: { action: "login", message: { en: "Sign in to the provider used for summaries, then try again.", ko: "요약에 사용하는 제공자에 로그인한 뒤 다시 진행해 주세요." } },
+	auth_expired: { action: "login", message: { en: "Sign in again to the provider used for summaries, then try again.", ko: "요약에 사용하는 제공자에 다시 로그인한 뒤 다시 진행해 주세요." } },
+	quota: { action: "quota", message: { en: "Try again after the provider's usage limit resets.", ko: "제공자의 사용 한도가 복구된 뒤 다시 진행해 주세요." } },
+	org_denied: { action: "account", message: { en: "Check the provider account and its organization permissions, then try again.", ko: "해당 제공자의 계정과 조직 권한을 확인한 뒤 다시 진행해 주세요." } },
+	model_unavailable: { action: "settings", message: { en: "Check that the summary model is available and its settings are correct, then try again.", ko: "요약 모델의 사용 가능 여부와 설정을 확인한 뒤 다시 진행해 주세요." } },
+	refused: { action: "retry", message: { en: "The provider refused the summary. Fix the cause, then try again.", ko: "제공자가 요약을 거절했습니다. 원인을 해결한 뒤 다시 진행해 주세요." } },
+	timeout: { action: "retry", message: { en: "The summary request timed out. Fix the cause, then try again.", ko: "요약 요청 시간이 초과됐습니다. 원인을 해결한 뒤 다시 진행해 주세요." } },
+	incomplete: { action: "retry", message: { en: "The summary response was incomplete. Fix the cause, then try again.", ko: "요약 응답이 완전하지 않습니다. 원인을 해결한 뒤 다시 진행해 주세요." } },
+	empty: { action: "retry", message: { en: "The summary response was empty. Fix the cause, then try again.", ko: "요약 응답이 비어 있습니다. 원인을 해결한 뒤 다시 진행해 주세요." } },
+	context_budget: { action: "retry", message: { en: "The summary does not fit the chat model's input limit. Fix the cause, then try again.", ko: "요약 결과가 대화 모델의 입력 한도에 맞지 않습니다. 원인을 해결한 뒤 다시 진행해 주세요." } },
+	stale: { action: "retry", message: { en: "The conversation changed during the summary. Try again from the latest conversation.", ko: "요약 중 대화가 바뀌었습니다. 최신 대화에서 다시 진행해 주세요." } },
+	provider: { action: "retry", message: { en: "Fix the cause, then try again.", ko: "원인을 해결한 뒤 다시 진행해 주세요." } },
+	account_blocked: { action: "account", message: { en: "The summary provider's account pool did not send the request. It is not confirmed whether the cause is the usage limit or authentication. Check the account status or choose another model, then try again.", ko: "요약 공급자의 계정 묶음이 요청을 보내지 않았습니다. 원인이 사용 한도인지 인증인지는 확정되지 않았습니다. 계정 상태를 확인하거나 다른 모델을 고른 뒤 다시 진행해 주세요." } },
+} as const satisfies Record<CompactionFailureKind, { readonly action: string; readonly message: Text }>;
+
+/** Improvement 230: why a `/compact` was refused and what to do; a refused `/compact` is never queued. */
+const COMPACT_REFUSED = {
+	engine: { en: "The conversation was not summarized because the engine is not connected. Send /compact again after the connection returns.", ko: "엔진에 연결되지 않아 대화를 요약하지 않았습니다. 연결이 돌아온 뒤 /compact를 다시 보내 주세요." },
+	session: { en: "The conversation was not summarized because the session is being switched. Send /compact again after the switch finishes.", ko: "세션을 교체하고 있어 대화를 요약하지 않았습니다. 교체가 끝난 뒤 /compact를 다시 보내 주세요." },
+	compacting: { en: "The conversation is already being summarized. If needed, send /compact again after the summary finishes.", ko: "이미 대화를 요약하고 있습니다. 요약이 끝난 뒤 필요하면 /compact를 다시 보내 주세요." },
+	retrying: { en: "The conversation was not summarized because a model request is being retried. Send /compact again after the retry finishes.", ko: "모델 요청을 재시도하고 있어 대화를 요약하지 않았습니다. 재시도가 끝난 뒤 /compact를 다시 보내 주세요." },
+	answering: { en: "The conversation was not summarized because an answer is in progress. Send /compact again after the answer finishes.", ko: "답변이 진행 중이라 대화를 요약하지 않았습니다. 답변이 끝난 뒤 /compact를 다시 보내 주세요." },
+} as const satisfies Record<string, Text>;
+/** A compaction failure notice: what failed, then the recovery text of COMPACTION_RECOVERY. */
+const COMPACTION_FAILED: Text = { en: "Could not summarize the conversation. The earlier content was kept. {recovery}",
+	ko: "대화 요약에 실패했습니다. 이전 내용은 유지했습니다. {recovery}" };
+/** Improvement 230: the engine refused `/compact` and no terminal compaction event reported it. */
+function compactNotReported(): string {
+	return say(COMPACTION_FAILED, { recovery: say(COMPACTION_RECOVERY.provider.message) });
+}
+
+/** Bug 223: the longest provider error a compaction failure log line keeps, after its sensitive values are removed. */
+export const COMPACTION_ERROR_MAX_CHARS = 512;
+
+/**
+ * Bug 223: the provider's own error text with every value the repository security check finds (tokens, keys,
+ * credentials, home paths, e-mail, internal addresses, device ids) replaced by [redacted], on one line, at most
+ * COMPACTION_ERROR_MAX_CHARS. The cause wording stays. Values are found before the text is cut.
+ */
+export function sanitizeProviderError(text: unknown, checker: Pick<SecurityChecker, "runtimeOccurrences">): string | null {
+	if (typeof text !== "string") return null;
+	const withoutPrivateKeys = text.replace(/-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY-----[\s\S]*?(?:-----END (?:[A-Z0-9]+ )*PRIVATE KEY-----|$)/g, "[redacted]");
+	const flat = withoutPrivateKeys.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, " ").replace(/\s+/g, " ").trim();
+	if (!flat) return null;
+	const spans = checker.runtimeOccurrences([flat])
+		.map((found) => [found.start ?? 0, found.end ?? flat.length] as const).sort((a, b) => a[0] - b[0]);
+	let kept = "";
+	let at = 0;
+	for (const [start, end] of spans) {
+		if (end <= at) continue;
+		if (start >= at) kept += `${flat.slice(at, start)}[redacted]`;
+		at = end;
+	}
+	kept += flat.slice(at);
+	return kept.length > COMPACTION_ERROR_MAX_CHARS ? `${kept.slice(0, COMPACTION_ERROR_MAX_CHARS)}…` : kept;
+}
+
+/**
+ * Bug 223: the fields of one gateway log line per failed blocking compaction. A provider/model the engine did not list
+ * or a malformed number never reaches the log. The provider error is kept only through sanitizeProviderError;
+ * errorMessage and other free text are never read.
+ */
+export function compactionFailureLog(failureKind: CompactionFailureKind, failure: unknown, knownModels: ReadonlySet<string>,
+	sanitize: (text: unknown) => string | null = () => null): Record<string, unknown> {
+	const fields = typeof failure === "object" && failure !== null ? failure as Record<string, unknown> : {};
+	const provider = typeof fields.provider === "string" ? fields.provider : "";
+	const model = typeof fields.model === "string" ? fields.model : "";
+	const listed = knownModels.has(`${provider}/${model}`);
+	const tokens = fields.inputTokens;
+	const retryAt = fields.retryAt;
+	return {
+		failureKind,
+		provider: listed ? provider : "unknown",
+		model: listed ? model : "unknown",
+		error: sanitize(fields.error) ?? "unknown",
+		inputTokens: typeof tokens === "number" && Number.isSafeInteger(tokens) && tokens >= 0 ? tokens : "unknown",
+		inputTokensSource: fields.inputTokensSource === "estimate" || fields.inputTokensSource === "provider" ? fields.inputTokensSource : "unknown",
+		requestSent: typeof fields.requestSent === "boolean" ? fields.requestSent : "unknown",
+		...(typeof retryAt === "number" && Number.isSafeInteger(retryAt) && retryAt > 0 && retryAt < 8.64e15
+			? { retryAt: new Date(retryAt).toISOString() } : {}),
+	};
+}
+
+export type RotationReason = "manual" | "age" | "compaction_failed" | ForcedRotationReason;
 /** Bug 72 proposal 4: limits that rotate a session even with works, updates, decisions or questions open. */
 export type ForcedRotationReason = "size" | "compactions";
 
@@ -106,6 +187,10 @@ export const ROTATION_HELD_LOG_MS = 6 * 60 * 60 * 1000;
 export const ROTATION_RETRY_MS = 30 * 60 * 1000;
 /** Bug 72: completed turns that must carry an unconsumed user input before an idle native releases it from the turn. */
 export const UNCONSUMED_INPUT_RELEASE_TURNS = 2;
+/** Bug 224: the engine's exact refusal of a prompt before accepting it while compaction is unfinished (RequiredCompactionError). */
+export const REQUIRED_COMPACTION_REFUSAL = "Context remains above the compaction threshold because compaction did not complete";
+/** Bug 224 (user decision 2026-10-29): failed compactions in a row of one session that open a fresh session. */
+export const FRESH_SESSION_COMPACTION_FAILURES = 2;
 
 /** Bug 72: one condition that now holds a conversation's session rotation. */
 export interface RotationBlocker {
@@ -147,6 +232,65 @@ function describeBlockers(blockers: readonly RotationBlocker[]): string {
 const HANDOFF_MAX_CHARS = 8000;
 const HANDOFF_LINE_CHARS = 600;
 const CONTEXT_OVERFLOW = /prompt is too long|context overflow/i;
+const COMPACTION_REQUIRED_MESSAGE: Text = {
+	en: "The engine did not receive this message because the conversation summary did not finish. The message stays in the history and will not be sent again automatically. Fix the cause of the summary failure or press 'New session'.",
+	ko: "대화 요약이 끝나지 않아 엔진이 이 메시지를 받지 않았습니다. 메시지는 기록에 남아 있고 자동으로 다시 보내지 않습니다. 요약 실패 원인을 해결하거나 '새 세션'을 눌러 주세요.",
+};
+
+/** Improvement 253: fixed hub text people read in the chat (notices, errors, cancel reasons, labels), chosen by say() when made. */
+export const HUB_TEXT = {
+	newConversation: { en: "New conversation", ko: "새 대화" },
+	engineDisconnected: { en: "The engine connection was lost.", ko: "엔진 연결이 끊겼습니다." },
+	recoveryFailed: { en: "Could not recover the previous work: {error}", ko: "이전 작업 복구 실패: {error}" },
+	closeChecking: { en: "Checking whether the session closed. The message will be delivered after the check.", ko: "세션 닫기 상태를 확인하고 있습니다. 메시지는 확인 후 전달합니다." },
+	workNotifyFailed: { en: "Could not send the work result notification: {error}", ko: "작업 결과 알림 실패: {error}" },
+	workReceiptUnknown: { en: "Could not confirm that the work result notification was received. The result record is kept.", ko: "작업 결과 알림의 수신을 확인하지 못했습니다. 결과 기록은 보존되어 있습니다." },
+	workReconcileFailed: { en: "Could not check the work result notifications: {error}", ko: "작업 결과 알림 대조 실패: {error}" },
+	inputQueued: { en: "The message is still in the engine queue. It will not be sent again automatically.", ko: "메시지가 엔진 대기열에 남아 있습니다. 자동 재전송하지 않습니다." },
+	inputConsumptionUnknown: { en: "Could not confirm that the message was processed. The record is kept, and the message will not be sent again automatically.", ko: "메시지의 실행 소비를 확인하지 못했습니다. 기록을 보존하며 자동 재전송하지 않습니다." },
+	queuedResumeFailed: { en: "Could not confirm that the queued input resumed: {error}", ko: "대기 입력 재개 확인 실패: {error}" },
+	userInputReconcileFailed: { en: "Could not check the user input: {error}", ko: "사용자 입력 대조 실패: {error}" },
+	sessionTransition: { en: "Switching session", ko: "세션 교체 중" },
+	sessionRotated: { en: "Switched to a new engine session ({reason}). The chat history on the screen stays as it is, and the next message continues in the new session.{extra}",
+		ko: "새 엔진 세션으로 교체했습니다 ({reason}). 화면의 대화 기록은 그대로이고, 다음 메시지부터 새 세션에서 이어집니다.{extra}" },
+	rotatedAfterFailure: { en: " The previous session file was kept, and messages the engine did not receive will not be sent again automatically.", ko: " 이전 세션 파일은 그대로 남겨 두었고, 받지 못한 메시지는 자동으로 다시 보내지 않습니다." },
+	closeResolved: { en: "Checked whether the session closed. Messages continue in the existing conversation.", ko: "세션 닫기 상태를 확인했습니다. 기존 대화에서 메시지 처리를 계속합니다." },
+	closeRecoveryExhausted: { en: "session_close_recovery_exhausted: {error}. The message is kept. Check the engine connection and the session list, then restart the gateway.",
+		ko: "session_close_recovery_exhausted: {error}. 메시지는 보관 중입니다. 엔진 연결과 세션 목록을 확인한 뒤 게이트웨이를 다시 시작하세요." },
+	rotationQuestionClosed: { en: "This question was closed by a session switch. If you answer it in the inbox, the answer goes to the new session.", ko: "세션 교체로 닫힌 질문입니다. 받은편지함에서 답하면 새 세션으로 전달됩니다." },
+	continuityProtected: { en: "{message}. The same engine session is kept. Fix the cause, then send an instruction to continue. The earlier input will not be sent again automatically.",
+		ko: "{message}. 같은 엔진 세션을 유지합니다. 원인을 해결한 뒤 계속할 지시를 보내 주세요. 이전 입력은 자동 재전송하지 않습니다." },
+	userStopped: { en: "The user stopped the task.", ko: "사용자가 작업을 중단했습니다." },
+	stopped: { en: "Stopped the task.", ko: "작업을 중단했습니다." },
+	modelResponseError: { en: "Model response error", ko: "모델 응답 오류" },
+	compactionStarted: { en: "Summarizing the conversation. Please wait until it finishes.", ko: "대화 내용을 요약하고 있습니다. 완료될 때까지 기다려 주세요." },
+	compactionCancelled: { en: "Cancelled the conversation summary. The earlier content and the same session are kept. The earlier input will not be sent again automatically.",
+		ko: "대화 요약을 취소했습니다. 이전 내용과 같은 세션을 유지합니다. 이전 입력은 자동으로 다시 보내지 않습니다." },
+	compactionCompleted: { en: "Finished summarizing the conversation. Continuing in the same session.", ko: "대화 요약을 완료했습니다. 같은 세션에서 계속합니다." },
+	turnEnded: { en: "The task finished.", ko: "작업이 끝났습니다." },
+	permissionTitle: { en: "Permission request: {tool}", ko: "권한 요청: {tool}" },
+	endedWhileOff: { en: "This question ended while the gateway was off.", ko: "게이트웨이가 꺼져 있던 동안 끝난 질문입니다." },
+	reattached: { en: "The gateway reconnected and continues to receive the work in progress.{recovered}", ko: "게이트웨이가 다시 연결돼 진행 중인 작업을 이어서 받습니다.{recovered}" },
+	sendReceiptUnknown: { en: "Could not confirm that the message was received after it was sent. To avoid running it twice, it will not be sent again automatically.",
+		ko: "메시지 전송 이후 수신을 확인하지 못했습니다. 중복 실행을 피하기 위해 자동 재전송하지 않습니다." },
+	recovered: { en: "Fetched the work results that finished while the gateway was off.{recovered}", ko: "게이트웨이가 꺼져 있던 동안 끝난 작업 결과를 가져왔습니다.{recovered}" },
+	interrupted: { en: "The work was interrupted. It was continued automatically {tries} times but did not finish. Check it, then give the instruction again.",
+		ko: "작업이 끊겨 자동으로 {tries}번 이어 보냈지만 끝나지 않았습니다. 확인 후 다시 지시해 주세요." },
+	autoContinue: { en: "Continuing the work a restart interrupted ({attempt}/{limit}).{recovered}", ko: "재시작으로 끊긴 작업을 이어서 진행합니다 ({attempt}/{limit}).{recovered}" },
+	recoveredOne: { en: " Filled in 1 missed answer.", ko: " 놓친 답변 1개를 채웠습니다." },
+	recoveredMany: { en: " Filled in {count} missed answers.", ko: " 놓친 답변 {count}개를 채웠습니다." },
+	multiSelect: { en: " (multiple choices allowed)", ko: " (여러 개 선택 가능)" },
+	questionUnreachable: { en: "The question window did not reach the web. Press Stop, then answer in the chat.", ko: "질문 창이 웹에 도착하지 않았습니다. 중단 버튼을 누른 뒤 채팅으로 답해 주세요." },
+} as const satisfies Record<string, Text>;
+
+/** Why a session was replaced. The user notice uses the UI language; the engine context keeps the Korean text. */
+const ROTATION_REASON = {
+	size: { en: "the session file reached {mb} MB", ko: "세션 파일이 {mb}MB에 닿음" },
+	compactions: { en: "compaction ran {count} more times", ko: "압축이 {count}번 더 이어짐" },
+	compaction_failed: { en: "the conversation summary failed {count} times in a row", ko: "대화 요약이 {count}번 연속 실패함" },
+	manual: { en: "requested directly", ko: "직접 요청" },
+	age: { en: "the session passed {hours} hours and is idle", ko: "세션이 {hours}시간을 넘겨 쉬는 중" },
+} as const satisfies Record<string, Text>;
 
 interface OpenResult {
 	sessionId: string;
@@ -176,6 +320,11 @@ export interface SlashCommand {
 	source: string;
 }
 
+/** An agent session's command list (D5): skill commands outside its `skills` allowlist are left out; other sources stay. */
+export function allowedAgentCommands<T extends { readonly name: string; readonly source: string }>(commands: readonly T[], skills: ReadonlySet<string>): T[] {
+	return commands.filter((command) => command.source !== "skill" || skills.has(command.name) || skills.has(command.name.replace(/^skill:/, "")));
+}
+
 interface WorkWake {
 	input: StoredEvent;
 	/** Releases a live receipt wait after reconciliation or connection loss. Absent after restart. */
@@ -189,6 +338,7 @@ interface ConvRuntime {
 	run: number;
 	rotating: boolean;
 	admitting: number;
+	promptAdmissions: Set<() => void>;
 	clientInputIdentity: boolean;
 	atomicQueuedResume: boolean;
 	/** `open_session` state.sessionId: the session file's own identity, which survives reconnects. */
@@ -322,6 +472,7 @@ export function modelOptions(models: OmoModel[]): ModelChoice[] {
 
 export class Hub {
 	private readonly runtime = new Map<string, ConvRuntime>();
+	private readonly deletingAgents = new Set<string>();
 	private readonly sessionToConv = new Map<string, string>();
 	/** Open ask_user_question cards by scope-qualified gateway action ID. omo owns their lifetime. */
 	private readonly questions = new Map<string, QuestionCard>();
@@ -617,9 +768,10 @@ export class Hub {
 	}
 
 	snapshot(): Record<string, unknown> {
+		const conversations = this.store.listConversations(false);
 		return {
-			conversations: this.store.listConversations(),
-			activity: Object.fromEntries(this.store.listConversations().map((conv) => [conv.id, this.activity(conv.id)])),
+			conversations,
+			activity: Object.fromEntries(conversations.map((conv) => [conv.id, this.activity(conv.id)])),
 			approvals: [...this.dialogs.list(), ...this.questions.values(), ...this.releasedMainCards()],
 			sessionTransitions: [...this.runtime]
 				.filter(([, runtime]) => runtime.rotating)
@@ -659,6 +811,10 @@ export class Hub {
 
 	/** Whether the last model answer named a held switch; the next settled main turn re-reads it. */
 	private modelPending = false;
+	private readonly knownModels = new Set<string>();
+	private providerErrorChecker: SecurityChecker | null = null;
+	/** Improvement 230: conversations whose `/compact` RPC has not answered yet. */
+	private readonly manualCompactions = new Set<string>();
 
 	/** The models omo can use right now (its logged-in providers) and the one a conversation's session is on. */
 	async models(convId = "main"): Promise<ModelInfo> {
@@ -671,6 +827,7 @@ export class Hub {
 			omo.command<{ model?: OmoModel | null; thinkingLevel?: string; pendingModelSwitch?: { provider: string; id: string } | null }>("get_state", { sessionId }),
 		]);
 		const options = modelOptions(available.models ?? []);
+		for (const option of options) this.knownModels.add(`${option.provider}/${option.id}`);
 		const held = state.pendingModelSwitch;
 		const pending = held
 			? options.find((o) => o.provider === held.provider && o.id === held.id) ?? { provider: held.provider, id: held.id, name: held.id }
@@ -725,13 +882,43 @@ export class Hub {
 		}
 	}
 
-	createConversation(title: string): ConversationInfo {
-		const conv = this.store.createConversation(this.nextId("c"), title.trim() || "새 대화");
+	createConversation(title: string, agentId?: string): ConversationInfo {
+		const conv = this.store.createConversation(this.nextId("c"), title.trim() || say(HUB_TEXT.newConversation), agentId);
 		this.emit("*", "conversation.created", conv);
 		this.publishActivity(conv.id);
 		return conv;
 	}
 
+	agentUpdated(data: unknown): void {
+		this.emit("*", "agent.updated", data);
+	}
+
+	/** Keep file movement and visibility changes inside the same deletion admission. */
+	async deleteAgentConversation(convId: string, trash: () => string): Promise<string> {
+		const conv = this.store.getConversation(convId);
+		if (!conv?.agentId) throw new Error("agent_conversation_missing");
+		const rt = this.rt(convId);
+		if (this.maintenanceId || this.deletingAgents.has(convId) || rt.rotating || this.closeUncertain(convId) ||
+			this.hasUnfinishedTurn(convId) || this.rotationBlocked(convId) ||
+			this.openQuestionCards(convId, this.conversationScope(convId)).size > 0) throw new Error("agent_busy");
+		this.deletingAgents.add(convId);
+		try {
+			if (conv.threadId || rt.sessionId) {
+				const { sessionId } = await this.ensureSession(conv, true);
+				await this.requireOmo().command("close_session", { sessionId });
+				this.sessionToConv.delete(sessionId);
+				const owner = this.ownerForConversation(convId, sessionId);
+				if (owner) this.releaseScopedUiOwner(owner);
+				rt.sessionId = null;
+			}
+			const entry = trash();
+			this.store.setConversationHidden(convId, true);
+			return entry;
+		} finally {
+			this.deletingAgents.delete(convId);
+		}
+	}
+
 	onOmoStatus(status: OmoStatus, detail?: string): Promise<number> {
 		const activityRecovery = this.beginActivityRecovery();
 		this.omoStatus = status;
@@ -759,7 +946,7 @@ export class Hub {
 				rt.wake = null;
 				rt.notified.clear();
 				const scope = this.conversationScope(conv);
-				this.dialogs.cancelScope(scope, "엔진 연결이 끊겼습니다.");
+				this.dialogs.cancelScope(scope, say(HUB_TEXT.engineDisconnected));
 				for (const [id, card] of this.questions) {
 					if (card.scope !== scope) continue;
 					this.questions.delete(id);
@@ -822,7 +1009,7 @@ export class Hub {
 					this.activityRecoveryFailedGeneration = activityRecovery;
 					this.publishAllActivities();
 				}
-				this.emit(conv.id, "error", { message: `이전 작업 복구 실패: ${errorMessage(error)}` });
+				if (!(error instanceof AgentSessionError)) this.emit(conv.id, "error", { message: say(HUB_TEXT.recoveryFailed, { error: errorMessage(error) }) });
 			}
 		}
 	}
@@ -830,6 +1017,7 @@ export class Hub {
 	/** `images` are names of files already uploaded to the media folder; unknown names are dropped. */
 	async sendText(convId: string, text: string, src: Source, trust: Trust, images: string[] = [], referenceIds?: unknown, checked = false, submissionId?: string): Promise<void> {
 		if (this.maintenanceId) throw new MaintenanceError("maintenance_held");
+		this.requireVisibleAgent(convId);
 		if (submissionId !== undefined && !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(submissionId)) throw new SecurityRuntimeError("held_conflict");
 		const context = { ...(submissionId ? { key: JSON.stringify(["message", convId, submissionId]), submissionId } : {}),
 			snapshot: structuredClone({ text, src, trust, images, referenceIds }) };
@@ -847,6 +1035,7 @@ export class Hub {
 			this.emit(convId, "notice", { kind: "usage", level: "info", message: await this.options.usageReport() });
 			return;
 		}
+		const compact = images.length === 0 && references.length === 0 ? compactInstructions(body) : null;
 		const dir = this.options.media?.dir;
 		const attached = dir ? [...new Set(images)].filter((n) => mediaFile(dir, n)).slice(0, MAX_ATTACHMENTS) : [];
 		const prompt = referencedInput(body, attached, references);
@@ -857,13 +1046,17 @@ export class Hub {
 		if (!body && attached.length === 0 && references.length === 0) return;
 		const attachmentSnapshot = this.attachments(prompt.images);
 		const send = async (receipt?: (ref: SecurityReceipt) => void) => {
+			this.requireVisibleAgent(convId);
 			if (receipt && prompt.images.some((name) => !dir || !mediaFile(dir, name))) throw new SecurityRuntimeError("dispatch_failed");
+			// A message stored now would cancel the session replacement in progress (it admits no new user message).
+			if (compact !== null && this.rt(convId).rotating) return this.refuseCompact(convId, COMPACT_REFUSED.session, receipt !== undefined);
 			const input = this.store.acceptMainUser(convId, {
 				text: body, src: source, trust, ...(attached.length ? { images: attached } : {}),
 				...(references.length ? { references } : {}),
-			}, receipt);
+			}, receipt, compact !== null);
 			this.publishStored(input);
 			this.decisions?.refresh();
+			if (compact !== null) return this.manualCompact(convId, input.seq, compact, receipt !== undefined);
 			const rotationDone = this.rt(convId).rotationDone;
 			if (rotationDone) await rotationDone;
 			if (this.closeUncertain(convId)) {
@@ -873,7 +1066,7 @@ export class Hub {
 				}
 				this.scheduleCloseRecovery(convId);
 				this.emit(convId, "notice", { kind: "session-close-recovery", level: "info",
-					message: "세션 닫기 상태를 확인하고 있습니다. 메시지는 확인 후 전달합니다." });
+					message: say(HUB_TEXT.closeChecking) });
 				return;
 			}
 			await this.prompt(convId, prompt.text, prompt.images, input.seq, true, attachmentSnapshot, receipt !== undefined);
@@ -930,7 +1123,7 @@ export class Hub {
 		const generation = this.generation;
 		const flight = this.injectWorkUpdates(convId, generation).catch((error) => {
 			if (this.omoStatus === "ready" && generation === this.generation) {
-				this.emit(convId, "error", { message: `작업 결과 알림 실패: ${errorMessage(error)}` });
+				this.emit(convId, "error", { message: say(HUB_TEXT.workNotifyFailed, { error: errorMessage(error) }) });
 			}
 		}).finally(() => {
 			if (rt.waking !== flight) return;
@@ -992,7 +1185,7 @@ export class Hub {
 				if (!acknowledged && generation === this.generation && this.omoStatus === "ready" && rt.wake === wake) {
 					this.emit(convId, "notice", {
 						kind: "work-input-receipt-unknown", level: "warning",
-						input_seq: input.seq, message: "작업 결과 알림의 수신을 확인하지 못했습니다. 결과 기록은 보존되어 있습니다.",
+						input_seq: input.seq, message: say(HUB_TEXT.workReceiptUnknown),
 					});
 				}
 			}
@@ -1037,7 +1230,7 @@ export class Hub {
 			}
 		} catch (error) {
 			if (generation === this.generation && this.omoStatus === "ready") {
-				this.emit(conv, "error", { message: `작업 결과 알림 대조 실패: ${errorMessage(error)}` });
+				this.emit(conv, "error", { message: say(HUB_TEXT.workReconcileFailed, { error: errorMessage(error) }) });
 			}
 		}
 		if (generation !== this.generation || this.omoStatus !== "ready" || rt.sessionId !== sessionId || rt.run !== run) return;
@@ -1057,7 +1250,7 @@ export class Hub {
 				await this.reconcileWorkInput(pendingWake.input, sessionId, generation, true);
 			} catch (error) {
 				if (generation === this.generation && this.omoStatus === "ready") {
-					this.emit(conv, "error", { message: `작업 결과 알림 대조 실패: ${errorMessage(error)}` });
+					this.emit(conv, "error", { message: say(HUB_TEXT.workReconcileFailed, { error: errorMessage(error) }) });
 				}
 			}
 			if (generation !== this.generation || this.omoStatus !== "ready" || rt.sessionId !== sessionId || rt.run !== run) return;
@@ -1118,8 +1311,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 ? "메시지가 엔진 대기열에 남아 있습니다. 자동 재전송하지 않습니다."
-							: "메시지의 실행 소비를 확인하지 못했습니다. 기록을 보존하며 자동 재전송하지 않습니다.",
+						message: say(queued ? HUB_TEXT.inputQueued : HUB_TEXT.inputConsumptionUnknown),
 					});
 					if (queued && data.native_identity && rt.atomicQueuedResume && state &&
 						state.isStreaming === false && typeof state.queueEpoch === "string") {
@@ -1130,7 +1322,7 @@ export class Hub {
 							sessionId, clientInputId: data.input_id, queueEpoch: state.queueEpoch,
 						}).catch((error) => {
 							if (generation === this.generation && this.omoStatus === "ready" && rt.sessionId === sessionId) {
-								this.emit(conv, "error", { message: `대기 입력 재개 확인 실패: ${errorMessage(error)}` });
+								this.emit(conv, "error", { message: say(HUB_TEXT.queuedResumeFailed, { error: errorMessage(error) }) });
 							}
 						});
 					}
@@ -1154,7 +1346,7 @@ export class Hub {
 			}
 		} catch (error) {
 			if (generation === this.generation && this.omoStatus === "ready" && rt.sessionId === sessionId) {
-				this.emit(conv, "error", { message: `사용자 입력 대조 실패: ${errorMessage(error)}` });
+				this.emit(conv, "error", { message: say(HUB_TEXT.userInputReconcileFailed, { error: errorMessage(error) }) });
 			}
 		} finally {
 			clearTimeout(timer);
@@ -1181,11 +1373,13 @@ export class Hub {
 	 */
 	async rotateSession(convId: string, reason: RotationReason): Promise<ConversationInfo> {
 		if (this.maintenanceId) throw new MaintenanceError("maintenance_held");
+		this.requireVisibleAgent(convId);
 		const conv = this.store.getConversation(convId);
 		if (!conv) throw new Error(`unknown_conversation:${convId}`);
 		const rt = this.rt(convId);
 		const forced = reason === "size" || reason === "compactions";
-		if (rt.rotating || this.rotationHeldFor(convId, forced)) throw new Error("turn_running");
+		const residue = this.residualTurn(convId, reason);
+		if (rt.rotating || (this.rotationHeldFor(convId, forced) && residue === null)) throw new Error("turn_running");
 		if (this.omoStatus !== "ready" || this.closeUncertain(convId)) throw new Error("session_ownership_unknown");
 		const generation = this.generation;
 		const from = conv.threadId;
@@ -1195,7 +1389,7 @@ export class Hub {
 		rt.rotating = true;
 		rt.rotationDone = latch.promise;
 		rt.finishRotation = latch.resolve;
-		this.emit(convId, "session.transition", { active: true, label: "세션 교체 중" }, false);
+		this.emit(convId, "session.transition", { active: true, label: say(HUB_TEXT.sessionTransition) }, false);
 		try {
 			const { sessionId } = await this.ensureSession(conv, true);
 			const readiness = await this.requireOmo().command<{
@@ -1243,7 +1437,7 @@ export class Hub {
 				rt.sessionId !== sessionId ||
 				from !== source ||
 				this.store.lastSeq(convId, "message.user") !== admittedUser ||
-				this.rotationHeldFor(convId, forced)
+				(this.rotationHeldFor(convId, forced) && (residue === null || this.residualTurn(convId, reason) !== residue))
 			) {
 				throw new Error("turn_running");
 			}
@@ -1288,6 +1482,95 @@ export class Hub {
 		}
 	}
 
+	/**
+	 * Bug 224: a manual rotation may retire a session whose main turn left only residue: inputs nothing runs any more and
+	 * a work wake whose send already ended. Returns that residue's identity, or null when anything else holds. rotateSession
+	 * still proves the engine idle (no streaming, compaction, retry, queue or question) before it closes the session.
+	 */
+	private residualTurn(conv: string, reason: RotationReason): string | null {
+		if (reason !== "manual") return null;
+		const rt = this.rt(conv);
+		const holds = this.rotationHoldsFor(conv, false);
+		if (holds.length === 0 || this.store.pendingMainUsers(conv).length > 0) return null;
+		const residual = holds.every((hold) => hold.kind === "main_turn" &&
+			(hold.state === "unfinished_turn" || (hold.state === "waking" && rt.waking === null)));
+		if (!residual) return null;
+		const turn = this.store.mainTurn(conv);
+		return JSON.stringify({ turn: turn?.seq ?? null, inputs: turn?.inputs.map((input) => input.seq) ?? [], wake: rt.wake?.input.seq ?? null });
+	}
+
+	/**
+	 * Bug 224 (user decision 2026-10-29): FRESH_SESSION_COMPACTION_FAILURES failed compactions in a row open a fresh session
+	 * without asking the old one for anything. The old session is detached first, so its late events never reach this
+	 * conversation; stopping and closing it are best effort. Its file stays; the handoff names it and carries only the
+	 * recent exchange. Works, decisions and never-sent user input carry over as in any rotation; nothing is replayed.
+	 */
+	private openFreshSession(convId: string): void {
+		if (this.maintenanceId || this.omoStatus !== "ready") return;
+		const conv = this.store.getConversation(convId);
+		const rt = this.rt(convId);
+		if (!conv?.threadId || rt.rotating) return;
+		const from = conv.threadId;
+		const sessionId = rt.sessionId;
+		// Synchronous from the check above to the new thread, so no prompt or rotation interleaves; no latch is needed.
+		this.emit(convId, "session.transition", { active: true, label: say(HUB_TEXT.sessionTransition) }, false);
+		try {
+			if (sessionId) this.retireScopedQuestions(convId, sessionId);
+			rt.running = false;
+			rt.durableId = null;
+			rt.run++;
+			this.finishRetirement(convId, {
+				sessionId: sessionId ?? "", sessionPath: from, from, reason: "compaction_failed",
+				handoff: this.buildHandoff(convId, "compaction_failed", from),
+			});
+			this.publishActivity(convId);
+		} finally {
+			this.emit(convId, "session.transition", { active: false, label: null }, false);
+		}
+		if (sessionId) void this.stopAbandonedSession(sessionId);
+		if (this.store.pendingMainUsers(convId).length > 0) void this.recover();
+		void this.notifyWorkUpdates(convId);
+	}
+
+	/** A detached session gets one abort and one close; it no longer routes to any conversation, so failures only log. */
+	private async stopAbandonedSession(sessionId: string): Promise<void> {
+		for (const command of ["abort", "close_session"] as const) {
+			try {
+				await this.requireOmo().command(command, { sessionId });
+			} catch (error) {
+				console.error(`abandoned session ${command} failed (${sessionId}): ${errorMessage(error)}`);
+			}
+		}
+	}
+
+	/** Bug 223: log with cached model identities; an unhealthy engine must never hold its own failure diagnostic. */
+	private async logCompactionFailure(failureKind: CompactionFailureKind, failure: unknown): Promise<void> {
+		// Loaded on first use: the security rules ship beside src/, and only a failure needs them.
+		if (!this.providerErrorChecker) this.providerErrorChecker = (await import("./security-check.ts")).defaultChecker();
+		const checker = this.providerErrorChecker;
+		console.error("compaction_failed", JSON.stringify(compactionFailureLog(failureKind, failure, this.knownModels,
+			(text) => sanitizeProviderError(text, checker))));
+	}
+
+	private freshSessionCompactionFailures(): number {
+		return this.options.rotation?.freshSessionCompactionFailures ?? FRESH_SESSION_COMPACTION_FAILURES;
+	}
+
+	/**
+	 * Bug 224: failed blocking compactions since the last completed one in this session, one per native request id.
+	 * Improvement 230: a failed manual summary (`/compact`) does not count.
+	 */
+	private compactionFailuresInRow(conv: string): number {
+		const failed = new Set<string>();
+		for (const event of this.store.eventsAfter(conv, this.store.lastSeq(conv, "session.rotated")).reverse()) {
+			if (event.type !== "session.compaction") continue;
+			const data = event.data as { status?: string; requestId?: unknown; reason?: unknown };
+			if (data.status === "completed") break;
+			if (data.status === "failed" && data.reason !== "manual" && typeof data.requestId === "string") failed.add(data.requestId);
+		}
+		return failed.size;
+	}
+
 	private closeUncertain(conv: string): boolean {
 		return this.store.lastSeq(conv, "session.close.unknown") >
 			Math.max(this.store.lastSeq(conv, "session.rotated"), this.store.lastSeq(conv, "session.close.resolved"));
@@ -1304,9 +1587,16 @@ export class Hub {
 
 	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);
+		for (const release of rt.promptAdmissions) release();
+		if (retirement.sessionId) {
+			const owner = this.ownerForConversation(convId, retirement.sessionId);
+			this.sessionToConv.delete(retirement.sessionId);
+			if (owner) this.releaseScopedUiOwner(owner);
+		}
+		// Bug 224: nothing the retired session left unfinished can run any more; close it so recovery never replays it.
+		if (this.store.mainTurn(convId)) this.completeTurn(convId, "interrupted");
+		rt.wake?.release?.();
+		rt.wake = null;
 		rt.sessionId = null;
 		rt.itemId = null;
 		rt.itemText = "";
@@ -1318,7 +1608,8 @@ export class Hub {
 		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)}). 화면의 대화 기록은 그대로이고, 다음 메시지부터 새 세션에서 이어집니다.` });
+			message: say(HUB_TEXT.sessionRotated, { reason: this.reasonLabel(retirement.reason, serverLanguage()),
+				extra: retirement.reason === "compaction_failed" ? say(HUB_TEXT.rotatedAfterFailure) : "" }) });
 	}
 
 	private closeTimer(callback: () => void, ms: number): ReturnType<typeof setTimeout> {
@@ -1388,14 +1679,14 @@ export class Hub {
 					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: "세션 닫기 상태를 확인했습니다. 기존 대화에서 메시지 처리를 계속합니다." });
+						message: say(HUB_TEXT.closeResolved) });
 				}
 				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)}. 메시지는 보관 중입니다. 엔진 연결과 세션 목록을 확인한 뒤 게이트웨이를 다시 시작하세요.` });
+					this.emit(convId, "error", { message: say(HUB_TEXT.closeRecoveryExhausted, { error: errorMessage(error) }) });
 				}
 			} finally {
 				if (timeout !== undefined) this.clearCloseTimer(timeout);
@@ -1558,7 +1849,7 @@ export class Hub {
 			this.legacyQuestionHistoryAliases.delete(id);
 			this.emit(conv, "action.resolved", {
 				actionId: historyActionId,
-				answer: { kind: "cancel", reason: "세션 교체로 닫힌 질문입니다. 받은편지함에서 답하면 새 세션으로 전달됩니다." },
+				answer: { kind: "cancel", reason: say(HUB_TEXT.rotationQuestionClosed) },
 				by: "cancelled",
 			});
 		}
@@ -1591,11 +1882,13 @@ export class Hub {
 		);
 	}
 
-	private reasonLabel(reason: RotationReason): string {
+	/** `lang`: the UI language for the user notice, "ko" for the engine context (engine-facing text stays Korean). */
+	private reasonLabel(reason: RotationReason, lang: Language): string {
 		const hours = Math.round((this.options.rotation?.maxAgeMs ?? ROTATE_MAX_AGE_MS) / 3_600_000);
-		if (reason === "size") return `세션 파일이 ${Math.round((this.options.rotation?.forceMaxBytes ?? FORCE_ROTATE_MAX_BYTES) / 1024 / 1024)}MB에 닿음`;
-		if (reason === "compactions") return `압축이 ${this.options.rotation?.forceUpdateCompactions ?? FORCE_ROTATE_UPDATE_COMPACTIONS}번 더 이어짐`;
-		return reason === "manual" ? "직접 요청" : `세션이 ${hours}시간을 넘겨 쉬는 중`;
+		if (reason === "size") return textIn(lang, ROTATION_REASON.size, { mb: Math.round((this.options.rotation?.forceMaxBytes ?? FORCE_ROTATE_MAX_BYTES) / 1024 / 1024) });
+		if (reason === "compactions") return textIn(lang, ROTATION_REASON.compactions, { count: this.options.rotation?.forceUpdateCompactions ?? FORCE_ROTATE_UPDATE_COMPACTIONS });
+		if (reason === "compaction_failed") return textIn(lang, ROTATION_REASON.compaction_failed, { count: this.freshSessionCompactionFailures() });
+		return reason === "manual" ? textIn(lang, ROTATION_REASON.manual) : textIn(lang, ROTATION_REASON.age, { hours });
 	}
 
 	/** Recent user/assistant lines from the gateway's own history, newest kept, within HANDOFF_MAX_CHARS. */
@@ -1616,8 +1909,8 @@ export class Hub {
 			lines.unshift(line);
 		}
 		return [
-			`[게이트웨이 알림] 이 대화는 새 엔진 세션으로 교체됐습니다 (${this.reasonLabel(reason)}).`,
-			from ? `이전 세션의 전체 기록은 ${from} 에 남아 있습니다. 파일이 크니 필요할 때 필요한 부분만 검색해서 보세요.` : "",
+			`[게이트웨이 알림] 이 대화는 새 엔진 세션으로 교체됐습니다 (${this.reasonLabel(reason, "ko")}).`,
+			from ? `이전 세션의 전체 기록은 ${from} 에 남아 있습니다. 파일이 크니 필요할 때 끝부분이나 필요한 부분만 검색해서 보고, 전체를 읽지 마세요.` : "",
 			...this.handoffOpenItems(conv),
 			"아래는 직전 대화의 최근 부분입니다. 맥락으로만 참고하세요.",
 			"---",
@@ -1630,19 +1923,29 @@ export class Hub {
 
 	/** Sends input once. Native same-session compaction owns overflow recovery, never gateway replay. */
 	private async prompt(convId: string, body: string, images: string[] = [], messageSeq?: number, admitted = false, attachmentSnapshot?: ReturnType<Hub["attachments"]>, protectedPayload = false): Promise<void> {
+		this.requireVisibleAgent(convId);
 		const conv = this.store.getConversation(convId);
 		if (!conv) return;
 		const rt = this.rt(convId);
 		if (rt.rotating) return; // Accepted user intent remains definitely unsent until rotation finishes.
 		const generation = this.generation;
+		let input: StoredEvent | null = null;
+		let nativeCommand = false;
+		let sessionId: string | null = null;
+		const releaseAdmission = () => {
+			if (rt.promptAdmissions.delete(releaseAdmission)) rt.admitting -= 1;
+		};
+		rt.promptAdmissions.add(releaseAdmission);
+		// Hold user admission through RPC settlement, including the idle-before-agent_start interval.
+		rt.admitting += 1;
 		try {
-			const { sessionId } = await this.ensureSession(conv);
+			({ sessionId } = await this.ensureSession(conv));
 			if (generation !== this.generation || this.omoStatus !== "ready") return;
 			const reference = messageSeq ?? this.store.lastSeq(convId, "message.user");
 			// sendText and reconnect recovery can share admission; only one may cross the write boundary.
 			if (admitted && this.store.mainUserDispatched(convId, reference)) return;
 			const commandName = body.slice(1).split(" ", 1)[0];
-			const nativeCommand = (body === "." && images.length === 0) ||
+			nativeCommand = (body === "." && images.length === 0) ||
 				(body.startsWith("/") && (await this.commands(convId)).some((command) => command.name === commandName));
 			if (generation !== this.generation || this.omoStatus !== "ready" || rt.sessionId !== sessionId) return;
 			if (admitted && this.store.mainUserDispatched(convId, reference)) return;
@@ -1660,7 +1963,7 @@ export class Hub {
 				...(rt.clientInputIdentity ? { clientInputId: inputId } : {}),
 			};
 			if (attached.images.length) params.images = attached.images;
-			const input = this.emit(convId, "main.input", {
+			input = this.emit(convId, "main.input", {
 				origin: "user", input_ref: { message_seq: reference },
 				session_path: this.store.getConversation(convId)?.threadId, handoff,
 				...(!nativeCommand || rt.clientInputIdentity ? {
@@ -1677,9 +1980,20 @@ export class Hub {
 			this.decisions?.refresh();
 		} catch (error) {
 			if (generation !== this.generation || this.omoStatus !== "ready") return;
+			// A retired session's late answer: retirement already closed its input, so it must not close or report it again.
+			const retired = sessionId !== null && rt.sessionId !== sessionId;
+			// Bug 224: the engine refused this prompt before accepting it, so it never runs and must not hold the turn.
+			// Native commands ("." continues through a queued custom message) and unknown delivery stay open.
+			const refused = !retired && input !== null && !nativeCommand && error instanceof OmoCommandError &&
+				error.command === "prompt" && error.code === REQUIRED_COMPACTION_REFUSAL && !this.store.mainInputConsumed(input);
+			if (refused && input) this.emit(convId, "main.input.handled", { input_seq: input.seq, reason: "prompt_rejected" });
 			if (protectedPayload) throw new SecurityRuntimeError("dispatch_unknown");
+			if (retired) return;
+			if (error instanceof AgentSessionError) return; // The definition failure was already persisted and broadcast.
 			const message = errorMessage(error);
-			this.emit(convId, "error", this.continuityError(message));
+			this.emit(convId, "error", refused ? { kind: "compaction-required", message: say(COMPACTION_REQUIRED_MESSAGE) } : this.continuityError(message));
+		} finally {
+			releaseAdmission();
 		}
 	}
 
@@ -1687,7 +2001,7 @@ export class Hub {
 		if (!CONTEXT_OVERFLOW.test(message)) return { message };
 		return {
 			kind: "continuity-protected",
-			message: `${message}. 같은 엔진 세션을 유지합니다. 원인을 해결한 뒤 계속할 지시를 보내 주세요. 이전 입력은 자동 재전송하지 않습니다.`,
+			message: say(HUB_TEXT.continuityProtected, { message }),
 		};
 	}
 
@@ -1713,20 +2027,91 @@ export class Hub {
 		const rt = this.rt(convId);
 		if (!rt.sessionId || !rt.running) return;
 		await this.requireOmo().command("abort", { sessionId: rt.sessionId });
-		this.dialogs.cancelScope(this.conversationScope(convId), "사용자가 작업을 중단했습니다.");
+		this.dialogs.cancelScope(this.conversationScope(convId), say(HUB_TEXT.userStopped));
 	}
 
+	/**
+	 * Improvement 230: `/compact` asks the engine to summarize this conversation's session now. The message stays in the
+	 * history and its input is closed before the RPC, so recovery never sends it. While an answer runs, a summary runs, a
+	 * retry waits or the session is being replaced it is refused with a notice and never queued. The engine's own
+	 * compaction_start/compaction_end events carry the usual start and terminal notices; this returns once the RPC is sent.
+	 */
+	private async manualCompact(convId: string, messageSeq: number, instructions: string, protectedPayload: boolean): Promise<void> {
+		const conv = this.store.getConversation(convId);
+		if (!conv) return;
+		const rt = this.rt(convId);
+		const refuse = (message: Text) => this.refuseCompact(convId, message, protectedPayload);
+		const held = () => rt.rotating || this.closeUncertain(convId) ? COMPACT_REFUSED.session
+			: this.manualCompactions.has(convId) ? COMPACT_REFUSED.compacting
+			: rt.running || rt.promptAdmissions.size > 0 || rt.waking !== null || this.store.pendingMainUsers(convId).length > 0
+				? COMPACT_REFUSED.answering : null;
+		const early = this.omoStatus !== "ready" ? COMPACT_REFUSED.engine : held();
+		if (early) return refuse(early);
+		const generation = this.generation;
+		let sessionId: string;
+		let state: { isStreaming?: boolean; isCompacting?: boolean; isBashRunning?: boolean; pendingMessageCount?: number; retryAttempt?: number };
+		try {
+			({ sessionId } = await this.ensureSession(conv));
+			state = await this.requireOmo().command("get_state", { sessionId });
+		} catch (error) {
+			console.error(`manual compaction state: ${errorMessage(error)}`);
+			return refuse(COMPACT_REFUSED.engine);
+		}
+		if (this.omoStatus !== "ready") return refuse(COMPACT_REFUSED.engine);
+		if (generation !== this.generation || rt.sessionId !== sessionId) return refuse(COMPACT_REFUSED.session);
+		const busy = held() ?? (state.isCompacting ? COMPACT_REFUSED.compacting
+			: (state.retryAttempt ?? 0) > 0 ? COMPACT_REFUSED.retrying
+			: state.isStreaming || state.isBashRunning || (state.pendingMessageCount ?? 0) > 0 ? COMPACT_REFUSED.answering : null);
+		if (busy) return refuse(busy);
+		this.manualCompactions.add(convId);
+		const input = this.emit(convId, "main.input", { origin: "user", input_ref: { message_seq: messageSeq },
+			session_path: this.store.getConversation(convId)?.threadId, handoff: null });
+		if (input) {
+			this.store.ackMainInput(input);
+			this.emit(convId, "main.input.handled", { input_seq: input.seq, reason: "compact" });
+		}
+		const before = this.store.lastSeq(convId, "session.compaction");
+		void this.requireOmo().command("compact", { sessionId, ...(instructions ? { customInstructions: instructions } : {}) })
+			.catch(async (error) => {
+				if (generation !== this.generation || this.rt(convId).sessionId !== sessionId) return;
+				// A summary that started reports its own terminal notice and failure log line (bug 223).
+				const reported = this.store.eventsAfter(convId, before).some((event) => event.type === "session.compaction" &&
+					(event.data as { status?: string }).status !== "running");
+				if (reported) return;
+				if (!this.providerErrorChecker) this.providerErrorChecker = (await import("./security-check.ts")).defaultChecker();
+				console.error("manual_compaction_failed", JSON.stringify({ error: sanitizeProviderError(errorMessage(error), this.providerErrorChecker) ?? "unknown" }));
+				this.emit(convId, "error", { kind: "compaction-failed", action: "retry", message: compactNotReported() });
+			})
+			.catch((error) => console.error(`manual compaction: ${errorMessage(error)}`))
+			.finally(() => this.manualCompactions.delete(convId));
+	}
+
+	/** A security hold that released this `/compact` ends as failed (nothing was sent), not as an unconfirmed send. */
+	private refuseCompact(convId: string, message: Text, protectedPayload: boolean): void {
+		this.emit(convId, "notice", { kind: "compact-refused", level: "warning", message: say(message) });
+		if (protectedPayload) throw new SecurityRuntimeError("dispatch_failed");
+	}
+
+
 	/** omo's slash commands and skills for the conversation's session, trimmed to what the input menu shows. */
 	async commands(convId: string): Promise<SlashCommand[]> {
 		const conv = this.store.getConversation(convId);
 		if (!conv) throw new Error(`unknown_conversation:${convId}`);
 		const { sessionId } = await this.ensureSession(conv);
 		const { commands } = await this.requireOmo().command<{ commands: { name: string; description?: string; source: string }[] }>("get_commands", { sessionId });
-		const listed = commands.map((c) => ({ name: c.name, description: c.description ?? "", source: c.source }));
-		const own = [...(this.options.versionReport ? [VERSION_COMMAND] : []), ...(this.options.usageReport ? [USAGE_COMMAND] : [])];
+		const visible = conv.agentId ? allowedAgentCommands(commands, this.agentSkills(conv.agentId)) : commands;
+		const listed = visible.map((c) => ({ name: c.name, description: c.description ?? "", source: c.source }));
+		const own = [...(this.options.versionReport ? [VERSION_COMMAND] : []), ...(this.options.usageReport ? [USAGE_COMMAND] : []), COMPACT_COMMAND];
 		return [...listed.filter((c) => !own.some((command) => command.name === c.name)), ...own];
 	}
 
+	/** The agent's skills allowlist (D4.2, merged definition `skills`); the extension limits the session to the same set. */
+	private agentSkills(agentId: string): ReadonlySet<string> {
+		const files = this.options.agents ?? new AgentFileStore();
+		const skills = mergeAgentDefinition(files.read(agentId), files.readDefaults()).fields.skills;
+		return new Set(Array.isArray(skills) ? skills.filter((skill): skill is string => typeof skill === "string") : []);
+	}
+
 	answerAction(data: ActionAnswerData, conv?: string): boolean {
 		if (this.maintenanceId) throw new MaintenanceError("maintenance_held");
 		if (this.decisions) {
@@ -1854,9 +2239,9 @@ export class Hub {
 						? { engineTurn: { id: rt.statsTurnId, sessionId: rt.durableId, messageTimestamp: message.timestamp, messageIndex: rt.statsMessageIndex } } : {}),
 				});
 				if (message.stopReason === "aborted") {
-					this.emit(conv, "notice", { message: "작업을 중단했습니다.", level: "info" });
+					this.emit(conv, "notice", { message: say(HUB_TEXT.stopped), level: "info" });
 				} else if (message.stopReason === "error" || message.errorMessage) {
-					this.emit(conv, "error", this.continuityError(message.errorMessage ?? "모델 응답 오류"));
+					this.emit(conv, "error", this.continuityError(message.errorMessage ?? say(HUB_TEXT.modelResponseError)));
 				}
 				rt.itemId = null;
 				rt.itemText = "";
@@ -1887,9 +2272,9 @@ export class Hub {
 			case "compaction_start": {
 				if (!blockingCompaction(event) || this.compactionSeen(conv, event, false)) return;
 				const requestId = typeof event.requestId === "string" ? event.requestId : undefined;
-				this.emit(conv, "session.compaction", { status: "running", requestId });
+				this.emit(conv, "session.compaction", { status: "running", requestId, ...(event.reason === "manual" ? { reason: "manual" } : {}) });
 				this.emit(conv, "notice", { kind: "compaction-started", level: "info", requestId,
-					message: "대화 내용을 요약하고 있습니다. 완료될 때까지 기다려 주세요." });
+					message: say(HUB_TEXT.compactionStarted) });
 				return;
 			}
 			case "compaction_end": {
@@ -1898,21 +2283,25 @@ export class Hub {
 				const outcome = compactionOutcome(event);
 				this.emit(conv, "session.compaction", {
 					...outcome, requestId, accepted: outcome.status === "completed",
+					...(event.reason === "manual" ? { reason: "manual" } : {}),
 				});
 				switch (outcome.status) {
 					case "cancelled":
 						this.emit(conv, "notice", { kind: "compaction-cancelled", level: "warning", requestId,
-							message: "대화 요약을 취소했습니다. 이전 내용과 같은 세션을 유지합니다. 이전 입력은 자동으로 다시 보내지 않습니다." });
+							message: say(HUB_TEXT.compactionCancelled) });
 						break;
 					case "failed": {
 						const recovery = COMPACTION_RECOVERY[outcome.failureKind];
 						this.emit(conv, "error", { kind: "compaction-failed", requestId, failureKind: outcome.failureKind,
-							action: recovery.action, message: `대화 요약에 실패했습니다. 이전 내용은 유지했습니다. ${recovery.message}` });
+							action: recovery.action, message: say(COMPACTION_FAILED, { recovery: say(recovery.message) }) });
+						void this.logCompactionFailure(outcome.failureKind, event.failure)
+							.catch((error) => console.error(`compaction failure log: ${errorMessage(error)}`));
+						if (this.compactionFailuresInRow(conv) >= this.freshSessionCompactionFailures()) this.openFreshSession(conv);
 						break;
 					}
 					case "completed":
 						this.emit(conv, "notice", { kind: "compaction-completed", level: "info", requestId,
-							message: "대화 요약을 완료했습니다. 같은 세션에서 계속합니다." });
+							message: say(HUB_TEXT.compactionCompleted) });
 						break;
 				}
 				return;
@@ -1923,7 +2312,7 @@ export class Hub {
 				rt.statsMessageIndex = 0;
 				this.publishActivity(conv);
 				this.unwatchConversation(conv);
-				this.dialogs.cancelScope(owner.scope, "작업이 끝났습니다.");
+				this.dialogs.cancelScope(owner.scope, say(HUB_TEXT.turnEnded));
 				if (this.decisions) {
 					void this.reconcileDecisionMain(conv)
 						.then(() => this.decisions?.settled(owner.scope))
@@ -2000,7 +2389,7 @@ export class Hub {
 				legacyActionIds: [requestId],
 				method: method as DialogMethod,
 				permission,
-				title: permission ? `권한 요청: ${firstLine?.slice(PERMISSION_PREFIX.length).trim() ?? ""}` : (firstLine ?? ""),
+				title: permission ? say(HUB_TEXT.permissionTitle, { tool: firstLine?.slice(PERMISSION_PREFIX.length).trim() ?? "" }) : (firstLine ?? ""),
 				detail: detailParts.filter(Boolean).join("\n\n"),
 				options: Array.isArray(event.options) ? (event.options as unknown[]).map(String) : [],
 			},
@@ -2112,12 +2501,12 @@ export class Hub {
 			this.questions.delete(id);
 			const historyActionId = this.legacyQuestionHistoryAliases.get(id) ?? id;
 			this.legacyQuestionHistoryAliases.delete(id);
-			this.emit(owner.conv, "action.resolved", { actionId: historyActionId, answer: { kind: "cancel", reason: "게이트웨이가 꺼져 있던 동안 끝난 질문입니다." }, by: "cancelled" });
+			this.emit(owner.conv, "action.resolved", { actionId: historyActionId, answer: { kind: "cancel", reason: say(HUB_TEXT.endedWhileOff) }, by: "cancelled" });
 		}
 		for (const id of this.openQuestionCards(owner.conv, owner.scope)) {
 			if (live.has(id)) continue;
 			if (this.store.getDecisionByAlias(owner.scope, id)?.sourceRequestId.startsWith("legacy:")) continue;
-			this.emit(owner.conv, "action.resolved", { actionId: id, answer: { kind: "cancel", reason: "게이트웨이가 꺼져 있던 동안 끝난 질문입니다." }, by: "cancelled" });
+			this.emit(owner.conv, "action.resolved", { actionId: id, answer: { kind: "cancel", reason: say(HUB_TEXT.endedWhileOff) }, by: "cancelled" });
 		}
 	}
 
@@ -2251,7 +2640,7 @@ export class Hub {
 		const recovered = this.emitMissedAnswers(conv.id, assistantTexts(currentEntries));
 		if (!this.hasUnfinishedTurn(conv.id)) return;
 		if (rt.running) {
-			this.emit(conv.id, "notice", { kind: "reattached", level: "info", message: `게이트웨이가 다시 연결돼 진행 중인 작업을 이어서 받습니다.${recoveredNote(recovered)}` });
+			this.emit(conv.id, "notice", { kind: "reattached", level: "info", message: say(HUB_TEXT.reattached, { recovered: recoveredNote(recovered) }) });
 			return;
 		}
 		if (turn.source.origin === "work_update") {
@@ -2273,12 +2662,12 @@ export class Hub {
 			this.emit(conv.id, "notice", {
 				kind: "user-input-receipt-unknown", level: "warning",
 				message_seq: turn.source.input_ref.message_seq,
-				message: "메시지 전송 이후 수신을 확인하지 못했습니다. 중복 실행을 피하기 위해 자동 재전송하지 않습니다.",
+				message: say(HUB_TEXT.sendReceiptUnknown),
 			});
 			return;
 		}
 		if (turnFinished(currentEntries)) {
-			this.emit(conv.id, "notice", { kind: "recovered", level: "info", message: `게이트웨이가 꺼져 있던 동안 끝난 작업 결과를 가져왔습니다.${recoveredNote(recovered)}` });
+			this.emit(conv.id, "notice", { kind: "recovered", level: "info", message: say(HUB_TEXT.recovered, { recovered: recoveredNote(recovered) }) });
 			this.completeTurn(conv.id, "completed");
 			rt.wake?.release?.();
 			rt.wake = null;
@@ -2288,7 +2677,7 @@ export class Hub {
 			.eventsAfter(conv.id, this.store.lastSeq(conv.id, "message.user"))
 			.filter((e) => e.type === "notice" && (e.data as { kind?: string }).kind === "auto-continue").length;
 		if (tries >= AUTO_CONTINUE_LIMIT) {
-			this.emit(conv.id, "notice", { kind: "interrupted", level: "warning", message: `작업이 끊겨 자동으로 ${tries}번 이어 보냈지만 끝나지 않았습니다. 확인 후 다시 지시해 주세요.` });
+			this.emit(conv.id, "notice", { kind: "interrupted", level: "warning", message: say(HUB_TEXT.interrupted, { tries }) });
 			this.completeTurn(conv.id, "interrupted");
 			rt.wake?.release?.();
 			rt.wake = null;
@@ -2298,7 +2687,7 @@ export class Hub {
 			|| currentEntries.some((e) => e.type === "message" && e.role === "user");
 		const lastUser = this.store.getEvent(turn.source.input_ref.message_seq)?.data as { text?: string; images?: string[] } | undefined;
 		const message = promptReached || !lastUser?.text ? CONTINUE_PROMPT : lastUser.text;
-		this.emit(conv.id, "notice", { kind: "auto-continue", level: "warning", message: `재시작으로 끊긴 작업을 이어서 진행합니다 (${tries + 1}/${AUTO_CONTINUE_LIMIT}).${recoveredNote(recovered)}` });
+		this.emit(conv.id, "notice", { kind: "auto-continue", level: "warning", message: say(HUB_TEXT.autoContinue, { attempt: tries + 1, limit: AUTO_CONTINUE_LIMIT, recovered: recoveredNote(recovered) }) });
 		await this.prompt(conv.id, message, promptReached ? [] : lastUser?.images ?? [], turn.source.input_ref.message_seq);
 	}
 
@@ -2306,6 +2695,14 @@ export class Hub {
 		return this.store.mainTurn(conv) !== null || this.store.pendingMainUsers(conv).length > 0;
 	}
 
+	private requireVisibleAgent(convId: string): void {
+		if (this.deletingAgents.has(convId)) throw new Error("agent_busy");
+		const conv = this.store.getConversation(convId);
+		if (conv?.agentId && !this.store.listConversations(false).some((visible) => visible.id === convId)) {
+			throw new Error("agent_hidden");
+		}
+	}
+
 	private completeTurn(conv: string, status: "completed" | "interrupted", pendingInputSeqs: number[] = []): void {
 		const turn = this.store.mainTurn(conv);
 		const source = this.store.mainConsumedSource(conv);
@@ -2473,6 +2870,29 @@ export class Hub {
 	private openSession(conv: ConversationInfo) {
 		const storedPath = conv.threadId?.startsWith("/") ? conv.threadId : null;
 		const sessionPath = storedPath ?? `${this.options.sessionDir.replace(/\/$/, "")}/zgw-${conv.id}.jsonl`;
+		let agent: MergedAgentDefinition | undefined;
+		let cwd = this.options.cwd;
+		let model = this.savedModel();
+		if (conv.agentId) {
+			try {
+				const files = this.options.agents ?? new AgentFileStore();
+				agent = mergeAgentDefinition(files.read(conv.agentId), files.readDefaults());
+				cwd = join(files.root, conv.agentId, "knowledge");
+				const selected = agent.fields.model;
+				if (selected !== undefined) {
+					if (typeof selected !== "object" || selected === null ||
+						!("provider" in selected) || typeof selected.provider !== "string" || !selected.provider.trim() ||
+						!("modelId" in selected) || typeof selected.modelId !== "string" || !selected.modelId.trim()) {
+						throw new AgentDefinitionError("model", "provider and modelId required");
+					}
+					model = { provider: selected.provider, modelId: selected.modelId };
+				}
+			} catch {
+				// File/parser errors can contain private paths or definition text. Publish only the stable code.
+				this.emit(conv.id, "error", { kind: "agent-definition", message: "agent_definition_invalid" });
+				throw new AgentSessionError();
+			}
+		}
 		const opened = this.requireOmo().command<{ sessionId: string; attached?: boolean; state?: {
 			isStreaming?: boolean; pendingQuestions?: ScopedQuestionFrame[];
 			clientInputIdentity?: boolean; atomicQueuedResume?: boolean;
@@ -2480,15 +2900,18 @@ export class Hub {
 		} }>("open_session", {
 			sessionPath,
 			// Native ignores creation defaults when the session file already exists.
-			...(this.savedModel() ?? {}),
-			cwd: this.options.cwd,
+			...(model ?? {}),
+			...(typeof agent?.fields.thinking === "string" ? { thinkingLevel: agent.fields.thinking } : {}),
+			cwd,
 			permissionPreset: this.options.permissionPreset,
 			retain_on_disconnect: true,
 			kind: "interactive",
 			promptSurface: "app",
-			context: { zgw_conv: conv.id, zgw_role: "main" },
+			context: conv.agentId
+				? { zgw_conv: conv.id, zgw_role: "agent", zgw_agent: conv.agentId }
+				: { zgw_conv: conv.id, zgw_role: "main" },
 		});
-		return { sessionPath, opened };
+		return { sessionPath, opened, agent };
 	}
 
 	private watchAsk(conv: string, toolCallId: string, args: unknown): void {
@@ -2533,6 +2956,7 @@ export class Hub {
 
 	private async ensureSession(conv: ConversationInfo, duringRotation = false): Promise<OpenResult> {
 		if (this.maintenanceId) throw new MaintenanceError("maintenance_held");
+		if (!duringRotation) this.requireVisibleAgent(conv.id);
 		if (this.omoStatus !== "ready") throw new Error("omo_not_ready");
 		if (this.closeUncertain(conv.id)) throw new Error("session_close_unknown: source retained; verify native closure before retry");
 		const rt = this.rt(conv.id);
@@ -2540,9 +2964,9 @@ export class Hub {
 		if (rt.sessionId) return { sessionId: rt.sessionId, streaming: rt.running };
 		if (rt.opening) return rt.opening;
 		const generation = this.generation;
-		const { sessionPath, opened } = this.openSession(conv);
+		const { sessionPath, opened, agent } = this.openSession(conv);
 		const opening = opened
-			.then((data) => {
+			.then(async (data) => {
 				if (generation !== this.generation || this.omoStatus !== "ready") throw new Error("stale_open_session");
 				rt.sessionId = data.sessionId;
 				rt.durableId = typeof data.state?.sessionId === "string" ? data.state.sessionId : null;
@@ -2556,6 +2980,20 @@ export class Hub {
 				}
 				const owner = { conv: conv.id, scope: this.conversationScope(conv.id), sessionId: data.sessionId, sessionPath };
 				if (!this.bindScopedUiOwner(owner)) throw new Error("omo_owner_not_ready");
+				if (agent && data.attached !== true) {
+					// Notification policy is a session snapshot too; edits must not change a live session.
+					this.emit(conv.id, "agent.applied", { sha: agent.sha, at: new Date(this.now()).toISOString(), notify: agent.fields.notify === true });
+					let warnings: { code: string; message: string }[] = [];
+					try {
+						const result = await this.requireOmo().command<{ warnings?: { code: string; message: string }[] } | null>(
+							"extension_request", { sessionId: data.sessionId, name: "zgw.agent_warnings" });
+						if (Array.isArray(result?.warnings)) warnings = result.warnings;
+						else console.error(`agent startup warnings failed (${conv.id}): invalid warnings response`);
+					} catch (error) {
+						console.error(`agent startup warnings failed (${conv.id}): ${errorMessage(error)}`);
+					}
+					for (const warning of warnings) this.emit(conv.id, "notice", { kind: "agent-warning", level: "warning", ...warning });
+				}
 				this.syncScopedQuestions(owner, data.state?.pendingQuestions ?? []);
 				this.publishActivity(conv.id);
 				return { sessionId: data.sessionId, streaming: data.state?.isStreaming === true };
@@ -2577,7 +3015,7 @@ export class Hub {
 		if (!rt) {
 			rt = {
 				sessionId: null, opening: null, running: false, run: 0, rotating: false, admitting: 0, clientInputIdentity: false, atomicQueuedResume: false, durableId: null,
-				waking: null, wake: null, notified: new Set(),
+				waking: null, wake: null, notified: new Set(), promptAdmissions: new Set(),
 				itemId: null, itemText: "", statsTurnId: null, statsMessageIndex: 0,
 				rotationDone: null, finishRotation: null,
 			};
@@ -2632,9 +3070,9 @@ function unreachableQuestionText(args: unknown): string {
 	const questions = ((args as { questions?: unknown } | undefined)?.questions ?? []) as Partial<QuestionItem>[];
 	const lines = questions.map((q) => {
 		const options = (q.options ?? []).map((o) => o.label).join(" / ");
-		return `- ${q.header ? `[${q.header}] ` : ""}${q.question ?? ""}${q.multiSelect ? " (여러 개 선택 가능)" : ""}${options ? `: ${options}` : ""}`;
+		return `- ${q.header ? `[${q.header}] ` : ""}${q.question ?? ""}${q.multiSelect ? say(HUB_TEXT.multiSelect) : ""}${options ? `: ${options}` : ""}`;
 	});
-	return ["질문 창이 웹에 도착하지 않았습니다. 중단 버튼을 누른 뒤 채팅으로 답해 주세요.", ...lines].join("\n");
+	return [say(HUB_TEXT.questionUnreachable), ...lines].join("\n");
 }
 
 /** 2026-09-26T15:43:01.123Z -> 20260926T154301Z */
@@ -2705,8 +3143,10 @@ function turnFinished(entries: readonly LedgerEntry[]): boolean {
 	return last?.role === "assistant" && last.stopReason === "stop";
 }
 
-function recoveredNote(count: number): string {
-	return count > 0 ? ` 놓친 답변 ${count}개를 채웠습니다.` : "";
+/** The sentence added to a recovery notice for answers the gateway filled in while it was away (exported for tests). */
+export function recoveredNote(count: number): string {
+	if (count <= 0) return "";
+	return count === 1 ? say(HUB_TEXT.recoveredOne) : say(HUB_TEXT.recoveredMany, { count });
 }
 
 function errorMessage(error: unknown): string {