zigmini 0.8.0-beta.6 → 0.8.0-beta.7

package/src/work.ts

@@ -3,6 +3,7 @@ import { isAbsolute, join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { OmoCommandError, type OmoClient, type OmoEvent, type OmoStatus } from "./omo/client.ts";
 import { DecisionStoreError, Store, WorkStoreError, type LedgerState, type MainInput, type StoredEvent, type WorkCommand, type WorkItem, type WorkReport, type WorkUpdateKind } from "./store.ts";
+import { nativeReplyEntry, type NativeReplyEntry, type NativeReplyObserver } from "./reply-notifications.ts";
 
 const ACK_TIMEOUT_MS = 30_000;
 const PREFIX = "ZGW_WORK_COMMAND ";
@@ -15,7 +16,7 @@ type State = {
 	ordered?: { text: string; mode?: string; clientInputId?: string }[];
 	pendingQuestions?: OmoEvent[]; atomicQueuedResume?: boolean; queueEpoch?: string;
 };
-type Entry = { id: string; type: string; customType?: string; data?: unknown; message?: { role: string; content: unknown } };
+type Entry = NativeReplyEntry & { id: string; type: string; customType?: string; data?: unknown };
 export interface WorkSessionOwner {
 	readonly conv: string;
 	readonly scope: `work:${string}`;
@@ -30,6 +31,7 @@ export interface WorkRequest {
 	payload: RecordValue;
 }
 export interface WorkRouterOptions {
+	replies?: NativeReplyObserver;
 	sessionDir: string;
 	permissionPreset: string;
 	/** Invoked only for newly committed events. Task 6 also uses this boundary for report-turn metadata. */
@@ -121,6 +123,16 @@ export class WorkRouter {
 	}
 
 	private get ready(): boolean { return !this.stopped && this.status === "ready" && this.omo.currentStatus === "ready"; }
+	/** Includes finished, normally lazy sources so enabling never backfills their old replies. */
+	async notificationBaseline(): Promise<void> {
+		for (const work of this.allWorks()) {
+			const binding = await this.ensure(work);
+			const revision = this.options.replies?.revision();
+			const entries = await this.wholeSession(binding.sessionId, () => this.current(work.id, binding));
+			if (!entries || !this.current(work.id, binding)) throw new Error("reply_baseline_discarded");
+			if (revision !== undefined) this.options.replies?.observe({ sessionPath: work.sessionPath, conv: work.ownerConv, workId: work.id, title: work.title }, entries, revision);
+		}
+	}
 	private allWorks(): WorkItem[] { return this.store.listConversations().flatMap((conv) => this.store.listWorks(conv.id)); }
 	private work(id: string): WorkItem { const work = this.store.getWork(id); if (!work) throw new RoutingError("work_not_found", 404); return work; }
 	private current(workId: string, binding: Binding): boolean { return this.ready && binding.generation === this.generation && this.bindings.get(workId) === binding; }
@@ -463,7 +475,7 @@ export class WorkRouter {
 		const saved = this.store.getSetting("omo.model");
 		const model: { provider: string; modelId: string } | null = saved ? JSON.parse(saved) : null;
 		const promise = this.omo.command<{ sessionId: string; attached?: boolean; state?: State }>("open_session", {
-			sessionPath: work.sessionPath, cwd: work.cwd, permissionPreset: this.options.permissionPreset, kind: "worker", retain_on_disconnect: true, auto_title: false,
+			sessionPath: work.sessionPath, cwd: work.cwd, permissionPreset: this.options.permissionPreset, kind: "worker", promptSurface: "app", retain_on_disconnect: true, auto_title: false,
 			// Native applies these only on first creation, never on a persisted resume.
 			...(model ? { provider: model.provider, modelId: model.modelId } : {}),
 			context: { zgw_role: "work", zgw_work: work.id, zgw_conv: work.ownerConv },
@@ -580,11 +592,16 @@ export class WorkRouter {
 	private async readEvidence(workId: string): Promise<void> {
 		const work = this.work(workId);
 		const binding = await this.ensure(work);
+		let replyRevision = this.options.replies?.revision();
 		const [entries, state] = await Promise.all([
-			this.entriesAfter(binding.sessionId, this.store.workEntryCursor(workId), () => this.current(workId, binding)),
+			this.entriesAfter(binding.sessionId, this.store.workEntryCursor(workId), () => {
+				replyRevision = this.options.replies?.revision();
+				return this.current(workId, binding);
+			}),
 			this.omo.command<State>("get_state", { sessionId: binding.sessionId }),
 		]);
 		if (!entries || !this.current(workId, binding)) return;
+		if (replyRevision !== undefined) this.options.replies?.observe({ sessionPath: work.sessionPath, conv: work.ownerConv, workId, title: work.title }, entries, replyRevision);
 		if (typeof state.isStreaming === "boolean") this.options.onRuntime?.(workId, state.isStreaming);
 		for (const entry of entries) {
 			if (entry.type === "custom" && (entry.customType === "zgw.native_permission_asked" || entry.customType === "zgw.native_permission_replied")) {
@@ -644,6 +661,12 @@ export class WorkRouter {
 		const [workId, binding] = found;
 		if (!this.current(workId, binding)) return false;
 		this.options.onWorkEvent?.(workId, event);
+		if (this.options.replies && event.type === "entry_appended") {
+			const entry = nativeReplyEntry(event.entry);
+			const work = this.work(workId);
+			if (entry) this.options.replies.observe({ sessionPath: work.sessionPath, conv: work.ownerConv, workId, title: work.title },
+				[entry], this.options.replies.revision());
+		}
 		if (event.type === "extension_ui_request" && event.method === "notify" && this.store.isOmoCheckWork(workId)) {
 			// Preserve attribution before Hub turns the frame into an unattributed main-chat notice.
 			const sourceKey = `omo-check-notice:${typeof event.id === "string" ? event.id : crypto.randomUUID()}`;
@@ -725,8 +748,10 @@ export class WorkRouter {
 		// the native per-connection queue and the bridge frontend budget, dropping this connection.
 		for (const work of works) {
 			if (!this.ready || generation !== this.generation) return;
-			// Finished sessions are opened on demand by owner(), reconcile() or dispatch().
+			// A completed report may precede the final assistant reply. Enabled notifications
+			// must recover that tail even when command delivery already reached its terminal state.
 			if (["completed", "failed", "cancelled"].includes(work.status) &&
+				this.options.replies?.settings().mode !== "all-replies" &&
 				!this.store.listWorkCommands(work.id).some((command) => ["pending", "sending", "unknown"].includes(command.delivery))) continue;
 			try {
 				await this.reconcile(work.id);

package/web/app.js

@@ -28,6 +28,7 @@ import { hasTextSelection, panelShortcut } from "./shortcuts.js";
 import { decisionCommand, lastSentLabel, lastSentTooltip, nextLastSent } from "./lastsent.js";
 import { installTooltips } from "./tooltip.js";
 import { placeRow, unseenEvents } from "./chatorder.js";
+import { createTurnStats } from "./turn-stats.js";
 import { cardsOfDecision } from "./cardbind.js";
 import { createRecall, recallKey, resetRecall } from "./recall.js";
 import {
@@ -42,6 +43,7 @@ import {
 import { createEnrollment, NO_DEVICES_LINE, REVOKE_ARMED_LABEL, REVOKE_LABEL } from "./enroll.js";
 import { canUpdate, checkFailedLine, noticeLine, parseNotice, progressLine, questionGate, resultLine, UPDATE_CHECK_PATH, UPDATE_CONSENT_PATH, UPDATE_PATH, UPDATE_STATE_PATH, UPDATE_STATUS_PATH, updateStep, updateView } from "./update.js";
 import { createAppDownload } from "./app-download.js";
+import { setupNotificationSettings } from "./notifications.js";
 import { cleanRequest, cleanResultLine, GC_CLEAN_PATH, GC_PATH, gcView, selectAllState, selectAllTarget } from "./gc.js";
 import { manualFailureText, manualLinkLang, manualUrl, otherLang } from "./manual.js";
 
@@ -60,6 +62,7 @@ const state = {
 // Work activity the gateway reports per conversation (snapshot + activity.updated). It drives the avatar only;
 // state.running stays the sole input of #interrupt, and history pages never write here.
 const activity = createActivity();
+const turnStats = createTurnStats();
 const HISTORY_PAGE = 100;
 // Loaded window of the current conversation's stored events (by seq), for resuming after a reconnect and paging back.
 let hist = { conv: null, oldest: null, newest: 0, hasMore: false, loading: false, seen: new Set() };
@@ -984,8 +987,12 @@ function renderEvent(e, fromHistory = false) {
 			}
 			const source = referenceSource(e);
 			if (source) markReferenceable(body.parentElement, source);
+			turnStats.accept(e, body);
 			break;
 		}
+		case "message.stats":
+			turnStats.accept(e);
+			break;
 		case "progress.update":
 			renderProgress(e);
 			break;
@@ -1096,6 +1103,7 @@ function rememberSent(e) {
 
 function clearMessages(conv) {
 	els.messages.innerHTML = "";
+	turnStats.reset(conv);
 	setLastSent(null);
 	recall.sent.length = 0;
 	resetRecall(recall.rec);
@@ -1318,6 +1326,18 @@ function onServerEvent(e, generation, statusGeneration) {
 			showUpdateProgress(resultLine(e.data));
 			loadUpdateStatus();
 			return;
+		case "security-check.updated":
+			applySecurityBody(e.data);
+			return;
+		case "notifications.updated":
+			notificationSettings.updated(e.data);
+			return;
+		case "security-check.held":
+			showHeldCard(e.data);
+			return;
+		case "security-check.resolved":
+			markHeld(e.data.id, e.data.outcome);
+			return;
 		case "voice.updated":
 			voice.reads += 1;
 			void applyVoiceSetting(voiceEnabledFrom(e.data));
@@ -1648,6 +1668,9 @@ function connect() {
 		sendWebPresence();
 		resendPendingReportSpeech();
 		void readVoiceSetting();
+		void readSecuritySetting();
+		void notificationSettings.connect();
+		void readHeld();
 		void readVoiceInstall();
 		// Also after an update restarted the gateway: the new version and the update result show without a reload.
 		loadUpdateStatus();
@@ -1666,6 +1689,7 @@ function connect() {
 		state.sessionTransitions.clear();
 		renderSessionTransition();
 		inbox.online = false;
+		notificationSettings.disconnect();
 		historyRequests.length = 0;
 		renderInboxOnline();
 		setTimeout(connect, 1500);
@@ -2482,6 +2506,134 @@ async function setVoiceEnabled(enabled) {
 voiceButton.onclick = () => setVoiceEnabled(!voice.enabled);
 renderVoiceToggle();
 
+// ---- Improvement 165: the security check of every user message (settings toggle, blocked draft back in the composer) ----
+const SECURITY_CHECK_PATH = "/api/settings/security-check";
+const notificationSettings = setupNotificationSettings({ choice: $("notification-mode"), status: $("notification-status") });
+const security = { enabled: true, busy: false };
+const securityButton = $("toggle-security");
+
+function renderSecurityToggle() {
+	securityButton.textContent = security.enabled ? "보안검사 켜짐" : "보안검사 꺼짐";
+	securityButton.setAttribute("aria-pressed", String(security.enabled));
+	securityButton.classList.toggle("on", security.enabled);
+}
+
+function applySecurityBody(body) {
+	if (typeof body?.enabled === "boolean") security.enabled = body.enabled;
+	renderSecurityToggle();
+}
+
+async function readSecuritySetting() {
+	try {
+		const res = await fetch(SECURITY_CHECK_PATH, { cache: "no-store" });
+		if (res.ok) applySecurityBody(await res.json());
+	} catch {
+		// Offline: the reconnect reads it again.
+	}
+}
+
+async function setSecurityEnabled(enabled) {
+	if (security.busy) return;
+	security.busy = true;
+	try {
+		const res = await fetch(SECURITY_CHECK_PATH, { method: "PUT", headers: { "content-type": "application/json" }, body: JSON.stringify({ enabled }) });
+		const body = await res.json().catch(() => ({}));
+		if (!res.ok) throw new Error(body.error ?? String(res.status));
+		applySecurityBody(body);
+	} catch (err) {
+		systemLine(`보안검사 설정을 바꾸지 못했습니다: ${err instanceof Error ? err.message : err}`, true);
+	} finally {
+		security.busy = false;
+	}
+}
+
+/** A held text comes back into an empty composer of its conversation, so the user can fix it and send again. */
+function restoreDraft(conv, text) {
+	if (typeof text !== "string" || state.current !== conv || els.input.value !== "") return;
+	els.input.value = text;
+	els.input.focus();
+}
+
+// The card is built here from the gateway's held entry and never passes through the engine; values are shown as text.
+const heldCards = new Map();
+
+function showHeldCard(held) {
+	if (!held || typeof held.id !== "string" || heldCards.has(held.id)) return;
+	const card = document.createElement("div");
+	card.className = "msg system security-card";
+	card.dataset.heldId = held.id;
+	card.setAttribute("role", "group");
+	const title = make("div", "security-title", held.source === "answer" ? "보안검사 결과 (확인함 답)" : "보안검사 결과");
+	const list = document.createElement("ul");
+	list.className = "security-list";
+	for (const o of held.occurrences ?? []) {
+		const item = document.createElement("li");
+		item.append(make("span", "security-kind", o.label), " ", make("code", "security-value", o.value), " ", make("span", "security-place", `${o.line}줄 ${o.column}칸`));
+		list.append(item);
+	}
+	const question = make("p", "security-question", "이 값들을 노출해도 되겠습니까? 보내기를 누르면 원래 메시지를 그대로 엔진에 보냅니다.");
+	const actions = make("div", "security-actions");
+	const sendButton = make("button", "btn", "보내기");
+	const dropButton = make("button", "btn neutral", "보내지 않기");
+	sendButton.type = dropButton.type = "button";
+	sendButton.onclick = () => void decideHeld(held, true);
+	dropButton.onclick = () => void decideHeld(held, false);
+	actions.append(sendButton, dropButton);
+	const status = make("p", "security-status");
+	status.setAttribute("role", "status");
+	card.append(title, list, question, actions, status);
+	heldCards.set(held.id, { card, held });
+	if (held.conv === state.current || held.source === "answer") {
+		els.messages.append(card);
+		scrollToBottom(true);
+	}
+}
+
+function markHeld(id, outcome, message) {
+	const entry = heldCards.get(id);
+	if (!entry) return;
+	for (const button of entry.card.querySelectorAll("button")) button.disabled = true;
+	const status = entry.card.querySelector(".security-status");
+	status.textContent = message ?? (outcome === "sent" ? "보냈습니다." : outcome === "lost" ? "게이트웨이가 다시 시작해 보류 메시지가 사라졌습니다. 엔진에는 보내지 않았습니다." : "보내지 않았습니다. 메시지를 버렸습니다.");
+	entry.card.classList.add("done");
+	if (outcome !== "sent" && entry.held.source === "message") restoreDraft(entry.held.conv, entry.held.draft);
+}
+
+async function decideHeld(held, send) {
+	const entry = heldCards.get(held.id);
+	if (!entry || entry.card.classList.contains("done")) return;
+	for (const button of entry.card.querySelectorAll("button")) button.disabled = true;
+	try {
+		const res = await fetch(`/api/security-check/held/${encodeURIComponent(held.id)}`, {
+			method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ send }),
+		});
+		const body = await res.json().catch(() => ({}));
+		if (res.status === 404) markHeld(held.id, "lost");
+		else if (!res.ok) markHeld(held.id, "failed", `보내지 못했습니다: ${body.message ?? body.error ?? res.status}`);
+		else markHeld(held.id, body.outcome);
+	} catch (err) {
+		for (const button of entry.card.querySelectorAll("button")) button.disabled = false;
+		entry.card.querySelector(".security-status").textContent = `연결 오류: ${err instanceof Error ? err.message : err}`;
+	}
+}
+
+/** On every connect: cards still held come back; a card whose entry is gone (gateway restart) is marked lost. */
+async function readHeld() {
+	try {
+		const res = await fetch("/api/security-check/held", { cache: "no-store" });
+		if (!res.ok) return;
+		const { held } = await res.json();
+		const ids = new Set(held.map((h) => h.id));
+		for (const [id, entry] of heldCards) if (!ids.has(id) && !entry.card.classList.contains("done")) markHeld(id, "lost");
+		for (const h of held) showHeldCard(h);
+	} catch {
+		// Offline: the next connect reads again.
+	}
+}
+
+securityButton.onclick = () => setSecurityEnabled(!security.enabled);
+renderSecurityToggle();
+
 // ---- Todo 26: an npm install installs the voice servers on demand; the button is hidden everywhere else ----
 const voiceInstallButton = $("voice-install");
 
@@ -3175,6 +3327,12 @@ function settleSubmit(decision, result) {
 			noteConflict(inbox.state, decision, result.decision);
 			noteFor(id, "다른 곳에서 먼저 처리됐거나 질문이 바뀌었습니다. 최신 내용을 확인하고 다시 골라 주세요.", true);
 			break;
+		case "blocked":
+			// Improvement 165: the answer is held; the card decides. The typed answer stays in the form for a fix.
+			inbox.state.drafts.delete(id);
+			noteFor(id, `${result.message} 채팅의 보안검사 결과 카드에서 보내기 또는 보내지 않기를 고르세요.`, true);
+			if (result.held) showHeldCard(result.held);
+			break;
 		case "rejected":
 			inbox.state.drafts.delete(id);
 			if (result.decision) applyDecision(inbox.state, result.decision);

package/web/decisions.js

@@ -473,6 +473,9 @@ export function interpretAnswerResponse(status, body) {
 	if (status === 409) return { kind: "conflict", decision, error };
 	if (status === 404) return { kind: "gone", error };
 	if (status === 400) return { kind: "rejected", decision, error };
+	if (status === 422 && error === "security_check_blocked") {
+		return { kind: "blocked", error, held: record(body.held) ? body.held : null, message: typeof body.message === "string" ? body.message : "보안검사에 걸려 보내지 않고 보류했습니다." };
+	}
 	return { kind: "unavailable", status, error };
 }
 

package/web/index.html

@@ -177,6 +177,22 @@
         <p class="enroll-message" id="apk-message" role="status" aria-live="polite"></p>
         <div class="enroll-actions"><button type="button" class="text-btn" id="apk-renew" hidden>새로 만들기</button></div>
       </section>
+      <section class="settings-section security-check" id="security-check" aria-labelledby="security-check-title">
+        <div class="section-label"><span id="security-check-title">보안검사</span></div>
+        <p class="update-line">보낸 메시지에 비밀키, 토큰, 비밀번호, 홈 폴더 경로, 내부 IP 같은 값이 있으면 엔진에 보내지 않고 보류한 뒤, 값을 보여 주고 보낼지 묻습니다.</p>
+        <div class="update-buttons"><button type="button" class="text-btn" id="toggle-security" aria-pressed="true">보안검사 켜짐</button></div>
+      </section>
+      <section class="settings-section" id="notification-settings" aria-labelledby="notification-title">
+        <div class="section-label"><label id="notification-title" for="notification-mode">알림</label></div>
+        <div class="access-form">
+          <select class="access-input" id="notification-mode" aria-describedby="notification-description notification-status" disabled>
+            <option value="inbox-only" selected>확인함 알림만</option>
+            <option value="all-replies">모든 답장 알림</option>
+          </select>
+        </div>
+        <p class="update-note" id="notification-description">모든 답장 알림은 확인함 알림과 메인·작업의 완료된 답장 알림을 포함합니다. 이 게이트웨이에 연결된 모든 기기에 적용됩니다.</p>
+        <p class="enroll-message" id="notification-status" role="status" aria-live="polite"></p>
+      </section>
       <section class="settings-section gc" id="gc" aria-labelledby="gc-title">
         <div class="section-label"><span id="gc-title">정리</span><span class="gc-head"><span class="gc-summary" id="gc-summary" role="status" aria-live="polite"></span><label class="gc-all" id="gc-all-label" hidden><input type="checkbox" id="gc-all">전체 선택</label></span></div>
         <ul class="gc-list" id="gc-list" aria-label="정리 후보"></ul>

package/web/notifications.d.ts

@@ -0,0 +1,25 @@
+export type NotificationMode = "inbox-only" | "all-replies";
+export const NOTIFICATION_SETTINGS_PATH: string;
+export interface NotificationSettingsView {
+	readonly mode: NotificationMode;
+	readonly ready: boolean;
+	readonly online: boolean;
+	readonly busy: boolean;
+	readonly error: string;
+}
+export interface NotificationSettingsController {
+	readonly view: () => NotificationSettingsView;
+	readonly read: () => Promise<void>;
+	readonly set: (mode: NotificationMode) => Promise<void>;
+	readonly connect: () => Promise<void>;
+	readonly disconnect: () => void;
+	readonly updated: (body: unknown) => void;
+}
+export type SettingsFetch = (path: string, init: RequestInit) => Promise<Pick<Response, "ok" | "json">>;
+export function notificationMode(body: unknown): NotificationMode | null;
+export function createNotificationSettings(fetcher: SettingsFetch, render: (view: NotificationSettingsView) => void): NotificationSettingsController;
+export interface NotificationSettingsElements {
+	readonly choice: { value: string; disabled: boolean; onchange: (() => Promise<void>) | null };
+	readonly status: { textContent: string | null; classList: Pick<DOMTokenList, "toggle"> };
+}
+export function setupNotificationSettings(elements: NotificationSettingsElements, fetcher?: SettingsFetch): NotificationSettingsController;

package/web/notifications.js

@@ -0,0 +1,118 @@
+export const NOTIFICATION_SETTINGS_PATH = "/api/settings/notifications";
+
+/** Parse gateway data without treating a failed or malformed response as a default. */
+export function notificationMode(body) {
+	if (body === null || typeof body !== "object" || Array.isArray(body)) return null;
+	if (body.mode === "inbox-only" || body.mode === "all-replies") return body.mode;
+	return null;
+}
+
+/** Confirmed gateway state only. Requests belong to one connection epoch; writes run in order. */
+export function createNotificationSettings(fetcher, render) {
+	let mode = "inbox-only";
+	let ready = false;
+	let online = false;
+	let error = "";
+	let epoch = 0;
+	let generation = 0;
+	let pending = 0;
+	let tail = Promise.resolve();
+	const view = () => ({ mode, ready, online, busy: pending > 0, error });
+	const paint = () => render(view());
+	const confirm = (value) => {
+		mode = value;
+		ready = true;
+		error = "";
+		paint();
+	};
+
+	async function read() {
+		if (!online) return;
+		const connection = epoch;
+		const request = ++generation;
+		try {
+			const response = await fetcher(NOTIFICATION_SETTINGS_PATH, { cache: "no-store" });
+			if (!response.ok) throw new Error("notification_read_failed");
+			const value = notificationMode(await response.json());
+			if (value === null) throw new Error("notification_response_invalid");
+			if (connection === epoch && request === generation) confirm(value);
+		} catch {
+			if (connection === epoch && request === generation) {
+				error = "알림 설정을 불러오지 못했습니다. 다시 연결하면 재시도합니다.";
+				paint();
+			}
+		}
+	}
+
+	function set(value) {
+		if (!online || !ready || notificationMode({ mode: value }) === null) return Promise.resolve();
+		const connection = epoch;
+		generation += 1;
+		pending += 1;
+		paint();
+		tail = tail.then(async () => {
+			try {
+				if (connection !== epoch) return;
+				const request = ++generation;
+				const response = await fetcher(NOTIFICATION_SETTINGS_PATH, {
+					method: "PUT", headers: { "content-type": "application/json" }, body: JSON.stringify({ mode: value }),
+				});
+				if (!response.ok) throw new Error("notification_save_failed");
+				const saved = notificationMode(await response.json());
+				if (saved === null) throw new Error("notification_response_invalid");
+				if (connection !== epoch) return;
+				if (request === generation) confirm(saved);
+				else await read(); // A newer event/read may describe another client's write.
+			} catch {
+				if (connection === epoch) {
+					error = "알림 설정을 저장하지 못했습니다. 확인된 설정을 유지합니다.";
+					paint();
+				}
+			} finally {
+				pending -= 1;
+				paint();
+			}
+		});
+		return tail;
+	}
+
+	paint();
+	return {
+		view,
+		read,
+		set,
+		connect() {
+			epoch += 1;
+			generation += 1;
+			online = true;
+			ready = false;
+			error = "";
+			paint();
+			return read();
+		},
+		disconnect() {
+			epoch += 1;
+			generation += 1;
+			online = false;
+			paint();
+		},
+		updated(body) {
+			const value = notificationMode(body);
+			if (!online || value === null) return;
+			generation += 1;
+			confirm(value);
+		},
+	};
+}
+
+/** Reuse the settings dialog's native select and live status region. */
+export function setupNotificationSettings({ choice, status }, fetcher = fetch) {
+	const controller = createNotificationSettings(fetcher, (view) => {
+		choice.value = view.mode;
+		choice.disabled = !view.online || !view.ready || view.busy;
+		status.textContent = view.error || (view.busy ? "저장 중…" : !view.online ? "게이트웨이 연결을 기다립니다." : !view.ready ? "알림 설정 확인 중…" : "");
+		status.classList.toggle("error", Boolean(view.error));
+	});
+	choice.onchange = () => controller.set(choice.value);
+	return controller;
+}

package/web/style.css

@@ -126,6 +126,8 @@ button { font: inherit; color: inherit; cursor: pointer; }
 .msg-name { font-weight: 600; }
 .msg-name.bot { color: #a3acff; }
 .msg-time { font-size: 12px; color: var(--muted); }
+.turn-stats { margin-top: 4px; margin-right: 48px; font-size: 12px; line-height: 1.5; color: var(--muted); font-variant-numeric: tabular-nums; user-select: none; }
+.turn-stats::before { content: attr(data-label); }
 .msg-tag { font-size: 11px; color: var(--muted); border: 1px solid #4e5058; border-radius: 4px; padding: 0 4px; }
 .msg-read { font-size: 11px; color: var(--muted); }
 .msg.precomment .msg-body { opacity: 0.72; font-size: 0.9em; }
@@ -569,3 +571,13 @@ button { font: inherit; color: inherit; cursor: pointer; }
 /* Bug 90: the page-drawn tooltip (web/tooltip.js). */
 .zgw-tip { position: fixed; z-index: 10000; max-width: min(360px, calc(100vw - 16px)); padding: 6px 9px; border-radius: 6px; background: #111214; color: var(--text); border: 1px solid #3f4147; box-shadow: 0 4px 14px rgba(0, 0, 0, 0.45); font-size: 12px; line-height: 1.45; white-space: pre-line; overflow-wrap: anywhere; pointer-events: none; }
 .zgw-tip[hidden] { display: none; }
+
+/* Improvement 165: the security check card (values the user decides to send or drop). */
+.security-card { display: block; margin: 8px 0; border: 1px solid #4e5058; border-left: 4px solid var(--warn); background: var(--bg-card); border-radius: 6px; padding: 12px; max-width: 640px; }
+.security-card .security-title { font-weight: 600; margin-bottom: 6px; }
+.security-card .security-list { margin: 0 0 8px; padding-left: 18px; }
+.security-card .security-value { word-break: break-all; }
+.security-card .security-place { opacity: 0.7; font-size: 0.9em; }
+.security-card .security-actions { display: flex; gap: 8px; }
+.security-card .security-actions .btn { white-space: nowrap; writing-mode: horizontal-tb; }
+.security-card.done { opacity: 0.75; }

package/web/turn-stats.d.ts

@@ -0,0 +1,26 @@
+export interface TurnStatsEvent {
+	readonly conv?: string;
+	readonly type: string;
+	readonly seq?: number;
+	readonly data?: {
+		readonly itemId?: unknown;
+		readonly messageSeq?: unknown;
+		readonly turnId?: unknown;
+		readonly stats?: unknown;
+	};
+}
+export interface StatsBody {
+	readonly ownerDocument: { createElement(tag: string): StatsLine };
+	querySelector(selector: string): unknown;
+	appendChild(line: StatsLine): unknown;
+}
+export interface StatsLine {
+	className: string;
+	readonly dataset: Record<string, string | undefined>;
+	setAttribute(name: string, value: string): void;
+}
+export function turnStatsLabel(stats: unknown): string;
+export function createTurnStats(): {
+	reset(conv: string): void;
+	accept(event: TurnStatsEvent, body?: StatsBody): void;
+};

package/web/turn-stats.js

@@ -0,0 +1,58 @@
+/** Unknown fields are omitted, not rendered as zero. Model time excludes tools and wall time. */
+export function turnStatsLabel(stats) {
+	if (!stats || typeof stats !== "object") return "";
+	const parts = [];
+	if (Number.isFinite(stats.tokensPerSecond) && stats.tokensPerSecond > 0) parts.push(`TPS ${stats.tokensPerSecond.toFixed(1)} tok/s`);
+	if (Number.isFinite(stats.modelDurationMs) && stats.modelDurationMs > 0) parts.push(`모델 처리 ${(stats.modelDurationMs / 1000).toFixed(1)}초`);
+	if (Number.isFinite(stats.cacheHitPercent) && stats.cacheHitPercent >= 0 && stats.cacheHitPercent <= 100) parts.push(`캐시 적중 ${stats.cacheHitPercent.toFixed(1)}%`);
+	return parts.join(" · ");
+}
+
+/**
+ * One transcript in one gateway origin. Nothing is shared in storage or across app instances.
+ * Keep unmatched stats until their final's older page arrives; never fall back to the latest row.
+ */
+export function createTurnStats() {
+	let conv = null;
+	const rows = new Map();
+	const labels = new Map();
+	function draw(key) {
+		const body = rows.get(key);
+		const label = labels.get(key);
+		if (!body || !label || body.querySelector(".turn-stats")) return;
+		const line = body.ownerDocument.createElement("div");
+		line.className = "turn-stats";
+		// Generated content stays out of selection text and ordinary transcript text exports.
+		// The accessible name still exposes the same metadata to assistive technology.
+		line.dataset.label = label;
+		line.setAttribute("role", "note");
+		line.setAttribute("aria-label", label);
+		body.appendChild(line);
+	}
+	return {
+		reset(nextConv) {
+			conv = nextConv;
+			rows.clear();
+			labels.clear();
+		},
+		accept(event, body) {
+			if (!event || event.conv !== conv || !event.data) return;
+			const data = event.data;
+			if (typeof data.itemId !== "string" || !data.itemId) return;
+			const seq = event.type === "message.final" ? event.seq : data.messageSeq;
+			if (!Number.isInteger(seq) || seq <= 0) return;
+			const key = JSON.stringify([data.itemId, seq]);
+			if (event.type === "message.final") {
+				if (!body) return;
+				rows.set(key, body);
+				draw(key);
+			} else if (event.type === "message.stats") {
+				if (typeof data.turnId !== "string" || !data.turnId) return;
+				const label = turnStatsLabel(data.stats);
+				if (!label) return;
+				if (!labels.has(key)) labels.set(key, label);
+				draw(key);
+			}
+		},
+	};
+}