zigmini 0.9.0-beta.2 → 0.9.0-beta.3

package/host/omo-check/patches/omo-5.1.48-gateway-port.manifest.json

@@ -1,11 +1,11 @@
 {
   "schema": 1,
-  "revision": 2,
+  "revision": 3,
   "upstream": {
     "omo": "5.1.48",
     "senpi": "2026.10.25-2"
   },
-  "candidate": "<zigmini home>/omo/5.1.48-zgw.2",
+  "candidate": "<zigmini home>/omo/5.1.48-zgw.3",
   "pristine": "<zigmini home>/omo/5.1.48",
   "entrypoint": "node_modules/@code-yeongyu/senpi/dist/cli.js",
   "patchRoot": "node_modules",
@@ -13,7 +13,8 @@
     "omo-5.1.48-rpc-port.patch",
     "omo-5.1.48-compaction-port.patch",
     "omo-5.1.48-provider-port.patch",
-    "omo-5.1.48-runtime-compat.patch"
+    "omo-5.1.48-runtime-compat.patch",
+    "omo-5.1.48-compaction-recovery.patch"
   ],
   "files": [
     {
@@ -24,7 +25,7 @@
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/agent-session.js",
       "originalSha256": "7275ef36a6e5368eaea0d507644208c406f83bfaee2004984b9f94ac348ecc02",
-      "patchedSha256": "80ea2e80fbe4ed72ef42688d453531a78530d89a2d2367a7081f6432bf63b6ba"
+      "patchedSha256": "312825f603d98af540512ff0ee1c02da9ae54d081535a7b851fd788c9b65937d"
     },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/auth-storage.js",
@@ -79,7 +80,7 @@
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/stream.js",
       "originalSha256": "600dd50df1f34d7367636510a5e63106d674024454ac0c0501d97a266098c489",
-      "patchedSha256": "98c03ca2f9ca197e544702ec070ef107de3840eb9870f2201663b48b78af8e2b"
+      "patchedSha256": "86436c9ba31895ad99da8fd097b3a7dbbcfd71325a959ae574e93c642a2b4623"
     },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/ask-user/pending.js",
@@ -114,7 +115,7 @@
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/context-reduction-lifecycle.js",
       "originalSha256": "6c2a30053a0ff1d8c2c16471ac329f9927777c821dd1fb3c5e73a8bbd7c9e06b",
-      "patchedSha256": "3118a8e4348ff39656b9058dadc4c32bec56bb1bb48b0070bd850e1fdcb51900"
+      "patchedSha256": "b6ebc56683a9abd768f4bc1dfaddaea28dbdc7a24586254729700836d93f3a5e"
     },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/deterministic-fallback.js",
@@ -134,7 +135,7 @@
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/index.js",
       "originalSha256": "090f17d798e47486e038dc673cf5f20fbd66c54fda73460b20f0d8c770793645",
-      "patchedSha256": "5580493390b03e88bc99794f483da7136ab416affe380968ceed504e0d0b4a66"
+      "patchedSha256": "861ecef9412c7dd7014f2424fc9be18fbec5668e65318b5f51075e1efa463489"
     },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/lane-policy.js",
@@ -194,7 +195,7 @@
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative-summary.js",
       "originalSha256": "25dc617e8b999f7b38e638287df81790768279aa78a607e692ccd2b108b88ada",
-      "patchedSha256": "eca87198f3fd588b30bb3dd8b869cff7869caeef39bb5d709d47735da1528fac"
+      "patchedSha256": "103b36b2a4f2755d6ea349ac4e0c38b84058e88adaa15ddecc5605db15718638"
     },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.d.ts",
@@ -204,7 +205,7 @@
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/speculative.js",
       "originalSha256": "55332e85de550ea1b3f0c25df4898897fbe646c468fe7bf82ddacb16742becc7",
-      "patchedSha256": "bc8fc57e0ceabc890c93d251890958cc456f3b8ea3b7d8423897f584ca23175b"
+      "patchedSha256": "d3a50b066cee5d21a67af0dff3df7c4e1664159f6c2ad1376c405685f102e74a"
     },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/compaction/task-intent.js",
@@ -249,12 +250,12 @@
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/runner.js",
       "originalSha256": "bdd693f5c91dcf507b81262b19c48c5e721070033a75a59de3b0407144fe4346",
-      "patchedSha256": "c749c3663150d7dd26aab7687d7f81980be148732dcdb29033387c7170a9e081"
+      "patchedSha256": "46ee33b918130620bd08c4ba26f402b8274c71e7f7ccf41f9bdc7ca775a439a7"
     },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/types.d.ts",
       "originalSha256": "2bce6e8eec55ef835de724b7b62c8b02afda8e445ad873633bf25da07d37ea1a",
-      "patchedSha256": "e29250ad513e7e584ea11aef07e5f64012624c7f68faa7d80c13e5289866d5a1"
+      "patchedSha256": "359a267b3aec385dacc2f5809addcf6d395eb96610c67cd2914053ecae1fb8ee"
     },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/model-runtime.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigmini",
-  "version": "0.9.0-beta.2",
+  "version": "0.9.0-beta.3",
   "type": "module",
   "bin": {
     "zigmini": "bin/zigmini"

package/src/hub.ts

@@ -13,7 +13,7 @@ import { isVersionCommand, VERSION_COMMAND } from "./version.ts";
 import { isUsageCommand, USAGE_COMMAND } from "./usage.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";
@@ -52,7 +52,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;
@@ -87,9 +87,62 @@ const COMPACTION_RECOVERY = {
 	context_budget: { action: "retry", message: "요약 결과가 대화 모델의 입력 한도에 맞지 않습니다. 원인을 해결한 뒤 다시 진행해 주세요." },
 	stale: { action: "retry", message: "요약 중 대화가 바뀌었습니다. 최신 대화에서 다시 진행해 주세요." },
 	provider: { action: "retry", message: "원인을 해결한 뒤 다시 진행해 주세요." },
+	account_blocked: { action: "account", message: "요약 공급자의 계정 묶음이 요청을 보내지 않았습니다. 원인이 사용 한도인지 인증인지는 확정되지 않았습니다. 계정 상태를 확인하거나 다른 모델을 고른 뒤 다시 진행해 주세요." },
 } as const satisfies Record<CompactionFailureKind, { readonly action: string; readonly message: string }>;
 
-export type RotationReason = "manual" | "age" | ForcedRotationReason;
+/** 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 +159,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 +204,7 @@ 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 = "대화 요약이 끝나지 않아 엔진이 이 메시지를 받지 않았습니다. 메시지는 기록에 남아 있고 자동으로 다시 보내지 않습니다. 요약 실패 원인을 해결하거나 '새 세션'을 눌러 주세요.";
 
 interface OpenResult {
 	sessionId: string;
@@ -189,6 +247,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. */
@@ -659,6 +718,8 @@ 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;
 
 	/** 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 +732,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 }
@@ -1185,7 +1247,8 @@ export class Hub {
 		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;
@@ -1243,7 +1306,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 +1351,92 @@ 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: "세션 교체 중" }, 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. */
+	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 };
+			if (data.status === "completed") break;
+			if (data.status === "failed" && 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 +1453,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 +1474,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: `새 엔진 세션으로 교체했습니다 (${this.reasonLabel(retirement.reason)}). 화면의 대화 기록은 그대로이고, 다음 메시지부터 새 세션에서 이어집니다.${
+				retirement.reason === "compaction_failed" ? " 이전 세션 파일은 그대로 남겨 두었고, 받지 못한 메시지는 자동으로 다시 보내지 않습니다." : ""}` });
 	}
 
 	private closeTimer(callback: () => void, ms: number): ReturnType<typeof setTimeout> {
@@ -1595,6 +1752,7 @@ export class Hub {
 		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}번 더 이어짐`;
+		if (reason === "compaction_failed") return `대화 요약이 ${this.freshSessionCompactionFailures()}번 연속 실패함`;
 		return reason === "manual" ? "직접 요청" : `세션이 ${hours}시간을 넘겨 쉬는 중`;
 	}
 
@@ -1617,7 +1775,7 @@ export class Hub {
 		}
 		return [
 			`[게이트웨이 알림] 이 대화는 새 엔진 세션으로 교체됐습니다 (${this.reasonLabel(reason)}).`,
-			from ? `이전 세션의 전체 기록은 ${from} 에 남아 있습니다. 파일이 크니 필요할 때 필요한 부분만 검색해서 보세요.` : "",
+			from ? `이전 세션의 전체 기록은 ${from} 에 남아 있습니다. 파일이 크니 필요할 때 끝부분이나 필요한 부분만 검색해서 보고, 전체를 읽지 마세요.` : "",
 			...this.handoffOpenItems(conv),
 			"아래는 직전 대화의 최근 부분입니다. 맥락으로만 참고하세요.",
 			"---",
@@ -1635,14 +1793,23 @@ export class Hub {
 		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 +1827,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 +1844,19 @@ 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;
 			const message = errorMessage(error);
-			this.emit(convId, "error", this.continuityError(message));
+			this.emit(convId, "error", refused ? { kind: "compaction-required", message: COMPACTION_REQUIRED_MESSAGE } : this.continuityError(message));
+		} finally {
+			releaseAdmission();
 		}
 	}
 
@@ -1908,6 +2085,9 @@ export class Hub {
 						const recovery = COMPACTION_RECOVERY[outcome.failureKind];
 						this.emit(conv, "error", { kind: "compaction-failed", requestId, failureKind: outcome.failureKind,
 							action: recovery.action, message: `대화 요약에 실패했습니다. 이전 내용은 유지했습니다. ${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":
@@ -2577,7 +2757,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,
 			};

package/src/omo/client.ts

@@ -25,6 +25,8 @@ export interface OmoEvent {
 export const COMPACTION_FAILURE_KINDS = [
 	"invalid_model", "auth_missing", "auth_expired", "quota", "org_denied", "model_unavailable",
 	"refused", "timeout", "incomplete", "empty", "context_budget", "stale", "provider",
+	// Bug 223: the provider's local account pool refused to send; quota versus auth is not known.
+	"account_blocked",
 ] as const;
 export type CompactionFailureKind = typeof COMPACTION_FAILURE_KINDS[number];
 export type CompactionOutcome =