zigmini 0.8.0-beta.6 → 0.9.0-beta.1

package/src/decisions.ts

@@ -1,5 +1,7 @@
 import { isDeepStrictEqual } from "node:util";
 import { decisionContext } from "./decision-context.ts";
+import { SecurityCheckError, type MessageGuard } from "./security-check.ts";
+import { securityDecision, SecurityRuntimeError } from "./security-allow.ts";
 import type { OmoEvent } from "./omo/client.ts";
 import type { ActionAnswerData, DecisionAnswerRequest, DecisionInfo, DecisionsPageData, DecisionUpdatedData } from "./protocol.ts";
 import { blockedMainQuestion, blockedQuestion, DecisionStoreError, RESUMABLE_CLOSED, Store, type Decision, type DecisionMethod, type DecisionSubmission, type StoredEvent } from "./store.ts";
@@ -35,6 +37,15 @@ export interface DecisionServiceOptions {
 	readonly receiptTimeoutMs?: number;
 	readonly onHistory?: (event: StoredEvent) => void;
 	readonly onError?: (error: unknown) => void;
+	/** Improvement 165: the security check of answer text (value, comment, free text of each question). */
+	readonly guard?: Pick<MessageGuard, "holdOrPass">;
+}
+
+function answerTexts(request: DecisionAnswerRequest): string[] {
+	if (!("response" in request)) return [];
+	const response = request.response as { value?: unknown; comment?: unknown; answers?: Record<string, { text?: unknown }> };
+	const texts = [response.value, response.comment, ...Object.values(response.answers ?? {}).map((answer) => answer.text)];
+	return texts.filter((text): text is string => typeof text === "string");
 }
 
 function record(value: unknown): value is Record<string, unknown> {
@@ -153,6 +164,10 @@ export class DecisionService {
 	}
 
 	info(decision: Decision): DecisionInfo {
+		if (securityDecision(decision)) {
+			const security = this.store.securityHold(decision.id)?.state;
+			return { ...decision, work: null, allowedActions: [], ...(security ? { security } : {}) };
+		}
 		const work = decision.workId === null ? null : this.store.getWork(decision.workId);
 		let allowedActions: DecisionInfo["allowedActions"] = [];
 		if (unresolved(decision) && !["completed", "failed", "cancelled"].includes(work?.status ?? "") &&
@@ -189,8 +204,19 @@ export class DecisionService {
 		return this.info(this.required(id));
 	}
 
-	answer(id: string, input: unknown): DecisionInfo {
+	answer(id: string, input: unknown, checked = false): DecisionInfo {
+		const original = this.store.getDecision(id);
+		if (original && securityDecision(original)) throw new DecisionStoreError("security_endpoint_required");
 		const request = parseDecisionAnswer(input);
+		if (!checked) {
+			const owner = this.store.getDecision(id)?.ownerConv ?? "main";
+			const snapshot = structuredClone(request);
+			this.options.guard?.holdOrPass(owner, "answer", answerTexts(request), async (receipt) => {
+				receipt({ kind: "answer", decisionId: id, submissionId: snapshot.submissionId });
+				this.answer(id, snapshot, true);
+			}, { key: JSON.stringify(["answer", id, request.submissionId]), snapshot,
+				originalDecisionId: id, submissionId: request.submissionId });
+		}
 		this.refresh();
 		const before = this.required(id);
 		const binding = this.ports.liveBinding(before);
@@ -212,15 +238,15 @@ export class DecisionService {
 			try {
 				if (!this.ports.sendLive(decision)) this.review(id, "receipt_unknown");
 			} catch (error) {
-				this.error(error);
+				this.error(checked ? new SecurityRuntimeError("dispatch_unknown") : error);
 				this.review(id, "receipt_unknown");
 			}
 		} else if (operation?.data.mainInputSeq !== null && operation?.data.mainInputSeq !== undefined) {
 			const inputEvent = this.store.getEvent(operation.data.mainInputSeq);
 			if (!inputEvent) throw new Error("decision_main_intent_missing");
-			this.dispatch(id, () => this.ports.dispatchMain(inputEvent));
+			this.dispatch(id, () => this.ports.dispatchMain(inputEvent), checked);
 		} else if (operation?.data.commandId && decision.workId) {
-			this.dispatch(id, () => this.ports.dispatchWork(decision.workId!));
+			this.dispatch(id, () => this.ports.dispatchWork(decision.workId!), checked);
 		}
 		this.refresh();
 		return this.info(this.required(id));
@@ -231,6 +257,7 @@ export class DecisionService {
 	 * 취소 button; a later answer to the closed decision is rejected as a conflict.
 	 */
 	dismiss(id: string, input: unknown): DecisionInfo {
+		if (securityDecision(this.required(id))) throw new DecisionStoreError("security_endpoint_required");
 		const expectedRevision = parseDecisionDismiss(input);
 		this.refresh();
 		let dismissal;
@@ -258,9 +285,9 @@ export class DecisionService {
 		return this.info(this.required(id));
 	}
 
-	private dispatch(id: string, send: () => Promise<void>): void {
+	private dispatch(id: string, send: () => Promise<void>, protectedPayload = false): void {
 		void send().catch((error: unknown) => {
-			this.error(error);
+			this.error(protectedPayload ? new SecurityRuntimeError("dispatch_unknown") : error);
 			if (!this.stopped) this.review(id, "receipt_unknown");
 		}).finally(() => {
 			if (!this.stopped) this.refresh();
@@ -507,6 +534,7 @@ export class DecisionService {
 			this.store.reconcileDecisionReceipts();
 			const now = Date.now();
 			for (let decision of this.store.allDecisions()) {
+				if (securityDecision(decision)) continue;
 				if (!unresolved(decision)) continue;
 				const context = this.store.decisionContextReason(decision);
 				if (context === "work_failed" || context === "work_cancelled") {
@@ -534,16 +562,18 @@ export class DecisionService {
 				}
 			}
 			for (const decision of this.store.allDecisions()) {
+				if (securityDecision(decision)) continue;
 				if (decision.method === "question" && decision.status === "pending" && decision.bindingState === "live") {
 					this.store.reconcileReissuedQuestion(decision.id, this.ports.liveBinding(decision));
 				}
 			}
+			this.store.notifySecurityReceipts();
 			const all = this.store.allDecisions();
 			for (const decision of all) {
 				const previous = this.known.get(decision.id);
 				this.known.set(decision.id, decision);
 				if (!previous || previous.revision < decision.revision) {
-					if (previous && previous.status !== decision.status && !unresolved(decision)) {
+					if (!securityDecision(decision) && previous && previous.status !== decision.status && !unresolved(decision)) {
 						const answer = record(decision.answer) ? decision.answer : {};
 						const kind = decision.method === "question" ? "question" : decision.method === "confirm" ? "confirm" : "value";
 						const dismissed = decision.status === "closed" ? DISMISSED_REASONS[decision.reason ?? ""] : undefined;
@@ -564,7 +594,7 @@ export class DecisionService {
 				}
 				const times: number[] = [];
 				if (unresolved(decision) && decision.bindingState === "live" && decision.deadlineAt !== null) times.push(decision.deadlineAt);
-				if (decision.status === "submitted") {
+				if (!securityDecision(decision) && decision.status === "submitted") {
 					const operation = this.store.latestDecisionOperation(decision.id);
 					times.push(Date.parse(operation?.ts ?? decision.updatedAt) + this.receiptMs);
 				}
@@ -610,7 +640,7 @@ export class DecisionService {
 			}
 			if (!route[2] && req.method === "GET") {
 				const decision = this.required(id);
-				if (unresolved(decision)) {
+				if (!securityDecision(decision) && unresolved(decision)) {
 					let timer: ReturnType<typeof setTimeout> | undefined;
 					try {
 						await Promise.race([
@@ -630,10 +660,18 @@ export class DecisionService {
 			}
 			return Response.json({ error: "method_not_allowed" }, { status: 405 });
 		} catch (error) {
+			if (error instanceof SecurityCheckError) {
+				return Response.json({ error: error.code, message: error.message, held: error.held }, { status: 422, headers: { "Cache-Control": "no-store" } });
+			}
+			if (error instanceof SecurityRuntimeError) {
+				return Response.json({ error: error.code, ...(error.held ? { held: error.held } : {}) }, {
+					status: error.code === "held_conflict" ? 409 : 503, headers: { "Cache-Control": "no-store" },
+				});
+			}
 			if (error instanceof DecisionStoreError) {
 				return Response.json({
 					error: error.code, decision: error.decision ? this.info(error.decision) : null,
-				}, { status: error.code === "decision_not_found" ? 404 : error.code.startsWith("invalid_") ? 400 : 409 });
+				}, { status: error.code === "decision_not_found" ? 404 : error.code === "security_endpoint_required" || error.code.startsWith("invalid_") ? 400 : 409 });
 			}
 			if (error instanceof URIError) return Response.json({ error: "invalid_decision" }, { status: 400 });
 			this.error(error);

package/src/engine/compat.json

@@ -1,6 +1,6 @@
 {
-  "omo": "5.1.35",
-  "senpi": "2026.10.16",
+  "omo": "5.1.44",
+  "senpi": "2026.10.21-3",
   "threadSchema": 7,
-  "verifiedAt": "2026-10-19"
+  "verifiedAt": "2026-10-23"
 }

package/src/hub.ts

@@ -1,7 +1,7 @@
 import { scopedActionId, type DialogAnswer, type DialogGate, type DialogMethod, type DialogRequest, type DialogResolution } from "./approvals.ts";
 import type { DecisionService } from "./decisions.ts";
 import type { SttProvider } from "./adapters/voice/stt.ts";
-import { OmoCommandError, type OmoEvent, type OmoStatus } from "./omo/client.ts";
+import { blockingCompaction, compactionOutcome, OmoCommandError, type CompactionFailureKind, type OmoEvent, type OmoStatus } from "./omo/client.ts";
 import type { OmoRpc } from "./omo/generations.ts";
 import { type ActionAnswerData, type ConversationActivity, type ConversationInfo, type Envelope, type MessageReference, PROTOCOL_VERSION, type Source, type Trust } from "./protocol.ts";
 import { readFileSync, statSync } from "node:fs";
@@ -13,6 +13,11 @@ 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 { 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";
 
 export type Broadcast = (envelope: Envelope) => void;
 
@@ -35,6 +40,7 @@ const HISTORY_MAX_PAGE = 500;
 const HISTORY_MAX_RESUME = 1000;
 
 export interface HubOptions {
+	replies?: NativeReplyObserver;
 	cwd: string;
 	sessionDir: string;
 	permissionPreset: string;
@@ -59,12 +65,30 @@ export interface HubOptions {
 	versionReport?: () => Promise<string>;
 	/** Answers `/usage` (model account usage) as a notice; the command never reaches omo. */
 	usageReport?: () => Promise<string>;
+	/** Improvement 165: the security check of user text; a finding keeps the text from omo and the store. */
+	guard?: Pick<MessageGuard, "check" | "hold" | "existing">;
 }
 
 /** Anthropic rejects images over 5 MB; bigger attachments reach the agent as a file path only. */
 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;
 /** Bug 72 proposal 4: limits that rotate a session even with works, updates, decisions or questions open. */
 export type ForcedRotationReason = "size" | "compactions";
@@ -176,6 +200,9 @@ interface ConvRuntime {
 	finishRotation: (() => void) | null;
 	itemId: string | null;
 	itemText: string;
+	/** Set only by the engine's structured start event; never inferred from arrival timing. */
+	statsTurnId: string | null;
+	statsMessageIndex: number;
 }
 
 interface ContentPart {
@@ -192,7 +219,7 @@ interface SessionEntry {
 	customType?: string;
 	data?: unknown;
 	details?: { notification_id?: string };
-	message?: { role?: string; content?: ContentPart[] | string; stopReason?: string; clientInputId?: string };
+	message?: { role?: string; content?: ContentPart[] | string; stopReason?: string; errorMessage?: string; clientInputId?: string };
 }
 
 interface EntriesResult {
@@ -342,6 +369,23 @@ export class Hub {
 		this.omo = omo;
 	}
 
+	/** Explicit mode activation snapshots every existing main source before admitting new occurrences. */
+	async notificationBaseline(): Promise<void> {
+		for (const conv of this.store.listConversations()) {
+			if (!conv.threadId) continue;
+			const sessionPath = conv.threadId;
+			const generation = this.generation;
+			const revision = this.options.replies?.revision();
+			const current = () => generation === this.generation &&
+				this.store.getConversation(conv.id)?.threadId === conv.threadId;
+			await notificationHistory(conv.threadId, (entry) => {
+				if (!current()) throw new Error("reply_baseline_discarded");
+				if (revision !== undefined) this.options.replies?.observe({ sessionPath, conv: conv.id, title: conv.title }, [entry], revision);
+			}, true);
+			if (!current()) throw new Error("reply_baseline_discarded");
+		}
+	}
+
 	attachDecisions(decisions: DecisionService): void {
 		this.decisions = decisions;
 	}
@@ -706,6 +750,8 @@ export class Hub {
 			this.uiSessionScopes.clear();
 			for (const [conv, rt] of this.runtime) {
 				rt.sessionId = null;
+				rt.statsTurnId = null;
+				rt.statsMessageIndex = 0;
 				rt.opening = null;
 				rt.running = false;
 				rt.waking = null;
@@ -757,6 +803,18 @@ export class Hub {
 				} else if (this.hasUnfinishedTurn(conv.id)) await this.recoverConversation(current);
 				else if (this.openQuestionCards(conv.id, this.conversationScope(conv.id)).size > 0) await this.ensureSession(current);
 				else if (this.store.unreportedWorkUpdates(conv.id).length > 0 || this.workSummary(conv.id).length > 0) await this.ensureSession(current);
+				if (this.options.replies?.settings().mode === "all-replies" && current.threadId) {
+					if (this.rt(conv.id).sessionId) await this.syncLedger(conv.id);
+					else {
+						const sessionPath = current.threadId;
+						const revision = this.options.replies.revision();
+						await notificationHistory(sessionPath, (entry) => {
+							if (generation !== this.generation || this.omoStatus !== "ready" ||
+								this.store.getConversation(conv.id)?.threadId !== sessionPath) throw new Error("reply_history_discarded");
+							this.options.replies?.observe({ sessionPath, conv: conv.id, title: current.title }, [entry], revision);
+						});
+					}
+				}
 				// Opening main comes first. A notification ACK or worker reconciliation cannot hold readiness.
 				void this.notifyWorkUpdates(conv.id);
 			} catch (error) {
@@ -770,12 +828,17 @@ 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): Promise<void> {
+	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");
+		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 }) };
+		if (this.options.guard?.existing(context)) return;
 		const conv = this.store.getConversation(convId);
 		if (!conv) throw new Error(`unknown_conversation:${convId}`);
 		const body = text.trim();
-		const references = resolveMessageReferences(this.store, convId, referenceIds);
+		const source = structuredClone(src);
+		const references = structuredClone(resolveMessageReferences(this.store, convId, referenceIds));
 		if (this.options.versionReport && images.length === 0 && references.length === 0 && isVersionCommand(body)) {
 			this.emit(convId, "notice", { kind: "version", level: "info", message: await this.options.versionReport() });
 			return;
@@ -792,22 +855,36 @@ export class Hub {
 			throw new MessageReferenceError("message_reference_images_unavailable");
 		}
 		if (!body && attached.length === 0 && references.length === 0) return;
-		const input = this.store.acceptMainUser(convId, {
-			text: body, src, trust, ...(attached.length ? { images: attached } : {}),
-			...(references.length ? { references } : {}),
-		});
-		this.publishStored(input);
-		this.decisions?.refresh();
-		const rotationDone = this.rt(convId).rotationDone;
-		if (rotationDone) await rotationDone;
-		if (this.closeUncertain(convId)) {
-			if (this.closeRecoveries.get(convId)?.exhausted) throw new Error("session_close_recovery_exhausted");
-			this.scheduleCloseRecovery(convId);
-			this.emit(convId, "notice", { kind: "session-close-recovery", level: "info",
-				message: "세션 닫기 상태를 확인하고 있습니다. 메시지는 확인 후 전달합니다." });
+		const attachmentSnapshot = this.attachments(prompt.images);
+		const send = async (receipt?: (ref: SecurityReceipt) => void) => {
+			if (receipt && prompt.images.some((name) => !dir || !mediaFile(dir, name))) throw new SecurityRuntimeError("dispatch_failed");
+			const input = this.store.acceptMainUser(convId, {
+				text: body, src: source, trust, ...(attached.length ? { images: attached } : {}),
+				...(references.length ? { references } : {}),
+			}, receipt);
+			this.publishStored(input);
+			this.decisions?.refresh();
+			const rotationDone = this.rt(convId).rotationDone;
+			if (rotationDone) await rotationDone;
+			if (this.closeUncertain(convId)) {
+				if (this.closeRecoveries.get(convId)?.exhausted) {
+					if (receipt) throw new SecurityRuntimeError("dispatch_unknown");
+					throw new Error("session_close_recovery_exhausted");
+				}
+				this.scheduleCloseRecovery(convId);
+				this.emit(convId, "notice", { kind: "session-close-recovery", level: "info",
+					message: "세션 닫기 상태를 확인하고 있습니다. 메시지는 확인 후 전달합니다." });
+				return;
+			}
+			await this.prompt(convId, prompt.text, prompt.images, input.seq, true, attachmentSnapshot, receipt !== undefined);
+		};
+		// The approved closure owns the inspected references, body and image bytes. Never re-resolve reference ids.
+		const found = checked ? null : this.options.guard?.check([prompt.text]);
+		if (found) {
+			this.options.guard!.hold(convId, "message", found, send, body, context);
 			return;
 		}
-		await this.prompt(convId, prompt.text, prompt.images, input.seq, true);
+		await send();
 	}
 
 	/** Reserve gateway report admission before its HTTP body is parsed. The source
@@ -1233,6 +1310,8 @@ export class Hub {
 		rt.sessionId = null;
 		rt.itemId = null;
 		rt.itemText = "";
+		rt.statsTurnId = null;
+		rt.statsMessageIndex = 0;
 		rt.notified.clear();
 		const to = `${this.options.sessionDir.replace(/\/$/, "")}/zgw-${convId}-${fileStamp(this.now())}-${crypto.randomUUID().slice(0, 8)}.jsonl`;
 		this.store.rotateThread(convId, to, new Date(this.now()).toISOString(), retirement.handoff);
@@ -1550,7 +1629,7 @@ 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): Promise<void> {
+	private async prompt(convId: string, body: string, images: string[] = [], messageSeq?: number, admitted = false, attachmentSnapshot?: ReturnType<Hub["attachments"]>, protectedPayload = false): Promise<void> {
 		const conv = this.store.getConversation(convId);
 		if (!conv) return;
 		const rt = this.rt(convId);
@@ -1568,7 +1647,7 @@ export class Hub {
 			if (generation !== this.generation || this.omoStatus !== "ready" || rt.sessionId !== sessionId) return;
 			if (admitted && this.store.mainUserDispatched(convId, reference)) return;
 			const handoff = nativeCommand ? null : this.store.getSessionMeta(convId).handoff;
-			const attached = this.attachments(images);
+			const attached = attachmentSnapshot ?? this.attachments(images);
 			const text = [body, attached.note].filter(Boolean).join("\n\n");
 			const context = handoff ? `${handoff}\n\nZGW_WORK_STATE ${JSON.stringify(this.workSummary(convId))}` : null;
 			const inputId = crypto.randomUUID();
@@ -1598,6 +1677,7 @@ export class Hub {
 			this.decisions?.refresh();
 		} catch (error) {
 			if (generation !== this.generation || this.omoStatus !== "ready") return;
+			if (protectedPayload) throw new SecurityRuntimeError("dispatch_unknown");
 			const message = errorMessage(error);
 			this.emit(convId, "error", this.continuityError(message));
 		}
@@ -1690,6 +1770,28 @@ export class Hub {
 		}
 		const rt = this.rt(conv);
 		switch (event.type) {
+			case "extension_event": {
+				if (event.name === "zgw.turn_started") {
+					rt.statsTurnId = nativeTurnStarted(event.data);
+					rt.statsMessageIndex = 0;
+				} else if (event.name === "zgw.turn_stats" && rt.durableId) {
+					const measured = nativeTurnStats(event.data);
+					if (!measured) return;
+					const stored = this.store.appendTurnStats(conv, rt.durableId, measured);
+					if (stored) this.publishStored(stored);
+				}
+				return;
+			}
+			case "entry_appended": {
+				// Native emits message_end before persistence; this later event closes that gap.
+				const entry = nativeReplyEntry(event.entry);
+				if (entry && this.options.replies) {
+					this.options.replies.observe({ sessionPath: owner.sessionPath, conv, title: this.store.getConversation(conv)?.title ?? "Reply" },
+						[entry], this.options.replies.revision());
+					return;
+				}
+				return this.options.replies ? this.syncLedger(conv) : undefined;
+			}
 			case "agent_start":
 				rt.run++;
 				rt.running = true;
@@ -1717,7 +1819,7 @@ export class Hub {
 			}
 			case "message_end": {
 				const message = event.message as {
-					role?: string; content?: ContentPart[] | string; stopReason?: string; errorMessage?: string; clientInputId?: string;
+					role?: string; content?: ContentPart[] | string; stopReason?: string; errorMessage?: string; clientInputId?: string; timestamp?: unknown;
 					customType?: string; details?: { notification_id?: string };
 				} | undefined;
 				if (message?.role === "user") {
@@ -1739,12 +1841,18 @@ export class Hub {
 					return;
 				}
 				if (message?.role !== "assistant") return;
+				rt.statsMessageIndex++;
 				const itemId = rt.itemId ?? this.nextId("m");
 				const content = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content ?? [];
 				const thinking = content.filter((c) => c.type === "thinking").map((c) => c.thinking ?? "").join("\n\n").trim();
 				if (thinking) this.emit(conv, "thinking.final", { itemId, text: thinking });
 				const text = content.filter((c) => c.type === "text").map((c) => c.text ?? "").join("");
-				if (text || rt.itemText) this.emit(conv, "message.final", { itemId, text: text || rt.itemText });
+				if (text || rt.itemText) this.emit(conv, "message.final", {
+					itemId, text: text || rt.itemText,
+					...(rt.statsTurnId && rt.durableId && messageTimestamp(message.timestamp) &&
+						message.stopReason !== "aborted" && message.stopReason !== "error" && !message.errorMessage
+						? { engineTurn: { id: rt.statsTurnId, sessionId: rt.durableId, messageTimestamp: message.timestamp, messageIndex: rt.statsMessageIndex } } : {}),
+				});
 				if (message.stopReason === "aborted") {
 					this.emit(conv, "notice", { message: "작업을 중단했습니다.", level: "info" });
 				} else if (message.stopReason === "error" || message.errorMessage) {
@@ -1752,7 +1860,7 @@ export class Hub {
 				}
 				rt.itemId = null;
 				rt.itemText = "";
-				return;
+				return this.options.replies ? this.syncLedger(conv) : undefined;
 			}
 			case "tool_execution_start":
 				this.emit(conv, "progress.update", {
@@ -1776,36 +1884,43 @@ export class Hub {
 				});
 				return;
 			}
-			case "compaction_start":
-				this.emit(conv, "session.compaction", { status: "running", reason: event.reason, requestId: event.requestId });
+			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, "notice", { kind: "compaction-started", level: "info", requestId,
+					message: "대화 내용을 요약하고 있습니다. 완료될 때까지 기다려 주세요." });
 				return;
+			}
 			case "compaction_end": {
-				const failed = typeof event.errorMessage === "string" || event.accepted === false ||
-					(event.accepted !== true && (typeof event.result !== "object" || event.result === null));
+				if (!blockingCompaction(event) || this.compactionSeen(conv, event, true)) return;
+				const requestId = typeof event.requestId === "string" ? event.requestId : undefined;
+				const outcome = compactionOutcome(event);
 				this.emit(conv, "session.compaction", {
-					status: event.aborted === true ? "cancelled" : failed ? "failed" : "completed",
-					reason: event.reason,
-					requestId: event.requestId,
-					accepted: event.accepted,
-					error: event.errorMessage,
-					rejectionCause: event.rejectionCause,
+					...outcome, requestId, accepted: outcome.status === "completed",
 				});
-				if (event.aborted === true) {
-					this.emit(conv, "notice", {
-						kind: "compaction-cancelled",
-						level: "warning",
-						message: "컨텍스트 압축이 취소됐습니다. 같은 세션을 유지하며 이전 입력을 자동으로 다시 보내지 않습니다.",
-					});
-				} else if (failed) {
-					this.emit(conv, "error", {
-						kind: "compaction-failed",
-						message: `컨텍스트 압축 실패: ${event.errorMessage ?? event.rejectionCause ?? "완료 결과가 없습니다"}. 같은 세션을 유지합니다. 원인을 해결한 뒤 계속할 지시를 보내 주세요. 이전 입력은 자동 재전송하지 않습니다.`,
-					});
+				switch (outcome.status) {
+					case "cancelled":
+						this.emit(conv, "notice", { kind: "compaction-cancelled", level: "warning", requestId,
+							message: "대화 요약을 취소했습니다. 이전 내용과 같은 세션을 유지합니다. 이전 입력은 자동으로 다시 보내지 않습니다." });
+						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}` });
+						break;
+					}
+					case "completed":
+						this.emit(conv, "notice", { kind: "compaction-completed", level: "info", requestId,
+							message: "대화 요약을 완료했습니다. 같은 세션에서 계속합니다." });
+						break;
 				}
 				return;
 			}
 			case "agent_settled": {
 				rt.running = false;
+				rt.statsTurnId = null;
+				rt.statsMessageIndex = 0;
 				this.publishActivity(conv);
 				this.unwatchConversation(conv);
 				this.dialogs.cancelScope(owner.scope, "작업이 끝났습니다.");
@@ -1828,6 +1943,8 @@ export class Hub {
 				this.releaseScopedUiOwner(owner);
 				rt.sessionId = null;
 				rt.durableId = null;
+				rt.statsTurnId = null;
+				rt.statsMessageIndex = 0;
 				rt.running = false;
 				this.publishActivity(conv);
 				rt.run++;
@@ -2230,6 +2347,7 @@ export class Hub {
 	}
 
 	private async readLedger(conv: string): Promise<void> {
+		const replyRevision = this.options.replies?.revision();
 		const rt = this.rt(conv);
 		const generation = this.generation;
 		const sessionId = rt.sessionId;
@@ -2246,7 +2364,10 @@ export class Hub {
 				const result = await this.requireOmo().command<EntriesResult>("get_entries", { sessionId, since });
 				logLedgerRead(conv, "since", result);
 				if (!current()) throw new LedgerReadDiscarded();
-				this.store.appendLedger(conv, { sessionPath, durableId, lastEntryId: since }, ledgerEntries(result.entries), result.leafId);
+				const entries = ledgerEntries(result.entries);
+				// Persist notification identity before advancing the native history cursor.
+				if (replyRevision !== undefined) this.options.replies?.observe({ sessionPath, conv, title: this.store.getConversation(conv)?.title ?? "Reply" }, result.entries, replyRevision);
+				this.store.appendLedger(conv, { sessionPath, durableId, lastEntryId: since }, entries, result.leafId);
 				return;
 			} catch (error) {
 				if (!(error instanceof OmoCommandError) || !error.code.startsWith("Entry not found")) throw error;
@@ -2256,10 +2377,13 @@ export class Hub {
 		// A full read is the one unbounded response the ledger asks for: one at a time across conversations.
 		const rebuild = this.ledgerRebuilds.then(async () => {
 			if (!current()) throw new LedgerReadDiscarded();
+			const rebuildReplyRevision = this.options.replies?.revision();
 			const result = await this.requireOmo().command<EntriesResult>("get_entries", { sessionId });
 			logLedgerRead(conv, "full", result);
 			if (!current()) throw new LedgerReadDiscarded();
-			this.store.rebuildLedger(conv, sessionPath, durableId, ledgerEntries(result.entries), result.leafId);
+			const entries = ledgerEntries(result.entries);
+			if (rebuildReplyRevision !== undefined) this.options.replies?.observe({ sessionPath, conv, title: this.store.getConversation(conv)?.title ?? "Reply" }, result.entries, rebuildReplyRevision);
+			this.store.rebuildLedger(conv, sessionPath, durableId, entries, result.leafId);
 		});
 		this.ledgerRebuilds = rebuild.catch(() => undefined);
 		await rebuild;
@@ -2361,6 +2485,7 @@ export class Hub {
 			permissionPreset: this.options.permissionPreset,
 			retain_on_disconnect: true,
 			kind: "interactive",
+			promptSurface: "app",
 			context: { zgw_conv: conv.id, zgw_role: "main" },
 		});
 		return { sessionPath, opened };
@@ -2453,7 +2578,7 @@ export class Hub {
 			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(),
-				itemId: null, itemText: "",
+				itemId: null, itemText: "", statsTurnId: null, statsMessageIndex: 0,
 				rotationDone: null, finishRotation: null,
 			};
 			this.runtime.set(conv, rt);
@@ -2470,6 +2595,17 @@ export class Hub {
 		this.emit("main", "notice", { kind: "update", level: "info", message });
 	}
 
+	/** Persisted lifecycle records also deduplicate a terminal replay after a gateway restart. */
+	private compactionSeen(conv: string, event: OmoEvent, terminal: boolean): boolean {
+		if (typeof event.requestId !== "string") return false;
+		return this.store.eventsAfter(conv, this.store.lastSeq(conv, "session.rotated")).some((stored) => {
+			if (stored.type !== "session.compaction") return false;
+			const data = stored.data;
+			return typeof data === "object" && data !== null && "requestId" in data && data.requestId === event.requestId &&
+				(!terminal || ("status" in data && data.status !== "running"));
+		});
+	}
+
 	private emit(conv: string, type: string, data: unknown, persist = true): StoredEvent | null {
 		const stored = persist && conv !== "*" ? this.store.appendEvent(conv, type, data) : null;
 		if (stored) this.publishStored(stored);