zigmini 0.8.0-beta.5 → 0.8.0-beta.6

package/README.ko.md

@@ -208,6 +208,7 @@ zigmini update <버전>     # 지정한 버전으로 업데이트
 | `zigmini pair [--apk]` | 폰 등록 QR 또는 앱 내려받기 QR을 그립니다 |
 | `zigmini consent` | 권한 안내를 보이고 동의를 기록합니다 |
 | `zigmini update [버전] [--force]` | 업데이트합니다 |
+| `zigmini rotate-main [--restart] [--wait <초>] [--foreground]` | main 대화를 새 엔진 세션으로 교체합니다. 웹의 "새 세션"과 같은 요청입니다. 분리 실행하고 결과는 `~/.zigmini/logs/rotate-main.log`에 남깁니다. `--restart`는 게이트웨이를 먼저 멈추고 다시 켭니다 |
 | `zigmini migrate` | 옛 Docker 설치(`~/.zigmini-gateway`)를 새 구조로 복사합니다. 옛 폴더는 바꾸지 않습니다 |
 | `zigmini migrate-run` | 유휴를 기다리고, 옛 실행을 멈추고, 백업하고, migrate와 setup을 실행한 뒤 확인합니다. 실패하면 옛 실행으로 되돌립니다 |
 | `zigmini --version` | 설치된 버전을 출력합니다 |

package/README.md

@@ -208,6 +208,7 @@ An update to a version that does not support the zero-downtime switch (including
 | `zigmini pair [--apk]` | Draws the phone registration QR code or the app download QR code |
 | `zigmini consent` | Shows the permission notice and records the consent |
 | `zigmini update [버전] [--force]` | Updates (`버전`: version) |
+| `zigmini rotate-main [--restart] [--wait <초>] [--foreground]` | Moves the main conversation to a fresh engine session, like "새 세션" (New session) in the web. Runs detached and logs to `~/.zigmini/logs/rotate-main.log`. `--restart` stops and starts the gateway first (`<초>`: seconds) |
 | `zigmini migrate` | Copies an old Docker installation (`~/.zigmini-gateway`) to the new layout. The old folder is not changed |
 | `zigmini migrate-run` | Waits until idle, stops the old runtime, backs up, runs migrate and setup, then checks. If this fails, it goes back to the old runtime |
 | `zigmini --version` | Prints the installed version |

package/assets/android/zigmini.apk.json

@@ -1,5 +1,5 @@
 {
-  "versionCode": 24,
-  "versionName": "0.8.0-beta.5",
-  "sha256": "783c65a373c2b3f7b9f117e66237c6081a85a8f225c7ef9af182049e3a8a5393"
+  "versionCode": 25,
+  "versionName": "0.8.0-beta.6",
+  "sha256": "4fc49f125efaa2ae1118d4724b7a2370c7d1c80227f9228858266eea64678155"
 }

package/assets/build.json

@@ -1 +1 @@
-{"commit":"6eea099deac067c0e19d44b3bb2890a341438510"}
+{"commit":"46f57dd257c4451fbc4f2d9f4022501e20798032"}

package/docs/manual.ko.md

@@ -208,7 +208,7 @@ Android 앱(APK)을 받는 QR이 보입니다. 폰 카메라로 QR을 찍어 APK
 
 #### 정리
 
-게이트웨이가 지워도 되는 후보를 보여 줍니다. 후보는 DB 백업, 엔진 버전 폴더, 업데이트 남은 파일, 임시 폴더, 이전 RPC 데몬입니다. 지울 항목을 고르고 "선택한 항목 정리"를 누릅니다.
+게이트웨이가 지워도 되는 후보를 보여 줍니다. 후보는 DB 백업, 엔진 버전 폴더, 업데이트 남은 파일, 임시 폴더, 이전 RPC 데몬입니다. 지울 항목을 고르고 "선택한 항목 정리"를 누릅니다. 후보 수 옆의 "전체 선택"을 누르면 모든 후보를 한 번에 고르거나 모두 풉니다.
 
 #### 음성 설정
 
@@ -378,5 +378,6 @@ Ctrl 단축키는 Cmd, Alt, Shift와 함께 누르면 동작하지 않습니다.
 - `zigmini pair [--apk]`: 폰 등록 QR이나 앱 내려받기 QR을 보여 줍니다.
 - `zigmini consent`: 권한 안내를 보이고 동의를 기록합니다.
 - `zigmini update [버전]`: 업데이트합니다.
+- `zigmini rotate-main [--restart]`: main 대화를 새 세션으로 교체합니다. "새 세션"과 같습니다. 먼저 운영자 허가를 받습니다. 자세한 내용은 운영 문서를 보세요.
 
 전체 목록은 README의 '명령' 절을 보세요.

package/docs/manual.md

@@ -208,7 +208,7 @@ A QR for the Android app (APK) shows. Scan it with the phone camera, get the APK
 
 #### Cleanup (정리)
 
-The gateway lists things that are safe to delete: DB backups, engine version folders, leftover update files, temp folders and old RPC daemons. Tick the ones to remove and click 선택한 항목 정리 (clean selected).
+The gateway lists things that are safe to delete: DB backups, engine version folders, leftover update files, temp folders and old RPC daemons. Tick the ones to remove and click 선택한 항목 정리 (clean selected). The 전체 선택 (select all) box beside the count ticks every candidate at once, or clears them all.
 
 #### Voice settings
 
@@ -378,5 +378,6 @@ Main commands for the Mac terminal:
 - `zigmini pair [--apk]`: shows the phone registration QR or the app download QR.
 - `zigmini consent`: shows the permission notice and records consent.
 - `zigmini update [version]`: updates.
+- `zigmini rotate-main [--restart]`: moves the main conversation to a new session, like "새 세션" (new session). Ask the operator first. See the operator guide.
 
 For the full list, see the README's Commands section.

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

@@ -1,6 +1,6 @@
 {
   "schema": 1,
-  "revision": 3,
+  "revision": 4,
   "upstream": {
     "omo": "5.1.35",
     "senpi": "2026.10.16"
@@ -12,7 +12,8 @@
   "patches": [
     "omo-5.1.35-gateway-port.patch",
     "omo-5.1.35-image-replay.patch",
-    "omo-5.1.35-question-capability.patch"
+    "omo-5.1.35-question-capability.patch",
+    "omo-5.1.35-phantom-attach.patch"
   ],
   "files": [
     {
@@ -148,7 +149,7 @@
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/modes/rpc/session-command-router.js",
       "originalSha256": "3f952631024884c893a6e37549c2861e25b0bddc2387222006b77dcbaad78c9b",
-      "patchedSha256": "95515f802619da5e54352b8d996b8b71c6db91f1574470626239de2764367f9b"
+      "patchedSha256": "a2ea46300a8d7b4cb46413afd5389ad8df37707c2852f3f4b826011a28eea6ef"
     },
     {
       "path": "node_modules/@earendil-works/pi-agent-core/dist/agent.d.ts",

package/host/omo-check/patches/omo-5.1.35-phantom-attach.patch

@@ -0,0 +1,31 @@
+diff --git a/@code-yeongyu/senpi/dist/modes/rpc/session-command-router.js b/@code-yeongyu/senpi/dist/modes/rpc/session-command-router.js
+--- a/@code-yeongyu/senpi/dist/modes/rpc/session-command-router.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/session-command-router.js
+@@ -584,7 +584,17 @@
+      * the failure response otherwise, exactly as an open does.
+      */
+     reopenParked(entry) {
+-        return this.open(parkedOpenCommand(entry), undefined, { reply: false, defaults: false });
++        return this.open(parkedOpenCommand(entry), undefined, { reply: false, defaults: false, releaseUnowned: true });
++    }
++    /**
++     * zgw (rotation after a handoff): the registry counts one attachment for every open, and an owner-less reopen has no
++     * connection that could ever release it, so a later close by the real owner left the session open. Release it as a
++     * detach: a retained entry stays open at zero attachments, exactly as when its last client leaves.
++     */
++    releaseUnownedReopen(sessionId) {
++        if (this.draining || this.registry.peek(sessionId)?.retainOnDisconnect !== true)
++            return false;
++        return this.tryClaimClose(sessionId, { drainAttachments: false, detach: true }) !== undefined;
+     }
+     async open(command, owner, options) {
+         // A parked session's reopen replays what its park recorded; a field it left empty stays empty
+@@ -729,6 +739,8 @@
+                 this.releaseOwnerAttachment(owner, openedSession.sessionId);
+                 await this.releaseOwnedSession(openedSession.sessionId);
+             }
++            if (owner === undefined && options?.releaseUnowned === true)
++                this.releaseUnownedReopen(openedSession.sessionId);
+             const replyState = entry.worker?.snapshot?.state ?? (entry.runtime ? buildRpcSessionState(entry.runtime.session) : undefined);
+             if (!replyState)
+                 throw new Error("Session state was not created");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigmini",
-  "version": "0.8.0-beta.5",
+  "version": "0.8.0-beta.6",
   "type": "module",
   "bin": {
     "zigmini": "bin/zigmini"

package/src/cli/main.ts

@@ -11,6 +11,7 @@ import { setupHint } from "./setup-hint.ts";
 import { helperCommand, updateCommand } from "../update/cli.ts";
 import { handoffCommand } from "../update/handoff-system.ts";
 import { HANDOFF_COMMAND } from "../update/strategy.ts";
+import { ROTATE_COMMAND, ROTATE_RUN_COMMAND, rotateCommand } from "./rotate-main.ts";
 import { EXIT_USAGE, parseMigrateArgs, parseMigrateRunArgs, runMigrate, runMigrateRun, systemMigrateDeps, systemMigrateRunDeps } from "./migrate.ts";
 
 export const HELP = `zigmini - 개인 AI 에이전트 게이트웨이
@@ -29,6 +30,10 @@ export const HELP = `zigmini - 개인 AI 에이전트 게이트웨이
   doctor [--json] [--fix]     전체 상태를 점검합니다(--fix: 이상 있는 launchd 에이전트만 다시 띄움)
   pair                        폰 등록 QR(유효 10분, 한 번 사용)을 터미널에 그립니다. 게이트웨이가 실행 중이어야 합니다
   pair --apk                  앱(APK) 내려받기 QR(유효 10분)을 터미널에 그립니다
+  rotate-main [--restart] [--wait <초>] [--foreground]
+                              main 대화를 새 엔진 세션으로 교체합니다. main 차례가 끝나길 기다린 뒤 보냅니다(기본 900초).
+                              기본은 분리 실행이고 결과는 <홈>/logs/rotate-main.log에 남깁니다
+                              (--restart: 먼저 게이트웨이를 멈추고 다시 켭니다. --foreground: 이 터미널에서 실행)
   consent                     풀 액세스 권한 안내를 보이고 동의를 기록합니다(거부하면 멈춤)
   update [버전] [--force]      새 버전으로 업데이트합니다(비우면 latest). DB 백업 뒤 설치·재시작하고, 실패하면 자동으로 되돌립니다
                               (--force: 진행 중인 턴이 있어도 합니다. 게이트웨이가 실행 중이어야 합니다)
@@ -127,6 +132,15 @@ if (import.meta.main) {
 	}
 	if (argv[0] === UPDATER_COMMAND) process.exit(await helperCommand(deps, ctx));
 	if (argv[0] === HANDOFF_COMMAND) process.exit(await handoffCommand(deps, ctx, argv.slice(1)));
+	if (argv[0] === ROTATE_COMMAND || argv[0] === ROTATE_RUN_COMMAND) {
+		const refusal = argv.includes("--restart") ? cliGate("restart", ctx.paths.home, kind, notice) : null;
+		if (refusal !== null) {
+			deps.err(`${refusal}\n`);
+			process.exit(EXIT_DECLINED);
+		}
+		const args = argv[0] === ROTATE_RUN_COMMAND ? [...argv.slice(1), "--foreground"] : argv.slice(1);
+		process.exit(await rotateCommand(args, deps, ctx));
+	}
 	if (argv[0] === "update") {
 		process.exit(await updateCommand(argv.slice(1), { webPort: ctx.paths.ports.web, fetch: (url, init) => fetch(url, init), prompt: stdinPrompt(),
 			out: deps.out, err: deps.err, sleep: (ms) => Bun.sleep(ms), now: Date.now }));

package/src/cli/rotate-main.ts

@@ -0,0 +1,411 @@
+import { spawn } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { agentDir } from "../model-accounts.ts";
+import { ROTATION_HELD_MESSAGE } from "../protocol.ts";
+import { type LaunchdContext, type LaunchdDeps, ownProcess, parseConfigEnv, startCommand, stopCommand } from "./launchd.ts";
+
+/**
+ * Improvement 162: `zigmini rotate-main` moves the main conversation to a fresh engine session the same way the web
+ * "새 세션" button does (conversation.rotate), from a command that outlives the engine that asked for it.
+ *
+ * The command starts a detached runner (its own session, so stopping the engine does not kill it) and returns. The
+ * runner waits until no main turn holds the session, stops on any other holder, sends the rotation and checks the
+ * session.rotated event. With --restart it first stops the gateway, checks that every process is gone and that no
+ * main session is parked for the next engine, starts the gateway again and only then rotates. Every step is a line in
+ * <home>/logs/rotate-main.log.
+ */
+
+export const ROTATE_COMMAND = "rotate-main";
+export const ROTATE_RUN_COMMAND = "_rotate-main-run";
+export const LOG_FILE = "rotate-main.log";
+export const DEFAULT_WAIT_S = 900;
+export const MAX_WAIT_S = 86_400;
+export const POLL_MS = 5_000;
+export const ROTATED_WAIT_MS = 120_000;
+export const PROCESSES_GONE_MS = 60_000;
+export const CONV = "main";
+
+export const EXIT_OK = 0;
+export const EXIT_FAILED = 1;
+export const EXIT_USAGE = 2;
+export const EXIT_BLOCKED = 3;
+export const EXIT_TIMEOUT = 4;
+
+export interface RotateOptions {
+	readonly restart: boolean;
+	readonly waitMs: number;
+	readonly foreground: boolean;
+}
+
+export const ROTATE_HELP = `사용법: zigmini rotate-main [--restart] [--wait <초>] [--foreground]
+  main 대화를 새 엔진 세션으로 교체합니다(웹의 "새 세션" 버튼과 같은 요청).
+  main 차례가 진행 중이면 끝날 때까지 기다립니다(--wait, 기본 ${DEFAULT_WAIT_S}초).
+  다른 원인이 교체를 막으면 그 원인을 로그에 쓰고 끝납니다.
+  --restart     먼저 게이트웨이를 멈추고(zigmini stop) 다시 켠 뒤(zigmini start) 교체합니다
+  --foreground  분리하지 않고 이 터미널에서 실행합니다(기본: 분리 실행, 결과는 로그에)
+  로그: <홈>/logs/${LOG_FILE}`;
+
+export function parseRotateArgs(args: readonly string[]): RotateOptions | string {
+	let restart = false;
+	let foreground = false;
+	let waitS = DEFAULT_WAIT_S;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--restart" && !restart) restart = true;
+		else if (arg === "--foreground" && !foreground) foreground = true;
+		else if (arg === "--wait" && i + 1 < args.length) {
+			const value = args[++i]!;
+			if (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > MAX_WAIT_S) return `--wait 값은 1~${MAX_WAIT_S} 사이의 초입니다: ${value}`;
+			waitS = Number(value);
+		} else return `잘못된 인자: ${arg}`;
+	}
+	return { restart, waitMs: waitS * 1000, foreground };
+}
+
+/** The arguments the detached runner gets: the parsed options again, always in the foreground. */
+export function runnerArgs(options: RotateOptions): string[] {
+	return [ROTATE_RUN_COMMAND, ...(options.restart ? ["--restart"] : []), "--wait", String(options.waitMs / 1000)];
+}
+
+export interface Blocker {
+	readonly kind: string;
+	readonly id?: string;
+	readonly workId?: string;
+	readonly state?: string;
+	readonly reason?: string;
+}
+
+export interface HealthView {
+	readonly ready: boolean;
+	readonly omo: string | null;
+	readonly maintenanceHeld: boolean;
+	/** main's rotation entry; null when main has no engine session yet. */
+	readonly blockers: readonly Blocker[] | null;
+	readonly active: string | null;
+}
+
+export function readHealth(body: unknown): HealthView | null {
+	if (typeof body !== "object" || body === null) return null;
+	const health = body as { ok?: unknown; omo?: unknown; maintenanceHeld?: unknown; rotation?: unknown; runtime?: unknown };
+	const omo = typeof health.omo === "string" ? health.omo : null;
+	const rotation = typeof health.rotation === "object" && health.rotation !== null ? (health.rotation as Record<string, unknown>)[CONV] : undefined;
+	const raw = typeof rotation === "object" && rotation !== null ? (rotation as { blockers?: unknown }).blockers : undefined;
+	const blockers = Array.isArray(raw)
+		? raw.filter((entry): entry is Blocker => typeof entry === "object" && entry !== null && typeof (entry as Blocker).kind === "string")
+		: null;
+	const runtime = health.runtime as { active?: unknown } | undefined;
+	return {
+		ready: health.ok === true && omo === "ready",
+		omo,
+		maintenanceHeld: health.maintenanceHeld === true,
+		blockers,
+		active: typeof runtime?.active === "string" ? runtime.active : null,
+	};
+}
+
+export function describeBlockers(blockers: readonly Blocker[]): string {
+	return blockers.map((b) => [b.kind, b.id, b.workId, b.state, b.reason].filter(Boolean).join(":")).join(", ");
+}
+
+export type Gate =
+	| { readonly kind: "ready" }
+	| { readonly kind: "wait"; readonly why: string }
+	| { readonly kind: "blocked"; readonly why: string };
+
+/** What the health says about rotating main now: a main turn, an update or a not-ready engine is waited for; anything else stops. */
+export function gate(health: HealthView | null): Gate {
+	if (health === null) return { kind: "wait", why: "health 응답 없음" };
+	if (!health.ready) return { kind: "wait", why: `엔진 준비 안 됨(omo=${health.omo ?? "?"})` };
+	if (health.maintenanceHeld) return { kind: "wait", why: "업데이트·유지보수 진행 중" };
+	if (health.blockers === null) return { kind: "blocked", why: "main 대화에 엔진 세션이 없습니다(교체할 세션 없음)" };
+	const other = health.blockers.filter((blocker) => blocker.kind !== "main_turn");
+	if (other.length > 0) return { kind: "blocked", why: `교체를 막는 원인: ${describeBlockers(health.blockers)}` };
+	if (health.blockers.length > 0) return { kind: "wait", why: `main 차례 진행 중: ${describeBlockers(health.blockers)}` };
+	return { kind: "ready" };
+}
+
+export type RotateOutcome =
+	| { readonly kind: "rotated"; readonly before: string | null; readonly from: string; readonly to: string }
+	| { readonly kind: "held"; readonly message: string }
+	| { readonly kind: "error"; readonly message: string }
+	| { readonly kind: "timeout" };
+
+/** What is wrong with a reported rotation: it must leave the session main had, for a new file in the same folder. */
+export function rotationProblems(outcome: { before: string | null; from: string; to: string }, exists: (path: string) => boolean): string[] {
+	const problems: string[] = [];
+	if (outcome.before !== null && outcome.from !== outcome.before) problems.push(`이전 세션이 다릅니다(교체 전 ${outcome.before})`);
+	if (outcome.to === outcome.from) problems.push("새 세션 파일이 이전과 같습니다");
+	if (dirname(outcome.to) !== dirname(outcome.from)) problems.push("새 세션 파일이 다른 폴더에 있습니다");
+	if (!basename(outcome.to).startsWith(`zgw-${CONV}-`)) problems.push("새 세션 파일 이름이 main 세션이 아닙니다");
+	if (!exists(outcome.from)) problems.push("이전 세션 파일이 디스크에 없습니다");
+	return problems;
+}
+
+export interface RotateDeps {
+	readonly health: () => Promise<unknown>;
+	readonly rotate: (timeoutMs: number) => Promise<RotateOutcome>;
+	readonly exists: (path: string) => boolean;
+	readonly now: () => number;
+	readonly sleep: (ms: number) => Promise<void>;
+	readonly log: (step: string, result: string) => void;
+	readonly out: (text: string) => void;
+	readonly stop: () => Promise<number>;
+	readonly start: () => Promise<number>;
+	/** This installation's gateway, bridge and engine processes still running ("pid command"). */
+	readonly processes: () => readonly string[];
+	/** Parked engine records of main sessions the next engine would reopen. */
+	readonly parkedMain: () => readonly string[];
+}
+
+type Waited = { readonly kind: "ready"; readonly health: HealthView } | { readonly kind: "blocked"; readonly why: string } | { readonly kind: "timeout"; readonly why: string };
+
+async function waitIdle(deps: RotateDeps, deadline: number): Promise<Waited> {
+	let last = "";
+	for (;;) {
+		const health = readHealth(await deps.health());
+		const state = gate(health);
+		if (state.kind === "ready") return { kind: "ready", health: health! };
+		if (state.kind === "blocked") return state;
+		if (state.why !== last) deps.log("wait", state.why);
+		last = state.why;
+		if (deps.now() >= deadline) return { kind: "timeout", why: state.why };
+		await deps.sleep(POLL_MS);
+	}
+}
+
+function finish(deps: RotateDeps, code: number, result: string): number {
+	deps.log("result", result);
+	deps.out(`${result}\n`);
+	return code;
+}
+
+function stopped(deps: RotateDeps, waited: Exclude<Waited, { kind: "ready" }>, waitMs: number): number {
+	if (waited.kind === "blocked") return finish(deps, EXIT_BLOCKED, `BLOCKED 교체하지 않았습니다. ${waited.why}`);
+	return finish(deps, EXIT_TIMEOUT, `TIMEOUT ${waitMs / 1000}초 안에 main 차례가 끝나지 않아 교체하지 않았습니다. 마지막 상태: ${waited.why}`);
+}
+
+/** Waits for main to be free and rotates it; a rotation refused because a turn started meanwhile waits again. */
+async function rotateWhenIdle(deps: RotateDeps, options: RotateOptions, deadline: number): Promise<number> {
+	for (;;) {
+		const waited = await waitIdle(deps, deadline);
+		if (waited.kind !== "ready") return stopped(deps, waited, options.waitMs);
+		deps.log("rotate", "conversation.rotate 보냄");
+		const outcome = await deps.rotate(ROTATED_WAIT_MS);
+		if (outcome.kind === "held") {
+			deps.log("rotate", `거절됨, 다시 기다림: ${outcome.message}`);
+			if (deps.now() >= deadline) return finish(deps, EXIT_TIMEOUT, `TIMEOUT 교체 요청이 계속 거절되었습니다: ${outcome.message}`);
+			await deps.sleep(POLL_MS);
+			continue;
+		}
+		if (outcome.kind === "timeout") return finish(deps, EXIT_FAILED, `FAILED ${ROTATED_WAIT_MS / 1000}초 안에 session.rotated 이벤트가 오지 않았습니다`);
+		if (outcome.kind === "error") return finish(deps, EXIT_FAILED, `FAILED 게이트웨이가 교체를 거절했습니다: ${outcome.message}`);
+		deps.log("rotated", `이전 ${outcome.from} → 새 ${outcome.to}`);
+		const problems = rotationProblems(outcome, deps.exists);
+		if (problems.length > 0) return finish(deps, EXIT_FAILED, `FAILED 교체 이벤트 확인 실패: ${problems.join("; ")}`);
+		return finish(deps, EXIT_OK, `ROTATED 이전 ${outcome.from} → 새 ${outcome.to}`);
+	}
+}
+
+async function waitProcessesGone(deps: RotateDeps): Promise<readonly string[]> {
+	const deadline = deps.now() + PROCESSES_GONE_MS;
+	for (;;) {
+		const left = deps.processes();
+		if (left.length === 0 || deps.now() >= deadline) return left;
+		await deps.sleep(1000);
+	}
+}
+
+/** After a failed step: start the gateway again so the Mac is not left without it, and never rotate. */
+async function recover(deps: RotateDeps, why: string): Promise<number> {
+	deps.log("recover", `${why}; 게이트웨이를 다시 켭니다`);
+	let code = await deps.start();
+	if (code !== 0) {
+		deps.log("recover", `zigmini start exit=${code}; 한 번 더 시도합니다`);
+		code = await deps.start();
+	}
+	return finish(deps, EXIT_FAILED, `FAILED ${why}. 교체 요청은 보내지 않았습니다. 다시 켜기 ${code === 0 ? "성공" : `실패(exit=${code}) - zigmini start를 직접 실행하세요`}`);
+}
+
+export async function runRotate(options: RotateOptions, deps: RotateDeps): Promise<number> {
+	deps.log("start", `mode=${options.restart ? "restart" : "rotate"} wait=${options.waitMs / 1000}s`);
+	const deadline = deps.now() + options.waitMs;
+	if (!options.restart) return await rotateWhenIdle(deps, options, deadline);
+
+	const waited = await waitIdle(deps, deadline);
+	if (waited.kind !== "ready") return stopped(deps, waited, options.waitMs);
+	const parkedBefore = deps.parkedMain();
+	if (parkedBefore.length > 0) {
+		return finish(deps, EXIT_BLOCKED, `BLOCKED 멈추기 전 확인: 다음 엔진이 다시 열 main 세션 기록이 있습니다(${parkedBefore.join(", ")}). 게이트웨이는 그대로 둡니다`);
+	}
+	deps.log("precheck", `active=${waited.health.active ?? "?"} parked-main=0`);
+	const stop = await deps.stop();
+	deps.log("stop", `zigmini stop exit=${stop}`);
+	if (stop !== 0) return await recover(deps, `zigmini stop 실패(exit=${stop})`);
+	const left = await waitProcessesGone(deps);
+	if (left.length > 0) return await recover(deps, `${PROCESSES_GONE_MS / 1000}초 뒤에도 남은 프로세스: ${left.join(" | ")}`);
+	deps.log("stop", "게이트웨이·브리지·엔진 프로세스 모두 꺼짐");
+	const parked = deps.parkedMain();
+	if (parked.length > 0) {
+		return finish(deps, EXIT_BLOCKED, `BLOCKED 멈춘 뒤 확인: 다음 엔진이 다시 열 main 세션 기록이 있습니다(${parked.join(", ")}). 게이트웨이를 다시 켜지 않았습니다. 확인 뒤 zigmini start를 실행하세요`);
+	}
+	deps.log("precheck", "멈춘 뒤 parked-main=0");
+	const start = await deps.start();
+	deps.log("start", `zigmini start exit=${start}`);
+	if (start !== 0) return await recover(deps, `zigmini start 실패(exit=${start})`);
+	const after = readHealth(await deps.health());
+	deps.log("ready", `omo=${after?.omo ?? "?"} active=${after?.active ?? "?"}`);
+	return await rotateWhenIdle(deps, options, Math.max(deadline, deps.now() + options.waitMs));
+}
+
+interface SnapshotConversation { readonly id?: unknown; readonly threadId?: unknown }
+
+/** One conversation.rotate over the gateway WebSocket, read like the web page: hello, the snapshot, then the request. */
+export function socketRotate(url: string, timeoutMs: number): Promise<RotateOutcome> {
+	return new Promise((resolve) => {
+		const ws = new WebSocket(url);
+		let before: string | null = null;
+		let sent = false;
+		let done = false;
+		const end = (outcome: RotateOutcome): void => {
+			if (done) return;
+			done = true;
+			clearTimeout(timer);
+			try { ws.close(); } catch { /* already closed */ }
+			resolve(outcome);
+		};
+		const timer = setTimeout(() => end({ kind: "timeout" }), timeoutMs);
+		ws.onopen = () => ws.send(JSON.stringify({ type: "hello", data: { client: "web-dev", version: "0.1.0" } }));
+		ws.onmessage = (event) => {
+			let message: { type?: unknown; conv?: unknown; data?: unknown };
+			try {
+				message = JSON.parse(String(event.data));
+			} catch {
+				return;
+			}
+			if (message.type === "state.snapshot" && !sent) {
+				const conversations = (message.data as { conversations?: unknown } | null)?.conversations;
+				const main = Array.isArray(conversations) ? (conversations as SnapshotConversation[]).find((conv) => conv?.id === CONV) : undefined;
+				before = typeof main?.threadId === "string" ? main.threadId : null;
+				sent = true;
+				ws.send(JSON.stringify({ type: "conversation.rotate", conv: CONV }));
+				return;
+			}
+			if (!sent || message.conv !== CONV) return;
+			const data = (message.data ?? {}) as { from?: unknown; to?: unknown; message?: unknown };
+			if (message.type === "session.rotated" && typeof data.from === "string" && typeof data.to === "string") {
+				end({ kind: "rotated", before, from: data.from, to: data.to });
+			} else if (message.type === "error") {
+				const text = typeof data.message === "string" ? data.message : JSON.stringify(data);
+				end(text === ROTATION_HELD_MESSAGE ? { kind: "held", message: text } : { kind: "error", message: text });
+			}
+		};
+		ws.onerror = () => end({ kind: "error", message: "WebSocket 연결 오류" });
+		ws.onclose = () => end({ kind: "error", message: "WebSocket 연결이 닫혔습니다" });
+	});
+}
+
+/** Main session records the engine parked for its successor: <agent dir>/rpc-host-daemon/<host>/handover-parked/*.json. */
+export function parkedMainSessions(dir: string): string[] {
+	const root = join(dir, "rpc-host-daemon");
+	if (!existsSync(root)) return [];
+	const found: string[] = [];
+	for (const host of readdirSync(root).sort()) {
+		const parked = join(root, host, "handover-parked");
+		if (!existsSync(parked)) continue;
+		for (const name of readdirSync(parked).sort()) {
+			if (!name.endsWith(".json")) continue;
+			try {
+				const entry = JSON.parse(readFileSync(join(parked, name), "utf8")) as { sessionPath?: unknown };
+				if (typeof entry.sessionPath === "string" && basename(entry.sessionPath).startsWith(`zgw-${CONV}-`)) found.push(entry.sessionPath);
+			} catch {
+				found.push(`${join(parked, name)} (읽을 수 없음)`);
+			}
+		}
+	}
+	return found;
+}
+
+/** This installation's gateway, bridge and engine processes: the package's two services, or anything run from the home folder. */
+export function leftoverProcesses(psOutput: string, ctx: LaunchdContext, self: readonly number[]): string[] {
+	const services = [join(ctx.packageRoot, "src/main.ts"), join(ctx.packageRoot, "host/omo-bridge/bridge.ts")];
+	const left: string[] = [];
+	for (const line of psOutput.split("\n")) {
+		const match = /^\s*(\d+)\s+(.*)$/.exec(line);
+		if (!match) continue;
+		const pid = Number(match[1]);
+		const command = match[2]!;
+		if (self.includes(pid) || command.includes("/src/cli/main.ts") || !ownProcess(command, ctx)) continue;
+		if (!command.includes(`${ctx.paths.home}/`) && !services.some((service) => command.includes(service))) continue;
+		left.push(`${pid} ${command}`);
+	}
+	return left;
+}
+
+export function logLine(at: Date, pid: number, step: string, result: string): string {
+	return `${at.toISOString()} [${pid}] ${step}: ${result.replace(/\s+/g, " ")}\n`;
+}
+
+export function systemRotateDeps(launchd: LaunchdDeps, ctx: LaunchdContext): RotateDeps {
+	const logFile = join(ctx.paths.logs, LOG_FILE);
+	const config = (): Record<string, string> => {
+		const text = launchd.readText(join(ctx.paths.home, "config.env"));
+		return text === null ? {} : parseConfigEnv(text);
+	};
+	const quiet: LaunchdDeps = { ...launchd, out: () => {}, err: (text) => appendFileSync(logFile, logLine(new Date(), process.pid, "launchd", text)) };
+	return {
+		health: async () => {
+			try {
+				const response = await fetch(`http://127.0.0.1:${ctx.paths.ports.web}/api/health`, { signal: AbortSignal.timeout(15_000) });
+				return await response.json();
+			} catch {
+				return null;
+			}
+		},
+		rotate: (timeoutMs) => socketRotate(`ws://127.0.0.1:${ctx.paths.ports.web}/ws`, timeoutMs),
+		exists: existsSync,
+		now: Date.now,
+		sleep: (ms) => Bun.sleep(ms),
+		log: (step, result) => {
+			mkdirSync(ctx.paths.logs, { recursive: true });
+			appendFileSync(logFile, logLine(new Date(), process.pid, step, result));
+		},
+		out: (text) => { process.stdout.write(text); },
+		stop: () => stopCommand(quiet, ctx, false),
+		start: () => startCommand(quiet, ctx),
+		processes: () => {
+			const ps = Bun.spawnSync(["ps", "-axww", "-o", "pid=,command="]);
+			return leftoverProcesses(ps.stdout.toString(), ctx, [process.pid, process.ppid]);
+		},
+		parkedMain: () => parkedMainSessions(agentDir({ ...ctx.env, ...config() })),
+	};
+}
+
+/** Starts the runner in its own session (setsid) with no terminal, so it survives the engine or shell that called it. */
+export function launchDetached(ctx: LaunchdContext, options: RotateOptions): number {
+	mkdirSync(ctx.paths.logs, { recursive: true });
+	const child = spawn(ctx.bunPath, [join(ctx.packageRoot, "src/cli/main.ts"), ...runnerArgs(options)], {
+		detached: true,
+		stdio: "ignore",
+		env: { ...ctx.env },
+	});
+	child.unref();
+	if (child.pid === undefined) throw new Error("rotate_runner_spawn_failed");
+	return child.pid;
+}
+
+export async function rotateCommand(args: readonly string[], launchd: LaunchdDeps, ctx: LaunchdContext,
+	detach: (ctx: LaunchdContext, options: RotateOptions) => number = launchDetached): Promise<number> {
+	const options = parseRotateArgs(args);
+	if (typeof options === "string") {
+		launchd.err(`${options}\n\n${ROTATE_HELP}\n`);
+		return EXIT_USAGE;
+	}
+	const logFile = join(ctx.paths.logs, LOG_FILE);
+	if (!options.foreground) {
+		const pid = detach(ctx, options);
+		launchd.out(`분리 실행을 시작했습니다: pid ${pid}, 모드 ${options.restart ? "재시작 후 교체" : "교체"}. 결과: ${logFile}\n`);
+		return EXIT_OK;
+	}
+	return await runRotate(options, systemRotateDeps(launchd, ctx));
+}

package/src/main.ts

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

package/src/protocol.ts

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

package/web/app.js

@@ -42,7 +42,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 { cleanRequest, cleanResultLine, GC_CLEAN_PATH, GC_PATH, gcView } from "./gc.js";
+import { cleanRequest, cleanResultLine, GC_CLEAN_PATH, GC_PATH, gcView, selectAllState, selectAllTarget } from "./gc.js";
 import { manualFailureText, manualLinkLang, manualUrl, otherLang } from "./manual.js";
 
 installTooltips(document, window);
@@ -3422,14 +3422,23 @@ async function checkUpdateNow() {
 	else showUpdateError(checkFailedLine(res?.status ?? 0));
 }
 
+// The version this page first loaded on: a stored ok result that ended there is stale after a reload (live update.result is not filtered).
+let pageVersion = null;
+
 function loadUpdateStatus() {
 	fetch(UPDATE_STATUS_PATH)
 		.then((res) => (res.ok ? res.json() : null))
-		.then(renderUpdate)
-		.catch((error) => console.warn("update status load:", error));
-	fetch(UPDATE_STATE_PATH)
+		.catch((error) => {
+			console.warn("update status load:", error);
+			return null;
+		})
+		.then((status) => {
+			renderUpdate(status);
+			if (pageVersion === null && typeof status?.current === "string") pageVersion = status.current;
+			return fetch(UPDATE_STATE_PATH);
+		})
 		.then((res) => (res.ok ? res.json() : null))
-		.then((state) => showUpdateProgress(progressLine(state)))
+		.then((state) => showUpdateProgress(progressLine(state, pageVersion)))
 		.catch((error) => console.warn("update state load:", error));
 }
 
@@ -3583,7 +3592,28 @@ const appDownload = createAppDownload({
 apkEls.renew.onclick = () => void appDownload.renew();
 
 // 정리 (improvement 66): nothing is cleaned until the user ticks rows and presses the button.
-const gcEls = { summary: $("gc-summary"), list: $("gc-list"), message: $("gc-message"), clean: $("gc-clean") };
+const gcEls = { summary: $("gc-summary"), list: $("gc-list"), message: $("gc-message"), clean: $("gc-clean"), all: $("gc-all"), allLabel: $("gc-all-label") };
+
+function gcBoxes() {
+	return [...gcEls.list.querySelectorAll("input[type=checkbox]")];
+}
+
+// Improvement 142: the 전체 선택 box and the clean button follow the ticked rows.
+function gcSync() {
+	const ticked = gcTicked().length;
+	const state = selectAllState(ticked, gcBoxes().length);
+	gcEls.allLabel.hidden = state.hidden;
+	gcEls.all.checked = state.checked;
+	gcEls.all.indeterminate = state.indeterminate;
+	gcEls.clean.disabled = ticked === 0;
+}
+
+gcEls.all.onchange = () => {
+	const boxes = gcBoxes();
+	const tick = selectAllTarget(gcTicked().length, boxes.length);
+	for (const box of boxes) box.checked = tick;
+	gcSync();
+};
 
 function gcTicked() {
 	return [...gcEls.list.querySelectorAll("input[type=checkbox]:checked")].map((box) => box.value);
@@ -3598,16 +3628,14 @@ function gcRow(row) {
 	const box = document.createElement("input");
 	box.type = "checkbox";
 	box.value = row.id;
-	box.onchange = () => { gcEls.clean.disabled = gcTicked().length === 0; };
+	box.onchange = gcSync;
 	const name = document.createElement("span");
 	name.className = "gc-name";
 	name.textContent = row.label;
-	name.dataset.tip = row.title;
-	name.dataset.tipOverflow = "";
+	name.title = row.title;
 	const sub = document.createElement("span");
 	sub.className = "gc-sub";
 	sub.textContent = row.sub;
-	sub.dataset.tipOverflow = "";
 	main.append(name, sub);
 	label.append(box, main);
 	li.append(label);
@@ -3627,6 +3655,7 @@ async function loadGc() {
 	gcEls.summary.textContent = view.summary;
 	gcEls.summary.classList.toggle("error", view.error);
 	gcEls.list.replaceChildren(...view.rows.map(gcRow));
+	gcSync();
 }
 
 gcEls.clean.onclick = async () => {

package/web/gc.d.ts

@@ -9,5 +9,7 @@ export const GC_FAILED_LINE: string;
 export function formatBytes(bytes: unknown): string;
 export function formatAge(ms: number): string;
 export function gcView(report: unknown): { summary: string; rows: GcRow[]; error: boolean };
+export function selectAllState(ticked: number, total: number): { hidden: boolean; checked: boolean; indeterminate: boolean };
+export function selectAllTarget(ticked: number, total: number): boolean;
 export function cleanRequest(ids: Iterable<string>): { method: "POST"; headers: { "content-type": "application/json" }; body: string };
 export function cleanResultLine(result: unknown): string;

package/web/gc.js

@@ -39,6 +39,17 @@ export function gcView(report) {
 	return { summary, rows, error: false };
 }
 
+// Improvement 142: the 전체 선택 box beside the summary. It is hidden with no rows, checked when every row is ticked and
+// indeterminate when only some are.
+export function selectAllState(ticked, total) {
+	return { hidden: total === 0, checked: total > 0 && ticked === total, indeterminate: ticked > 0 && ticked < total };
+}
+
+// A click on 전체 선택 ticks every row unless every row was already ticked; then it clears them all.
+export function selectAllTarget(ticked, total) {
+	return ticked < total;
+}
+
 export function cleanRequest(ids) {
 	return { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ ids: [...ids] }) };
 }

package/web/index.html

@@ -62,14 +62,14 @@
       <div class="chat-actions">
         <select class="model-select" id="model-select" title="엔진이 쓸 모델" disabled><option>모델 불러오는 중</option></select>
         <span class="model-pending" id="model-pending" hidden></span>
-        <button class="text-btn" id="rotate-session" title="이 대화의 엔진 세션을 새로 시작합니다. 화면의 기록은 그대로 남습니다.">새 세션</button>
-        <button class="text-btn" id="toggle-voice" title="이 게이트웨이의 음성 서버(음성 인식·음성 합성)를 켜고 끄기. 끄면 마이크·호출어·박수 감지·음성 답변을 쓸 수 없습니다." aria-pressed="true">음성 켜짐</button>
-        <button class="text-btn" id="voice-install" title="음성 서버(uv, Python 환경, 음성 모델)를 이 맥의 zigmini 폴더에 내려받아 설치합니다" hidden>음성 설치</button>
-        <button class="text-btn" id="toggle-clap" title="박수를 두 번 치면 호출어 대기를 켜고 끄기" aria-pressed="false">박수 감지 꺼짐</button>
-        <button class="text-btn" id="toggle-wake" title="&quot;헤이 지그&quot;라고 부르면 받아 적어 입력창에 채우기" aria-pressed="false">호출어 꺼짐</button>
-        <button class="text-btn" id="toggle-tts" title="답변을 음성으로 읽기" aria-pressed="false">음성 답변 꺼짐</button>
-        <button type="button" class="text-btn inbox-toggle" id="toggle-inbox" title="답을 기다리는 질문과 승인 요청 (Ctrl+C)" aria-haspopup="dialog" aria-expanded="false" aria-controls="inbox" aria-keyshortcuts="Control+C">확인함<span class="inbox-badge" id="inbox-badge" hidden>0</span></button>
-        <button type="button" class="text-btn" id="toggle-dev" title="이벤트 패널 (Ctrl+E)" aria-expanded="false" aria-controls="dev" aria-keyshortcuts="Control+E">이벤트</button>
+        <button class="text-btn" id="rotate-session" data-tip-keep title="이 대화의 엔진 세션을 새로 시작합니다. 화면의 기록은 그대로 남습니다.">새 세션</button>
+        <button class="text-btn" id="toggle-voice" data-tip-keep title="이 게이트웨이의 음성 서버(음성 인식·음성 합성)를 켜고 끄기. 끄면 마이크·호출어·박수 감지·음성 답변을 쓸 수 없습니다." aria-pressed="true">음성 켜짐</button>
+        <button class="text-btn" id="voice-install" data-tip-keep title="음성 서버(uv, Python 환경, 음성 모델)를 이 맥의 zigmini 폴더에 내려받아 설치합니다" hidden>음성 설치</button>
+        <button class="text-btn" id="toggle-clap" data-tip-keep title="박수를 두 번 치면 호출어 대기를 켜고 끄기" aria-pressed="false">박수 감지 꺼짐</button>
+        <button class="text-btn" id="toggle-wake" data-tip-keep title="&quot;헤이 지그&quot;라고 부르면 받아 적어 입력창에 채우기" aria-pressed="false">호출어 꺼짐</button>
+        <button class="text-btn" id="toggle-tts" data-tip-keep title="답변을 음성으로 읽기" aria-pressed="false">음성 답변 꺼짐</button>
+        <button type="button" class="text-btn inbox-toggle" id="toggle-inbox" data-tip-keep title="답을 기다리는 질문과 승인 요청 (Ctrl+C)" aria-haspopup="dialog" aria-expanded="false" aria-controls="inbox" aria-keyshortcuts="Control+C">확인함<span class="inbox-badge" id="inbox-badge" hidden>0</span></button>
+        <button type="button" class="text-btn" id="toggle-dev" data-tip-keep title="이벤트 패널 (Ctrl+E)" aria-expanded="false" aria-controls="dev" aria-keyshortcuts="Control+E">이벤트</button>
         <button type="button" class="text-btn" id="toggle-settings" title="설정: 폰 기기 등록 QR과 등록된 기기" aria-haspopup="dialog" aria-expanded="false" aria-controls="settings">설정</button>
       </div>
     </header>
@@ -100,7 +100,7 @@
       <button type="button" class="mic" id="toggle-memo" title="쪽지 열기/닫기" aria-pressed="false">쪽지</button>
       <button type="button" class="mic" id="attach" title="이미지 첨부 (최대 4장 · 붙여넣기나 끌어놓기도 됩니다)">이미지</button>
       <input type="file" id="attach-input" accept="image/png,image/jpeg,image/gif,image/webp" multiple hidden>
-      <button type="button" class="mic" id="mic" title="누르고 말하기 (다시 누르면 전송)">마이크</button>
+      <button type="button" class="mic" id="mic" data-tip-keep title="누르고 말하기 (다시 누르면 전송)">마이크</button>
       <textarea id="input" rows="1" placeholder="메시지 보내기" title="Enter 전송, Shift+Enter 줄바꿈"></textarea>
       <button type="submit" class="send" id="send">전송</button>
       <button type="button" class="stop" id="interrupt" title="진행 중인 작업 중단" hidden>중단</button>
@@ -178,7 +178,7 @@
         <div class="enroll-actions"><button type="button" class="text-btn" id="apk-renew" hidden>새로 만들기</button></div>
       </section>
       <section class="settings-section gc" id="gc" aria-labelledby="gc-title">
-        <div class="section-label"><span id="gc-title">정리</span><span class="gc-summary" id="gc-summary" role="status" aria-live="polite"></span></div>
+        <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>
         <p class="gc-message" id="gc-message" role="status" aria-live="polite"></p>
         <div class="gc-actions"><button type="button" class="text-btn" id="gc-clean" disabled>선택한 항목 정리</button></div>

package/web/style.css

@@ -412,6 +412,10 @@ button { font: inherit; color: inherit; cursor: pointer; }
 /* 정리 (improvement 66): inside .settings-body after 앱 내려받기; contain keeps its nowrap rows from widening the card on phones. */
 .settings-section.gc { contain: inline-size; }
 .gc-summary { text-transform: none; color: var(--text); }
+.gc-head { display: flex; align-items: center; gap: 12px; min-width: 0; }
+.gc-all { display: inline-flex; align-items: center; gap: 6px; text-transform: none; color: var(--text); font-weight: 400; cursor: pointer; white-space: nowrap; }
+.gc-all[hidden] { display: none; }
+.gc-all input { width: 16px; height: 16px; margin: 0; }
 .gc-list { margin: 0; padding: 0; list-style: none; display: flex; flex-direction: column; gap: 6px; }
 .gc-list:empty { display: none; }
 .gc-row { display: flex; align-items: center; gap: 8px; padding: 8px 10px; background: var(--bg-card); border: 1px solid #4e5058; border-radius: 6px; font-size: 13px; }

package/web/tooltip.d.ts

@@ -4,17 +4,11 @@ export type TipElement = {
 	setAttribute(name: string, value: string): void;
 	removeAttribute(name: string): void;
 	hasAttribute(name: string): boolean;
-	textContent: string | null;
-	scrollWidth: number;
-	clientWidth: number;
-	scrollHeight: number;
-	clientHeight: number;
 };
 export const TIP_GAP: number;
 export const TIP_MARGIN: number;
 export const TIP_ID: string;
 export function placeTip(anchor: Box, tip: { width: number; height: number }, view: { width: number; height: number }): { left: number; top: number; side: "above" | "below" };
-export function isTruncated(el: { scrollWidth: number; clientWidth: number; scrollHeight: number; clientHeight: number }): boolean;
 export function adoptTitle(el: Pick<TipElement, "getAttribute" | "setAttribute" | "removeAttribute" | "hasAttribute">): void;
 export function tipText(el: TipElement): string;
 export function addId(list: string | null, id: string): string;

package/web/tooltip.js

@@ -1,12 +1,13 @@
 // Bug 90: the page draws its own tooltip. Some browsers (the user's, likely Aside) never show the native `title`
-// tooltip, so every `title` in the page moves to `data-tip` and one shared element shows it on hover and keyboard focus,
-// linked with aria-describedby. Improvement 143: `data-tip-overflow` shows the tip only while the text is cut off.
+// tooltip, so a `title` moves to `data-tip` and one shared element shows it on hover and keyboard focus, linked with
+// aria-describedby. Bug 161: only elements marked `data-tip-keep` (새 세션, the voice buttons, 확인함, 이벤트) keep a
+// visible tip; every other `title` moves to `aria-description`, so neither the page nor the browser shows a tip for it.
 
 export const TIP_GAP = 6;
 export const TIP_MARGIN = 8;
 export const TIP_ID = "zgw-tip";
 const HOVER_DELAY_MS = 250;
-const SELECTOR = "[data-tip], [data-tip-overflow]";
+const SELECTOR = "[data-tip]";
 
 export function placeTip(anchor, tip, view) {
 	const left = Math.max(TIP_MARGIN, Math.min((anchor.left + anchor.right) / 2 - tip.width / 2, view.width - tip.width - TIP_MARGIN));
@@ -18,21 +19,17 @@ export function placeTip(anchor, tip, view) {
 	return { left, top, side: "below" };
 }
 
-export function isTruncated(el) {
-	return el.scrollWidth > el.clientWidth || el.scrollHeight > el.clientHeight;
-}
-
 export function adoptTitle(el) {
 	if (!el.hasAttribute("title")) return;
 	const text = el.getAttribute("title");
 	el.removeAttribute("title");
-	if (text) el.setAttribute("data-tip", text);
-	else el.removeAttribute("data-tip");
+	const attr = el.hasAttribute("data-tip-keep") ? "data-tip" : "aria-description";
+	if (text) el.setAttribute(attr, text);
+	else el.removeAttribute(attr);
 }
 
 export function tipText(el) {
-	if (el.hasAttribute("data-tip-overflow") && !isTruncated(el)) return "";
-	return el.getAttribute("data-tip") || (el.hasAttribute("data-tip-overflow") ? el.textContent : "") || "";
+	return el.hasAttribute("data-tip-keep") ? el.getAttribute("data-tip") || "" : "";
 }
 
 export function addId(list, id) {

package/web/update.d.ts

@@ -42,4 +42,4 @@ export function questionGate(counters: { readonly pending: number; readonly need
 export function canUpdate(status: unknown): boolean;
 export function updateStep(status: number, body: unknown): UpdateStep;
 export function resultLine(result: unknown): string | null;
-export function progressLine(data: unknown): string | null;
+export function progressLine(data: unknown, loadedVersion?: string | null): string | null;

package/web/update.js

@@ -89,10 +89,17 @@ export function resultLine(result) {
 	return `${typeof result.message === "string" ? result.message : "업데이트에 실패했습니다."}${typeof result.logPath === "string" && result.logPath !== "" ? ` (로그: ${result.logPath})` : ""}`;
 }
 
-/** The line for an `update.progress` payload or a GET /api/update/state body; null shows nothing. */
-export function progressLine(data) {
+/**
+ * The line for an `update.progress` payload or a GET /api/update/state body; null shows nothing. The gateway keeps the last
+ * result in state.json for good, so `loadedVersion` (the version the page first loaded on) hides an ok result that ended
+ * at that version: the page was reloaded after the update and the "reload the page" line is stale.
+ */
+export function progressLine(data, loadedVersion = null) {
 	if (data === null || typeof data !== "object") return null;
-	if (data.result !== undefined && data.result !== null) return resultLine(data.result);
+	if (data.result !== undefined && data.result !== null) {
+		if (data.result.ok === true && loadedVersion !== null && data.result.to === loadedVersion) return null;
+		return resultLine(data.result);
+	}
 	if (typeof data.label !== "string" || data.phase === "done") return null;
 	return `업데이트 중 (${data.from} → ${data.to}): ${data.label}`;
 }