zigmini 0.8.0-beta.4 → 0.8.0-beta.5

package/README.ko.md

@@ -2,7 +2,7 @@
 
 # zigmini
 
-zigmini는 맥에서 도는 개인 AI 에이전트 게이트웨이입니다. 맥의 웹 화면과 Android 앱에서 에이전트(OMO)와 대화하고, 작업을 맡기고, 알림을 받습니다. 게이트웨이와 브리지는 macOS 로그인 때 launchd가 자동으로 띄웁니다. Docker는 필요하지 않습니다.
+zigmini는 맥에서 도는 개인 AI 에이전트 게이트웨이입니다. 맥의 웹 화면과 Android 앱에서 에이전트와 대화하고, 작업을 맡기고, 알림을 받습니다. 게이트웨이와 브리지는 macOS 로그인 때 launchd가 자동으로 띄웁니다. Docker는 필요하지 않습니다.
 
 ## 요구 사항
 
@@ -103,7 +103,7 @@ zigmini는 에이전트를 권한 프리셋 `full-access`로 실행합니다.
 
 1. 권한 안내를 보여 주고 동의를 받습니다.
 2. 홈 폴더 `~/.zigmini`를 만듭니다. 이 설치의 규칙 파일(`~/.zigmini/rules.md`)이 없으면 빈 파일을 만듭니다. 아래 "에이전트 규칙"을 보세요.
-3. 에이전트 엔진(OMO, omo-ai)의 고정 버전을 내려받아 해시를 확인하고 패치합니다. 버전은 패키지가 정합니다(`src/engine/compat.json`, 이 문서를 쓸 때 OMO 5.1.35). 엔진 라이선스 요약을 보여 주고 동의(`y`)를 받습니다.
+3. 에이전트 엔진(omo-ai)의 고정 버전을 내려받아 해시를 확인하고 패치합니다. 버전은 패키지가 정합니다(`src/engine/compat.json`, 이 문서를 쓸 때 엔진 5.1.35). 엔진 라이선스 요약을 보여 주고 동의(`y`)를 받습니다.
 4. 에이전트 폴더와 모델 계정 로그인 상태를 확인합니다. 기본 에이전트 폴더는 `~/.omo/agent`이고, 같은 폴더를 쓰는 다른 OMO와 로그인 정보를 같이 씁니다. 로그인하지 않았으면 로그인 명령을 출력합니다. 그 명령을 실행한 뒤 `/login`을 입력합니다.
 5. Notion 토큰을 묻습니다(선택). 비우면 일정 기능이 꺼집니다.
 6. 외부 접속 방식을 묻습니다. 아래 "외부 접속"을 보세요.
@@ -187,7 +187,7 @@ zigmini update <버전>     # 지정한 버전으로 업데이트
 
 새 버전이 무중단 전환을 지원하면(0.8.0-beta.1 다음 버전부터) 진행 중인 턴을 끊지 않습니다.
 
-1. 새 브리지와 OMO(새 실행 세대)가 다른 포트에서 먼저 뜨고 확인을 받습니다. 확인에 실패하면 실행 중인 것은 그대로 두고 설치만 되돌립니다.
+1. 새 브리지와 엔진(새 실행 세대)가 다른 포트에서 먼저 뜨고 확인을 받습니다. 확인에 실패하면 실행 중인 것은 그대로 두고 설치만 되돌립니다.
 2. 게이트웨이만 다시 시작합니다. 웹과 폰은 수 초 뒤 다시 연결됩니다.
 3. 새 세션은 새 세대에서 열립니다. 이전 세대의 세션은 각자 턴이 끝나면 새 세대로 옮겨집니다.
 4. 이전 세대는 세션이 모두 옮겨지면 끝납니다. 메모리가 충분하면 최대 6시간, 아니면 최대 1시간을 기다립니다. 그때까지 끝나지 않은 턴은 끊깁니다. 마무리되면 main 채팅에 한 줄 알림이 옵니다.

package/README.md

@@ -2,7 +2,7 @@ English | [한국어](README.ko.md)
 
 # zigmini
 
-zigmini: a personal AI agent gateway that runs on a Mac. You talk with the agent (OMO), give it work and get notifications from the web screen on the Mac and from an Android app. launchd starts the gateway and the bridge automatically when you log in to macOS. Docker is not necessary.
+zigmini: a personal AI agent gateway that runs on a Mac. You talk with the agent, give it work and get notifications from the web screen on the Mac and from an Android app. launchd starts the gateway and the bridge automatically when you log in to macOS. Docker is not necessary.
 
 ## Requirements
 
@@ -103,7 +103,7 @@ The gateway runs the agent with the permission preset `full-access`. The agent d
 
 1. It shows the permission notice and asks for your consent.
 2. It creates the home folder `~/.zigmini`. If the rules file of this installation (`~/.zigmini/rules.md`) does not exist, it creates an empty one. See "Agent rules" below.
-3. It downloads the pinned version of the agent engine (OMO, omo-ai), checks its hash and patches it. The package decides the version (`src/engine/compat.json`; OMO 5.1.35 at the time of writing). It shows a summary of the engine license and asks for your consent (`y`).
+3. It downloads the pinned version of the agent engine (omo-ai), checks its hash and patches it. The package decides the version (`src/engine/compat.json`; engine 5.1.35 at the time of writing). It shows a summary of the engine license and asks for your consent (`y`).
 4. It checks the agent folder and the login state of the model account. The default agent folder is `~/.omo/agent`. Other OMO installations that use the same folder share the login data. If you are not logged in, it prints a login command. Run that command, then type `/login`.
 5. It asks for a Notion token (optional). If you leave it empty, the schedule feature is off.
 6. It asks for the external access method. See "External access" below.
@@ -187,7 +187,7 @@ When a new app version is available, the app shows "새 앱 버전" (new app ver
 
 If the new version supports a zero-downtime switch (versions after 0.8.0-beta.1), the update does not cut the turns in progress.
 
-1. A new bridge and OMO (a new runtime generation) start first on other ports and must pass a check. If the check fails, the update keeps the running ones and rolls back only the installation.
+1. A new bridge and engine (a new runtime generation) start first on other ports and must pass a check. If the check fails, the update keeps the running ones and rolls back only the installation.
 2. Only the gateway restarts. The web and the phone connect again after a few seconds.
 3. New sessions open in the new generation. Each session of the previous generation moves to the new generation when its turn ends.
 4. The previous generation ends when all its sessions have moved. It waits up to 6 hours if there is enough memory, otherwise up to 1 hour. Turns that are not done by then are cut. When the switch is complete, a one-line notice appears in the main chat.

package/assets/agent/gateway-rules.md

@@ -18,3 +18,4 @@ zigmini 패키지 공통 에이전트 규칙입니다. 게이트웨이 브리지
 13. 사용자의 시간 표현은 사용자의 현지 시간으로 해석합니다. 보고하는 시각도 현지 시간으로 씁니다.
 14. 사용자는 게이트웨이 프로필의 닉네임으로 부릅니다.
 15. main은 오래 기다리거나 오래 실행하는 작업(배포, 전체 테스트, 뮤테이션 테스트, 다른 작업 기다리기)을 맡기면, 그 작업의 세션 기록이 30분 넘게 바뀌지 않을 때 main을 깨우는 감시를 직접 겁니다. 작업이 끝나면 감시를 끕니다. 작업의 "기다리는 중"·"진행 중" 보고만 믿지 않습니다. 사용자에게 그렇게 말하기 전에 그 작업의 마지막 기록 시각과 실행 중인 프로세스를 확인합니다. 작업이 멈췄으면 바로 그 작업에 조치를 보내고 사용자에게 알립니다. 작업은 긴 명령을 세션과 분리해 실행하고, 결과 파일을 직접 확인하며, 시간 상한을 겁니다.
+16. 작업 하나에 나눌 수 있는 항목이 여럿이거나(예: 버그 여러 개, 구현·검증·문서 단계) 앞 단계를 기다려야 하는 단계가 있으면, 작업 세션은 mass-ulw 스킬을 씁니다. 작업 세션은 처음에 단계와 하위 작업을 정합니다. 서로 기다릴 필요가 없는 하위 작업은 최대한 병렬로 돌립니다. main은 이런 작업을 맡길 때 작업 지시문에 mass-ulw를 쓰라고 적습니다. 파일 하나 고침, 문서 한 줄 같은 작은 작업에는 mass-ulw를 쓰지 않습니다. 같은 파일을 고치는 하위 작업은 같은 단계에서 함께 돌리지 않습니다. 이런 하위 작업은 각자 worktree를 쓰거나 순서대로 돌립니다. 하위 작업을 병렬로 돌려도 무거운 명령(전체 테스트, 뮤테이션 테스트, 빌드 등)은 그 프로젝트나 설치 규칙이 정한 동시 실행 상한을 지킵니다. 규칙 8의 정리와 규칙 15의 감시는 하위 작업에도 적용합니다. 사용자가 질문만 하면 진행 중인 작업을 mass-ulw로 바꾸지 않습니다(규칙 4).

package/assets/android/zigmini.apk.json

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

package/assets/build.json

@@ -1 +1 @@
-{"commit":"8a70654fe6e2fe81a31be080c36b05c1cfae7c70"}
+{"commit":"6eea099deac067c0e19d44b3bb2890a341438510"}

package/docs/manual.ko.md

@@ -19,7 +19,7 @@ zigmini는 화면 두 개를 제공합니다.
 
 웹 화면은 세 부분으로 나뉩니다.
 
-- 왼쪽 사이드바: 대화 목록, 새 대화 버튼(+), 작업 상태 영역, 내 프로필, 에이전트 프로필이 있습니다. 사이드바 맨 위의 "omo" 배지는 에이전트 엔진 연결 상태를 보여 줍니다.
+- 왼쪽 사이드바: 대화 목록, 새 대화 버튼(+), 작업 상태 영역, 내 프로필, 에이전트 프로필이 있습니다. 사이드바 맨 위의 "엔진" 배지는 엔진 연결 상태를 보여 줍니다.
 - 가운데 채팅: 헤더, 메시지 목록, 입력창이 있습니다.
 - 오른쪽 패널: 확인함, 설정, 이벤트 패널이 열립니다.
 
@@ -208,7 +208,7 @@ Android 앱(APK)을 받는 QR이 보입니다. 폰 카메라로 QR을 찍어 APK
 
 #### 정리
 
-게이트웨이가 지워도 되는 후보를 보여 줍니다. 후보는 DB 백업, OMO 버전 폴더, 업데이트 남은 파일, 임시 폴더, 이전 RPC 데몬입니다. 지울 항목을 고르고 "선택한 항목 정리"를 누릅니다.
+게이트웨이가 지워도 되는 후보를 보여 줍니다. 후보는 DB 백업, 엔진 버전 폴더, 업데이트 남은 파일, 임시 폴더, 이전 RPC 데몬입니다. 지울 항목을 고르고 "선택한 항목 정리"를 누릅니다.
 
 #### 음성 설정
 
@@ -265,7 +265,7 @@ Ctrl 단축키는 Cmd, Alt, Shift와 함께 누르면 동작하지 않습니다.
 
 ### 4.1 연결
 
-앱 헤더 왼쪽에 지그 얼굴과 상태 태그가 있습니다. 상태 태그에는 "게이트웨이 재연결 중", "omo 끊김", "omo 연결됨", "작업 상태 확인 중" 중 하나가 보입니다.
+앱 헤더 왼쪽에 지그 얼굴과 상태 태그가 있습니다. 상태 태그에는 "게이트웨이 재연결 중", "엔진 끊김", "엔진 연결됨", "작업 상태 확인 중" 중 하나가 보입니다.
 
 | 조작 | 동작 |
 | --- | --- |

package/docs/manual.md

@@ -19,7 +19,7 @@ zigmini has two surfaces.
 
 The web screen has three parts.
 
-- Left sidebar: the conversation list, the new conversation button (+), the work status area, your profile and the agent profile. The "omo" badge at the top shows the agent engine connection.
+- Left sidebar: the conversation list, the new conversation button (+), the work status area, your profile and the agent profile. The "엔진" (engine) badge at the top shows the engine connection.
 - Center chat: the header, the message list and the input box.
 - Right panels: the inbox, settings and the event panel open here.
 
@@ -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, OMO 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).
 
 #### Voice settings
 
@@ -265,7 +265,7 @@ Ctrl shortcuts do nothing with Cmd, Alt or Shift held. They match by key positio
 
 ### 4.1 Connections
 
-The app header shows the Zig face and a status tag on the left. The tag reads one of "게이트웨이 재연결 중" (reconnecting), "omo 끊김" (omo disconnected), "omo 연결됨" (omo connected) or "작업 상태 확인 중" (checking work status).
+The app header shows the Zig face and a status tag on the left. The tag reads one of "게이트웨이 재연결 중" (reconnecting), "엔진 끊김" (engine disconnected), "엔진 연결됨" (engine connected) or "작업 상태 확인 중" (checking work status).
 
 | Action | What it does |
 | --- | --- |

package/host/omo-bridge/continuity-control.ts

@@ -98,7 +98,7 @@ function durableReadiness(ctx: ContinuityContext): string | null {
 	}
 
 	// Bug 86: only a tool call without its result can still be running. Work that outlives its tool call (task children,
-	// detached eval cells, background terminals, monitors, open questions) is owned through wake_source_state, which
+	// detached eval cells, background terminals, open questions) is owned through wake_source_state, which
 	// readiness checks before this; a settled call of any tool name leaves nothing behind.
 	const entries = ctx.sessionManager.getEntries();
 	const results = new Set(
@@ -162,7 +162,8 @@ export default function continuityControl<Context extends ContinuityContext>(
 		if (runtime.hasPendingMessages()) return result("native_queue");
 		if (runtime.isCompacting?.() !== false) return result("native_compaction");
 		if (wakeEvidenceInvalid || !wakes.has("senpi-task")) return result("task_registry_uninitialized");
-		if ([...wakes.values()].some((count) => count > 0)) return result("native_wake_ownership");
+		// Bug 153: session shutdown stops terminal monitors; monitoring now belongs to a separate OMO process.
+		if ([...wakes.entries()].some(([source, count]) => source !== "terminal-monitors" && count > 0)) return result("native_wake_ownership");
 		return result(durable ? durableReadiness(runtime) : null);
 	};
 	pi.rpc.handle("zgw.continuity_readiness", () => readiness(true));

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

@@ -1,5 +1,6 @@
 {
   "schema": 1,
+  "revision": 3,
   "upstream": {
     "omo": "5.1.35",
     "senpi": "2026.10.16"
@@ -9,7 +10,9 @@
   "entrypoint": "node_modules/@code-yeongyu/senpi/dist/cli.js",
   "patchRoot": "node_modules",
   "patches": [
-    "omo-5.1.35-gateway-port.patch"
+    "omo-5.1.35-gateway-port.patch",
+    "omo-5.1.35-image-replay.patch",
+    "omo-5.1.35-question-capability.patch"
   ],
   "files": [
     {
@@ -42,6 +45,11 @@
       "originalSha256": "f98f1758e934135084d2765f73b20e4c22f6a74dce344569c6dfbfe9dc250cbc",
       "patchedSha256": "218862c77a0df2691a521ae99c95e99acc64a8547dd6d6e627ebd98369d34fe0"
     },
+    {
+      "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/cold-seed-images.js",
+      "originalSha256": "f40ff494a945bc5188dca010476cac76ae60f178f67d5391457a04e7f266c16e",
+      "patchedSha256": "7c042bc1bfc0240cfd576cdc989f174dd248270219cc834788d22c9df3aa6903"
+    },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/core/extensions/builtin/ask-user/pending.js",
       "originalSha256": "0f8156f0cdd1fbc4bb08486d0b8b6ff5f821b9ac5df4cf5056714689fb2bb0c5",
@@ -110,12 +118,12 @@
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/modes/rpc/connection-handler.js",
       "originalSha256": "20c6ef0ebe92cd4a94b78623bd6ae1144909709c10dd826e7c313932b6c28775",
-      "patchedSha256": "f46ad1cf60f2fb0ffd1a1f27cc6710f29778a6abe9f9ba0c12b9ffc7d2bdd49f"
+      "patchedSha256": "239dd0f928a7b2c89ca1ebde7bc1ca5f796f303a4430060796c8585099094da3"
     },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/modes/rpc/connection-question-bridge.js",
       "originalSha256": "0b63f63575df24ebf3f80dc891ffe876a9d908bc1a2264525919e4a8cef061b8",
-      "patchedSha256": "1307c0dca8ea2cae4400e0fdabd7efe6f0becdc01d3c29a64737fe4fc3dc8206"
+      "patchedSha256": "f88a26b34f127d35debbcc3e6b6a6d26a75b5a32aee852af9c51b6c770956813"
     },
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/modes/rpc/multi-session-host.js",
@@ -140,7 +148,7 @@
     {
       "path": "node_modules/@code-yeongyu/senpi/dist/modes/rpc/session-command-router.js",
       "originalSha256": "3f952631024884c893a6e37549c2861e25b0bddc2387222006b77dcbaad78c9b",
-      "patchedSha256": "feded26ac955d2461df8818bed1cc5a3b21fdc213e38f43c7618943fb67add33"
+      "patchedSha256": "95515f802619da5e54352b8d996b8b71c6db91f1574470626239de2764367f9b"
     },
     {
       "path": "node_modules/@earendil-works/pi-agent-core/dist/agent.d.ts",

package/host/omo-check/patches/omo-5.1.35-image-replay.patch

@@ -0,0 +1,45 @@
+diff -ruN a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/cold-seed-images.js b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/cold-seed-images.js
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/cold-seed-images.js	2026-10-20 08:58:36
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/anthropic-subscription/cold-seed-images.js	2026-10-20 08:58:36
+@@ -21,6 +21,7 @@
+     toolOutput: (toolName) => `[image returned by the ${toolName} tool to your own call (tool output, not a user attachment)]`,
+     userHistory: "[image the user attached in this earlier turn (history, not part of the current message)]",
+     duplicate: (origin, first) => `${subject(origin)}: identical to an image already shown above (${source(first)}); not attached again]`,
++    userAnswered: "[image the user attached in an earlier turn: you already saw and answered it, so it is not attached again and is not part of the current message; ask the user to attach it again if you need it]",
+     answered: (origin) => `[image returned earlier by the ${origin.toolName} tool, id=${origin.toolCallId}: already seen earlier in this conversation; run the tool again if you need it]`,
+     capped: (origin) => `${subject(origin)}: omitted from this replay, which re-sends at most ${MAX_REPLAYED_HISTORY_IMAGES} earlier images; re-read the source if you need it]`,
+     unreadable: (origin) => `${subject(origin)}: omitted because its image data is missing or unreadable]`,
+@@ -86,14 +87,16 @@
+     return new Set(ordered.slice(0, MAX_REPLAYED_HISTORY_IMAGES).map(([hash]) => hash));
+ }
+ /**
+- * A tool image the assistant already responded to is not re-sent (#2768): a cold
+- * seed packs the whole history into one user message, and replaying earlier tool
+- * reads there made the model answer plain questions as if the user had just sent
+- * those images. The user's own uploads and images still awaiting a response are
+- * replayed.
++ * An image the assistant already responded to is not re-sent (#2768): a cold
++ * seed packs the whole history into one user message, and replaying earlier
++ * images there made the model answer plain questions as if the user had just
++ * sent those images. zigmini: this covers the user's own earlier uploads too;
++ * Claude Code saved each replayed upload as a new images/N.png on every model
++ * call and the model read it as a new attachment. Images still awaiting a
++ * response (the current turn) are replayed.
+  */
+ function isAnsweredToolImage(occurrence) {
+-    return occurrence.answered && occurrence.origin.kind === "tool";
++    return occurrence.answered;
+ }
+ /**
+  * Rewrites the image entries of a cold-seed history (#2490): a tool-result image
+@@ -124,8 +127,8 @@
+         if (decoded === undefined || hash === undefined) {
+             replacement = [{ type: "text", text: coldSeedImageText.unreadable(origin) }];
+         }
+-        else if (origin.kind === "tool" && occurrence.answered && shownEarlier === undefined) {
+-            replacement = [{ type: "text", text: coldSeedImageText.answered(origin) }];
++        else if (occurrence.answered && shownEarlier === undefined) {
++            replacement = [{ type: "text", text: origin.kind === "tool" ? coldSeedImageText.answered(origin) : coldSeedImageText.userAnswered }];
+         }
+         else if (!replayed.has(hash) && shownEarlier === undefined) {
+             replacement = [{ type: "text", text: coldSeedImageText.capped(origin) }];

package/host/omo-check/patches/omo-5.1.35-question-capability.patch

@@ -0,0 +1,65 @@
+diff --git a/@code-yeongyu/senpi/dist/modes/rpc/connection-handler.js b/@code-yeongyu/senpi/dist/modes/rpc/connection-handler.js
+--- a/@code-yeongyu/senpi/dist/modes/rpc/connection-handler.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/connection-handler.js
+@@ -313,7 +313,8 @@
+      * Create an extension UI context that uses the RPC protocol.
+      */
+     const createExtensionUIContext = () => ({
+-        question: (request, opts) => clientCapabilities?.includes(QUESTION_CAPABILITY)
++        // zgw (bug 151): a binding made without a connection (a handoff reopen) asks the session's live connections.
++        question: (request, opts) => clientCapabilities?.includes(QUESTION_CAPABILITY) || options.clientInfo?.sessionHasCapability?.(QUESTION_CAPABILITY)
+             ? questions.ask(request, opts)
+             : degradeQuestion(createExtensionUIContext(), request, opts),
+         select: (title, options, opts) => createDialogPromise(opts, undefined, {
+diff --git a/@code-yeongyu/senpi/dist/modes/rpc/connection-question-bridge.js b/@code-yeongyu/senpi/dist/modes/rpc/connection-question-bridge.js
+--- a/@code-yeongyu/senpi/dist/modes/rpc/connection-question-bridge.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/connection-question-bridge.js
+@@ -148,7 +148,8 @@
+         else if (selected !== undefined)
+             answers[question.id] = { selected: [selected] };
+     }
+-    const comment = await ui.input("Anything else? (optional)", undefined, opts);
++    // zgw (bug 151): the optional comment never inherits the question's required flag.
++    const comment = await ui.input("Anything else? (optional)", undefined, opts && { ...opts, required: false });
+     const unanswered = request.questions.filter((q) => !answers[q.id]).map((q) => q.id);
+     return {
+         status: comment?.trim() ? "comment-submitted" : unanswered.length ? "cancelled" : "answered",
+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
+@@ -558,6 +558,27 @@
+         });
+     }
+     /**
++     * zgw (bug 151): whether the session's clients advertised a capability, read when it is needed. A binding keeps the
++     * capabilities of the connection that opened it, and a handoff reopen has none. Attached live connections decide;
++     * with none attached, any live connection that advertised it does, since a question frame is replayed on attach.
++     */
++    sessionAdvertises(sessionId, capability) {
++        let attached = false;
++        for (const [connection, sessions] of this.sessionsByConnection) {
++            if (!sessions.has(sessionId) || this.releasedConnections.has(connection))
++                continue;
++            attached = true;
++            if (this.pendingCapabilities.get(connection)?.includes(capability))
++                return true;
++        }
++        if (attached)
++            return false;
++        for (const [connection, capabilities] of this.pendingCapabilities)
++            if (!this.releasedConnections.has(connection) && this.writer.hasRegisteredConnectionCapabilities(connection) && capabilities.includes(capability))
++                return true;
++        return false;
++    }
++    /**
+      * The successor's reopen of a handoff-parked session: the same open as an `open_session`, with no
+      * requesting connection and nothing to reply to (senpi#3368). Resolves `undefined` on success and
+      * the failure response otherwise, exactly as an open does.
+@@ -675,6 +696,7 @@
+                             }
+                         },
+                         connectionId: () => this.writer.currentConnection(),
++                        sessionHasCapability: (capability) => this.sessionAdvertises(openedSession.sessionId, capability),
+                     },
+                 }));
+                 if (entry.worker)

package/package.json

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

package/src/cli/doctor.ts

@@ -108,10 +108,10 @@ export async function collect(deps: DoctorDeps, ctx: LaunchdContext): Promise<Do
 	const health = await deps.health(healthUrl(ctx));
 	if (health === null) {
 		items.push({ id: "gateway.health", label: "게이트웨이", status: "bad", detail: `응답 없음 (${healthUrl(ctx)})` });
-		items.push({ id: "gateway.omo", label: "omo 연결", status: "bad", detail: "게이트웨이 응답 없음" });
+		items.push({ id: "gateway.omo", label: "엔진 연결", status: "bad", detail: "게이트웨이 응답 없음" });
 	} else {
 		items.push({ id: "gateway.health", label: "게이트웨이", status: health.status === 200 ? "ok" : "bad", detail: `HTTP ${health.status}` });
-		items.push({ id: "gateway.omo", label: "omo 연결", status: health.omo === "ready" ? "ok" : "bad", detail: health.omo === "ready" ? "" : `omo=${health.omo ?? "?"}` });
+		items.push({ id: "gateway.omo", label: "엔진 연결", status: health.omo === "ready" ? "ok" : "bad", detail: health.omo === "ready" ? "" : `omo=${health.omo ?? "?"}` });
 		items.push(...await voiceItems(deps, ctx, health.voice));
 		if (deps.updateStatus !== undefined) items.push(updateItem(await deps.updateStatus(`http://127.0.0.1:${ctx.paths.ports.web}${UPDATE_STATUS_PATH}`)));
 	}
@@ -129,13 +129,13 @@ export async function collect(deps: DoctorDeps, ctx: LaunchdContext): Promise<Do
 	const pinned = deps.pinnedEngine();
 	const global = deps.globalEngine();
 	const latest = await deps.latestEngine();
-	items.push({ id: "omo.version", label: "omo 버전", status: pinned === null ? "warn" : "info",
+	items.push({ id: "omo.version", label: "엔진 버전", status: pinned === null ? "warn" : "info",
 		detail: `고정 ${pinned ?? "없음"}, 전역 ${global ?? "?"}, npm 최신 ${latest ?? "확인 실패"}` });
 	const globalWarning = pinned === null ? null : globalEngineWarning(global, pinned);
-	if (globalWarning !== null) items.push({ id: "omo.global", label: "전역 omo", status: "warn", detail: globalWarning });
+	if (globalWarning !== null) items.push({ id: "omo.global", label: "전역 OMO", status: "warn", detail: globalWarning });
 
 	const rpc = deps.rpcDaemons();
-	items.push({ id: "omo.rpc", label: "omo RPC 호스트 데몬", status: rpc === null ? "warn" : "info", detail: rpc === null ? "확인 실패" : rpc.length === 0 ? "없음" : `${rpc.length}개 (나열만)` });
+	items.push({ id: "omo.rpc", label: "엔진 RPC 호스트 데몬", status: rpc === null ? "warn" : "info", detail: rpc === null ? "확인 실패" : rpc.length === 0 ? "없음" : `${rpc.length}개 (나열만)` });
 
 	const schema = deps.schema();
 	items.push({ id: "schema", label: "thread gateway 스키마", status: schema.state === "too_new" ? "warn" : schema.state === "ok" ? "ok" : "info",

package/src/cli/main.ts

@@ -20,7 +20,7 @@ export const HELP = `zigmini - 개인 AI 에이전트 게이트웨이
 사용법: zigmini <명령> [옵션]
 
 명령:
-  setup                       설치합니다: 홈 폴더, 엔진(OMO), 설정, launchd 등록과 시작
+  setup                       설치합니다: 홈 폴더, 엔진, 설정, launchd 등록과 시작
   start                       게이트웨이와 브리지를 launchd에 등록하고 시작합니다
   stop                        게이트웨이와 브리지를 멈춥니다
   stop --uninstall            멈추고 이 패키지의 launchd plist를 모두 지웁니다

package/src/engine/schema-guard.ts

@@ -17,7 +17,7 @@ export const STORE = join("gateway", "gateway.sqlite");
 export const GUARD_FILE = "schema-guard.json";
 export const GLOBAL_ENGINE_PACKAGE = join("install", "global", "node_modules", "omo-ai", "package.json");
 export const SCHEMA_TOO_NEW = "schema_too_new";
-export const NOTICE_TITLE = "OMO 스키마 충돌: 브리지를 멈췄습니다";
+export const NOTICE_TITLE = "엔진 스키마 충돌: 브리지를 멈췄습니다";
 
 export type StoreReading =
 	| { readonly state: "ok"; readonly version: number }

package/src/hub.ts

@@ -47,6 +47,14 @@ export interface HubOptions {
 	media?: { dir: string; hostDir?: string };
 	now?: () => number;
 	rotation?: { maxAgeMs?: number; idleMs?: number; forceMaxBytes?: number; forceUpdateCompactions?: number };
+	/** Bug 152: bounded native ownership reconciliation; timers are injectable for deterministic tests. */
+	closeRecovery?: {
+		intervalMs?: number;
+		maxAttempts?: number;
+		timeoutMs?: number;
+		setTimeout?: (callback: () => void, ms: number) => ReturnType<typeof setTimeout>;
+		clearTimeout?: (timer: ReturnType<typeof setTimeout>) => void;
+	};
 	/** Answers `/version` as a notice; the command never reaches omo. */
 	versionReport?: () => Promise<string>;
 	/** Answers `/usage` (model account usage) as a notice; the command never reaches omo. */
@@ -89,6 +97,7 @@ export interface RotationStatus {
 	/** First sweep that found it held in this gateway run; null when not held or not yet swept. */
 	readonly blockedSince: string | null;
 	readonly blockers: readonly RotationBlocker[];
+	readonly closeRecovery?: { readonly state: "recovering" | "exhausted"; readonly attempts: number; readonly maxAttempts: number };
 }
 
 /** omo writes a new session file with its first entry; until then the session has no size. */
@@ -120,6 +129,23 @@ interface OpenResult {
 	streaming: boolean;
 }
 
+interface CloseRecovery {
+	attempts: number;
+	exhausted: boolean;
+	timer?: ReturnType<typeof setTimeout>;
+	flight?: Promise<void>;
+	cancel?: () => void;
+}
+
+interface SessionRetirement {
+	sessionId: string;
+	sessionPath: string;
+	from: string | null;
+	reason: RotationReason;
+	handoff: string;
+	closeAcknowledged?: boolean;
+}
+
 export interface SlashCommand {
 	name: string;
 	description: string;
@@ -230,7 +256,7 @@ export const MAIN_QUESTION_RELEASED =
 const PERMISSION_PREFIX = "Permission required:";
 const AUTO_CONTINUE_LIMIT = 2;
 const CONTINUE_PROMPT =
-	"[게이트웨이 알림] 게이트웨이나 omo가 재시작되면서 이전 작업이 중간에 끊겼습니다. 세션 기록에서 마지막으로 한 일을 확인하고, 이미 끝난 단계는 반복하지 말고 끊긴 지점부터 이어서 마무리해 주세요.";
+	"[게이트웨이 알림] 게이트웨이나 엔진이 재시작되면서 이전 작업이 중간에 끊겼습니다. 세션 기록에서 마지막으로 한 일을 확인하고, 이미 끝난 단계는 반복하지 말고 끊긴 지점부터 이어서 마무리해 주세요.";
 
 /** A model as omo reports it (get_available_models / get_state); only the fields the gateway uses. */
 interface OmoModel {
@@ -274,6 +300,7 @@ export class Hub {
 	private readonly questions = new Map<string, QuestionCard>();
 	private readonly rotationHeld = new Map<string, { since: number; logged: boolean }>();
 	private readonly rotationFailures = new Map<string, { message: string; at: number }>();
+	private readonly closeRecoveries = new Map<string, CloseRecovery>();
 	private readonly legacyQuestionHistoryAliases = new Map<string, string>();
 	private readonly uiOwners = new Map<string, ScopedUiOwner>();
 	private readonly uiSessionScopes = new Map<string, string>();
@@ -668,6 +695,11 @@ export class Hub {
 		this.eventCount += 1;
 		if (status !== "ready") {
 			this.generation += 1;
+			for (const recovery of this.closeRecoveries.values()) {
+				if (recovery.timer !== undefined) this.clearCloseTimer(recovery.timer);
+				recovery.cancel?.();
+			}
+			this.closeRecoveries.clear();
 			this.sessionToConv.clear();
 			for (const owner of this.uiOwners.values()) this.decisions?.release(owner);
 			this.uiOwners.clear();
@@ -681,7 +713,7 @@ export class Hub {
 				rt.wake = null;
 				rt.notified.clear();
 				const scope = this.conversationScope(conv);
-				this.dialogs.cancelScope(scope, "omo 연결이 끊겼습니다.");
+				this.dialogs.cancelScope(scope, "엔진 연결이 끊겼습니다.");
 				for (const [id, card] of this.questions) {
 					if (card.scope !== scope) continue;
 					this.questions.delete(id);
@@ -709,17 +741,22 @@ export class Hub {
 		for (const conv of conversations) {
 			if (this.omoStatus !== "ready" || generation !== this.generation) return;
 			try {
+				if (this.closeUncertain(conv.id)) {
+					await this.reconcileClose(conv.id);
+					if (this.closeUncertain(conv.id) || generation !== this.generation) continue;
+				}
+				const current = this.store.getConversation(conv.id) ?? conv;
 				const pendingUsers = this.store.pendingMainUsers(conv.id);
 				if (pendingUsers.length > 0) {
-					await this.ensureSession(conv);
+					await this.ensureSession(current);
 					for (const user of pendingUsers) {
 						const data = user.data as { text: string; images?: string[]; references?: MessageReference[] };
 						const input = referencedInput(data.text, data.images ?? [], data.references);
 						await this.prompt(conv.id, input.text, input.images, user.seq, true);
 					}
-				} else if (this.hasUnfinishedTurn(conv.id)) await this.recoverConversation(conv);
-				else if (this.openQuestionCards(conv.id, this.conversationScope(conv.id)).size > 0) await this.ensureSession(conv);
-				else if (this.store.unreportedWorkUpdates(conv.id).length > 0 || this.workSummary(conv.id).length > 0) await this.ensureSession(conv);
+				} 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);
 				// Opening main comes first. A notification ACK or worker reconciliation cannot hold readiness.
 				void this.notifyWorkUpdates(conv.id);
 			} catch (error) {
@@ -763,7 +800,13 @@ export class Hub {
 		this.decisions?.refresh();
 		const rotationDone = this.rt(convId).rotationDone;
 		if (rotationDone) await rotationDone;
-		if (this.closeUncertain(convId)) throw new Error("session_close_unknown");
+		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: "세션 닫기 상태를 확인하고 있습니다. 메시지는 확인 후 전달합니다." });
+			return;
+		}
 		await this.prompt(convId, prompt.text, prompt.images, input.seq, true);
 	}
 
@@ -998,7 +1041,7 @@ export class Hub {
 						&& (event.data as { input_seq?: number }).input_seq === input.seq).at(-1);
 					if ((previous?.data as { kind?: string } | undefined)?.kind !== kind) this.emit(conv, "notice", {
 						kind, input_seq: input.seq, level: "warning",
-						message: queued ? "메시지가 OMO 대기열에 남아 있습니다. 자동 재전송하지 않습니다."
+						message: queued ? "메시지가 엔진 대기열에 남아 있습니다. 자동 재전송하지 않습니다."
 							: "메시지의 실행 소비를 확인하지 못했습니다. 기록을 보존하며 자동 재전송하지 않습니다.",
 					});
 					if (queued && data.native_identity && rt.atomicQueuedResume && state &&
@@ -1129,49 +1172,31 @@ export class Hub {
 			}
 			// Any rotation hands main's open waits of the closed session to the next one (inbox resume); bug 72.
 			this.retireScopedQuestions(convId, sessionId);
+			const retirement: SessionRetirement = {
+				sessionId, sessionPath: source, from, reason,
+				handoff: this.buildHandoff(convId, reason, source, handoffThrough),
+			};
+			let closeAcknowledged = false;
 			try {
 				await this.requireOmo().command("close_session", { sessionId });
-				const listed = await this.requireOmo().command<{
-					sessions?: { sessionId?: string; sessionPath?: string }[];
-				}>("list_sessions", { include_all: true, include_workers: true });
+				closeAcknowledged = true;
+				const listed = await this.requireOmo().command("list_sessions", { include_all: true, include_workers: true });
 				if (
-					generation !== this.generation || this.omoStatus !== "ready" || !Array.isArray(listed.sessions) ||
-					listed.sessions.some(
-						(entry) =>
-							!entry ||
-							typeof entry.sessionId !== "string" ||
-							typeof entry.sessionPath !== "string" ||
-							entry.sessionId === sessionId ||
-							entry.sessionPath === source,
-					)
+					generation !== this.generation || this.omoStatus !== "ready" ||
+					this.targetSessionPresent(listed, sessionId, source)
 				) {
 					throw new Error("session_retirement_unconfirmed");
 				}
 			} catch (error) {
 				this.emit(convId, "session.close.unknown", {
-					sessionPath: source,
-					sessionId,
+					...retirement,
+					closeAcknowledged,
 					message: errorMessage(error),
 				});
+				this.scheduleCloseRecovery(convId);
 				throw error;
 			}
-			const owner = this.ownerForConversation(convId, sessionId);
-			this.sessionToConv.delete(sessionId);
-			if (owner) this.releaseScopedUiOwner(owner);
-			rt.sessionId = null;
-			rt.itemId = null;
-			rt.itemText = "";
-			rt.notified.clear();
-			const to = `${this.options.sessionDir.replace(/\/$/, "")}/zgw-${conv.id}-${fileStamp(this.now())}-${crypto.randomUUID().slice(0, 8)}.jsonl`;
-			const handoff = this.buildHandoff(convId, reason, source, handoffThrough);
-			this.store.rotateThread(convId, to, new Date(this.now()).toISOString(), handoff);
-			this.emit(convId, "conversation.thread", { threadId: to });
-			this.emit(convId, "session.rotated", { reason, from, to });
-			this.emit(convId, "notice", {
-				kind: "session-rotated",
-				level: "info",
-				message: `새 omo 세션으로 교체했습니다 (${this.reasonLabel(reason)}). 화면의 대화 기록은 그대로이고, 다음 메시지부터 새 세션에서 이어집니다.`,
-			});
+			this.finishRetirement(convId, retirement);
 			return this.store.getConversation(convId) ?? conv;
 		} finally {
 			rt.rotating = false;
@@ -1187,7 +1212,120 @@ export class Hub {
 	}
 
 	private closeUncertain(conv: string): boolean {
-		return this.store.lastSeq(conv, "session.close.unknown") > this.store.lastSeq(conv, "session.rotated");
+		return this.store.lastSeq(conv, "session.close.unknown") >
+			Math.max(this.store.lastSeq(conv, "session.rotated"), this.store.lastSeq(conv, "session.close.resolved"));
+	}
+
+	/** A valid native inventory proves absence by target identity, not by the shape of unrelated worker entries. */
+	private targetSessionPresent(listed: unknown, sessionId: string, sessionPath: string): boolean {
+		if (typeof listed !== "object" || listed === null || !("sessions" in listed) || !Array.isArray(listed.sessions)) {
+			throw new Error("session_list_invalid");
+		}
+		return listed.sessions.some((entry: unknown) => typeof entry === "object" && entry !== null &&
+			(("sessionId" in entry && entry.sessionId === sessionId) || ("sessionPath" in entry && entry.sessionPath === sessionPath)));
+	}
+
+	private finishRetirement(convId: string, retirement: SessionRetirement): void {
+		const rt = this.rt(convId);
+		const owner = this.ownerForConversation(convId, retirement.sessionId);
+		this.sessionToConv.delete(retirement.sessionId);
+		if (owner) this.releaseScopedUiOwner(owner);
+		rt.sessionId = null;
+		rt.itemId = null;
+		rt.itemText = "";
+		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);
+		this.emit(convId, "conversation.thread", { threadId: to });
+		this.emit(convId, "session.rotated", { reason: retirement.reason, from: retirement.from, to });
+		this.emit(convId, "notice", { kind: "session-rotated", level: "info",
+			message: `새 엔진 세션으로 교체했습니다 (${this.reasonLabel(retirement.reason)}). 화면의 대화 기록은 그대로이고, 다음 메시지부터 새 세션에서 이어집니다.` });
+	}
+
+	private closeTimer(callback: () => void, ms: number): ReturnType<typeof setTimeout> {
+		const schedule = this.options.closeRecovery?.setTimeout;
+		return schedule ? schedule(callback, ms) : setTimeout(callback, ms);
+	}
+
+	private clearCloseTimer(timer: ReturnType<typeof setTimeout>): void {
+		(this.options.closeRecovery?.clearTimeout ?? clearTimeout)(timer);
+	}
+
+	private scheduleCloseRecovery(convId: string): void {
+		if (this.omoStatus !== "ready" || !this.closeUncertain(convId)) return;
+		const recovery = this.closeRecoveries.get(convId) ?? { attempts: 0, exhausted: false };
+		this.closeRecoveries.set(convId, recovery);
+		if (recovery.exhausted || recovery.timer !== undefined || recovery.flight) return;
+		recovery.timer = this.closeTimer(() => {
+			recovery.timer = undefined;
+			return this.reconcileClose(convId).then(() => {
+				if (this.omoStatus === "ready" && !this.closeUncertain(convId)) return this.recover();
+			});
+		}, this.options.closeRecovery?.intervalMs ?? 5_000);
+	}
+
+	/** Never re-close an uncertain native or send to it before a fresh inventory establishes ownership. */
+	private reconcileClose(convId: string): Promise<void> {
+		const recovery = this.closeRecoveries.get(convId) ?? { attempts: 0, exhausted: false };
+		this.closeRecoveries.set(convId, recovery);
+		if (recovery.flight) return recovery.flight;
+		if (recovery.exhausted || this.omoStatus !== "ready" || this.rt(convId).rotating) return Promise.resolve();
+		if (recovery.timer !== undefined) this.clearCloseTimer(recovery.timer);
+		recovery.timer = undefined;
+		const generation = this.generation;
+		const event = this.store.getEvent(this.store.lastSeq(convId, "session.close.unknown"));
+		if (!event || !this.closeUncertain(convId)) return Promise.resolve();
+		recovery.attempts += 1;
+		recovery.flight = (async () => {
+			let timeout: ReturnType<typeof setTimeout> | undefined;
+			try {
+				const cancelled = new Promise<never>((_resolve, reject) => {
+					recovery.cancel = () => reject(new Error("session_close_recovery_disconnected"));
+					timeout = this.closeTimer(() => reject(new Error("session_close_verification_timeout")),
+						this.options.closeRecovery?.timeoutMs ?? 10_000);
+				});
+				const listed = await Promise.race([
+					this.requireOmo().command("list_sessions", { include_all: true, include_workers: true }), cancelled,
+				]);
+				if (generation !== this.generation || this.omoStatus !== "ready") return;
+				const data = event.data as Partial<SessionRetirement>;
+				if (typeof data.sessionId !== "string" || typeof data.sessionPath !== "string") throw new Error("session_close_identity_missing");
+				const present = this.targetSessionPresent(listed, data.sessionId, data.sessionPath);
+				const current = this.store.getConversation(convId);
+				if (current?.threadId === data.sessionPath && !present) {
+					const reason = data.reason ?? "manual";
+					this.finishRetirement(convId, { sessionId: data.sessionId, sessionPath: data.sessionPath, from: data.from ?? data.sessionPath,
+						reason, handoff: data.handoff ?? this.buildHandoff(convId, reason, data.sessionPath, event.seq - 1) });
+				} else {
+					// A successful close releases this connection even when another attachment keeps the native alive.
+					// Reopen that source before sending again; a rejected close must not duplicate a still-owned attachment.
+					if (present && data.closeAcknowledged && current?.threadId === data.sessionPath) {
+						this.sessionToConv.delete(data.sessionId);
+						this.rt(convId).sessionId = null;
+					} else if (present && this.rt(convId).sessionId === data.sessionId && current?.threadId === data.sessionPath) {
+						// The rejected close kept its trusted open_session attachment; restore the UI authority retired above.
+						this.bindScopedUiOwner({ conv: convId, scope: this.conversationScope(convId), sessionId: data.sessionId, sessionPath: data.sessionPath });
+					}
+					this.emit(convId, "session.close.resolved", { sessionId: data.sessionId, sessionPath: data.sessionPath,
+						outcome: present ? "retained" : "superseded", attempts: recovery.attempts });
+					this.emit(convId, "notice", { kind: "session-close-resolved", level: "info",
+						message: "세션 닫기 상태를 확인했습니다. 기존 대화에서 메시지 처리를 계속합니다." });
+				}
+				this.closeRecoveries.delete(convId);
+			} catch (error) {
+				if (generation !== this.generation) return;
+				if (recovery.attempts >= (this.options.closeRecovery?.maxAttempts ?? 3)) {
+					recovery.exhausted = true;
+					this.emit(convId, "error", { message: `session_close_recovery_exhausted: ${errorMessage(error)}. 메시지는 보관 중입니다. 엔진 연결과 세션 목록을 확인한 뒤 게이트웨이를 다시 시작하세요.` });
+				}
+			} finally {
+				if (timeout !== undefined) this.clearCloseTimer(timeout);
+				recovery.cancel = undefined;
+				recovery.flight = undefined;
+				if (generation === this.generation && this.closeUncertain(convId)) this.scheduleCloseRecovery(convId);
+			}
+		})();
+		return recovery.flight;
 	}
 
 	private rotationBlocked(conv: string, inboxDecisions = true): boolean {
@@ -1255,7 +1393,10 @@ export class Hub {
 			if (!conv.threadId?.startsWith("/")) continue;
 			const blockers = this.rotationHolds(conv.id);
 			const held = blockers.length > 0 ? this.rotationHeld.get(conv.id) : undefined;
-			status[conv.id] = { blocked: blockers.length > 0, blockedSince: held ? new Date(held.since).toISOString() : null, blockers };
+			const recovery = this.closeRecoveries.get(conv.id);
+			status[conv.id] = { blocked: blockers.length > 0, blockedSince: held ? new Date(held.since).toISOString() : null, blockers,
+				...(recovery ? { closeRecovery: { state: recovery.exhausted ? "exhausted" as const : "recovering" as const,
+					attempts: recovery.attempts, maxAttempts: this.options.closeRecovery?.maxAttempts ?? 3 } } : {}) };
 		}
 		return status;
 	}
@@ -1396,7 +1537,7 @@ export class Hub {
 			lines.unshift(line);
 		}
 		return [
-			`[게이트웨이 알림] 이 대화는 새 omo 세션으로 교체됐습니다 (${this.reasonLabel(reason)}).`,
+			`[게이트웨이 알림] 이 대화는 새 엔진 세션으로 교체됐습니다 (${this.reasonLabel(reason)}).`,
 			from ? `이전 세션의 전체 기록은 ${from} 에 남아 있습니다. 파일이 크니 필요할 때 필요한 부분만 검색해서 보세요.` : "",
 			...this.handoffOpenItems(conv),
 			"아래는 직전 대화의 최근 부분입니다. 맥락으로만 참고하세요.",
@@ -1466,7 +1607,7 @@ export class Hub {
 		if (!CONTEXT_OVERFLOW.test(message)) return { message };
 		return {
 			kind: "continuity-protected",
-			message: `${message}. 같은 omo 세션을 유지합니다. 원인을 해결한 뒤 계속할 지시를 보내 주세요. 이전 입력은 자동 재전송하지 않습니다.`,
+			message: `${message}. 같은 엔진 세션을 유지합니다. 원인을 해결한 뒤 계속할 지시를 보내 주세요. 이전 입력은 자동 재전송하지 않습니다.`,
 		};
 	}
 

package/src/omo-check.ts

@@ -45,8 +45,8 @@ export class OmoCheckScheduler {
 		const version = body.version;
 		const result = this.store.createOmoCheck(version, {
 			ownerConv: "main",
-			title: `OMO ${version} 검증`,
-			goal: `OMO ${version} 후보 패치와 교체 가능 여부 검증 (운영 교체 금지)`,
+			title: `엔진 ${version} 검증`,
+			goal: `엔진 ${version} 후보 패치와 교체 가능 여부 검증 (운영 교체 금지)`,
 			cwd: this.options.cwd,
 			sessionPath: join(this.options.sessionDir, `zgw-omo-check-${version}.jsonl`),
 			requestKey: `omo-check:${version}`,

package/src/transcript.ts

@@ -62,7 +62,7 @@ export function toRecord(type: string, data: unknown, base: { ts: string; conv:
 	if (type === "message.user" && typeof d.text === "string") return { ...base, role: "user", text: d.text, src: d.src, trust: d.trust };
 	if (type === "message.final" && typeof d.text === "string") return { ...base, role: "assistant", text: d.text };
 	if (type === "session.rotated") {
-		return { ...base, role: "system", event: "session.rotated", text: `omo 세션 교체 (${String(d.reason)}): ${String(d.from)} -> ${String(d.to)}` };
+		return { ...base, role: "system", event: "session.rotated", text: `엔진 세션 교체 (${String(d.reason)}): ${String(d.from)} -> ${String(d.to)}` };
 	}
 	return null;
 }

package/src/update/handoff.ts

@@ -59,7 +59,7 @@ export const POLL_MS = 1000;
 
 export type HandoffResult = "promoted" | "untouched_failure" | "failure";
 
-const NOT_UP = `${BRIDGE_START_WAIT_MS / 1000}초 안에 OMO가 뜨지 않았습니다`;
+const NOT_UP = `${BRIDGE_START_WAIT_MS / 1000}초 안에 엔진이 뜨지 않았습니다`;
 
 function legacyRegistry(port: number, version: string, now: number): SlotRegistry {
 	return { schema: 1, slots: [{ slot: "a", state: "active", port, version, snapshot: null, engine: null, since: new Date(now).toISOString() }] };

package/src/usage.ts

@@ -279,7 +279,7 @@ function stamp(ms: number, timeZone: string | undefined): string {
 	return `${part("month")}/${part("day")} ${part("hour")}:${part("minute")}`;
 }
 
-const STATUS_TEXT = { expired: "토큰 만료 (OMO가 다음 사용 때 갱신)", unsupported: "사용량 API 없음" } as const;
+const STATUS_TEXT = { expired: "토큰 만료 (엔진이 다음 사용 때 갱신)", unsupported: "사용량 API 없음" } as const;
 
 export function formatUsageReport(rows: readonly UsageRow[], timeZone?: string): string {
 	if (rows.length === 0) return "계정 사용량\n로그인한 모델 계정이 없습니다.";

package/src/version.ts

@@ -3,7 +3,7 @@ import { CORE_NAME, ENGINE_PACKAGE, PLUGIN, OMO_REGISTRY_URL, readEnginePin, for
 export { OMO_REGISTRY_URL } from "./engine/index.ts";
 
 /** `/version`: the gateway answers it with a notice and never forwards it to omo. */
-export const VERSION_COMMAND = { name: "version", description: "게이트웨이·OMO 버전 보기 (게이트웨이가 바로 답함)", source: "extension" };
+export const VERSION_COMMAND = { name: "version", description: "게이트웨이·엔진 버전 보기 (게이트웨이가 바로 답함)", source: "extension" };
 
 export function isVersionCommand(text: string): boolean {
 	return /^\/version$/i.test(text.trim());
@@ -104,22 +104,22 @@ export function formatVersionReport(facts: VersionFacts): string {
 	const build = facts.gateway.build ? `빌드 커밋 ${facts.gateway.build}` : "빌드 커밋 알 수 없음";
 	lines.push(`· 게이트웨이: ${facts.gateway.version ?? "알 수 없음"} (${build})`);
 	const pin = facts.pin?.omo
-		? ` · 저장소 고정 omo ${formatEnginePin(facts.pin)}`
+		? ` · 저장소 고정 엔진 ${formatEnginePin(facts.pin)}`
 		: " · 저장소 고정 버전 읽기 실패";
 	let running: string | null = null;
-	if (!facts.omo) lines.push(`· 게이트웨이 OMO: 확인 실패 (OMO 연결 상태 ${facts.omoStatus})${pin}`);
+	if (!facts.omo) lines.push(`· 엔진: 확인 실패 (엔진 연결 상태 ${facts.omoStatus})${pin}`);
 	else {
 		running = facts.omo.install;
 		const engine = facts.omo.engine ? ` (${CORE_NAME} ${facts.omo.engine})` : "";
-		lines.push(`· 게이트웨이 OMO: ${facts.omo.install ?? "설치 경로 확인 실패"}${engine}${pin}`);
+		lines.push(`· 엔진: ${facts.omo.install ?? "설치 경로 확인 실패"}${engine}${pin}`);
 	}
 	if ("version" in facts.latest) {
-		lines.push(`· 최신 OMO: ${facts.latest.version} (npm ${ENGINE_PACKAGE})`);
+		lines.push(`· 최신 엔진: ${facts.latest.version} (npm ${ENGINE_PACKAGE})`);
 		const current = running ?? facts.pin?.omo ?? null;
 		if (current && isNewer(facts.latest.version, current)) {
 			lines.push(`업데이트 가능: ${current} → ${facts.latest.version} (자동으로 업데이트하지 않습니다)`);
 		}
-	} else lines.push(`· 최신 OMO: 확인 실패 (${facts.latest.error})`);
+	} else lines.push(`· 최신 엔진: 확인 실패 (${facts.latest.error})`);
 	return lines.join("\n");
 }
 

package/web/app.js

@@ -26,7 +26,9 @@ import {
 import { agentIconUrl, editAgentIcon, readAgentIcon, writeAgentIcon } from "./agent-icon.js";
 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 { cardsOfDecision } from "./cardbind.js";
 import { createRecall, recallKey, resetRecall } from "./recall.js";
 import {
 	addReference, clearReferences, createReferences, inputData, markReferenceable, planSend, referenceSeqs, referenceSource, removeReference,
@@ -43,6 +45,8 @@ import { createAppDownload } from "./app-download.js";
 import { cleanRequest, cleanResultLine, GC_CLEAN_PATH, GC_PATH, gcView } from "./gc.js";
 import { manualFailureText, manualLinkLang, manualUrl, otherLang } from "./manual.js";
 
+installTooltips(document, window);
+
 const $ = (id) => document.getElementById(id);
 const state = {
 	conversations: [],
@@ -676,12 +680,9 @@ function cardForDecision(id) {
 	return els.messages.querySelector(`.approval[data-decision-id="${CSS.escape(id)}"]`);
 }
 
-/** The mounted card of a decision: its explicit identity first, then the original action alias of an id-less card. */
-function cardOf(decision) {
-	const explicit = cardForDecision(decision.id);
-	if (explicit) return explicit;
-	const card = cardFor(originalActionId(decision));
-	return card && (card.dataset.decisionId === undefined || card.dataset.decisionId === decision.id) ? card : null;
+/** Every mounted card of a decision; a rebound question keeps its decision id on a new card (bug 154). */
+function cardsOf(decision) {
+	return cardsOfDecision(els.messages.querySelectorAll(".approval"), decision.id, originalActionId(decision));
 }
 
 /** Legacy or still-loading card bodies: controls on or off plus one status line, optionally with a retry control. */
@@ -715,13 +716,14 @@ function setCardBusy(actionId, busy) {
 }
 
 /** Re-renders the mounted card of a decision from canonical state; an id-less card follows only its own unique alias. */
-function syncCard(decision) {
-	const card = cardOf(decision);
-	if (!card) return;
-	const request = cardRequests.get(card);
-	if (!request) return;
-	if (typeof request.decisionId !== "string" && decisionForAction(inbox.state, request.actionId)?.id !== decision.id) return;
-	renderCardBody(card, decision);
+function syncCard(decision, except = null) {
+	for (const card of cardsOf(decision)) {
+		if (card === except) continue;
+		const request = cardRequests.get(card);
+		if (!request) continue;
+		if (typeof request.decisionId !== "string" && decisionForAction(inbox.state, request.actionId)?.id !== decision.id) continue;
+		renderCardBody(card, decision);
+	}
 }
 
 /** One line of state under a canonical card: in transit, locked for review, offline, finished, or why it still waits. */
@@ -1556,7 +1558,7 @@ function renderOmo() {
 	if (omoStatus === null) return;
 	const ready = omoStatus === "ready";
 	const checking = ready && state.ws?.readyState === WebSocket.OPEN && isUnknown(activity, state.current);
-	els.omo.textContent = checking ? "작업 상태 확인 중" : ready ? "omo 연결됨" : omoStatus === "connecting" ? "omo 연결 중" : "omo 끊김";
+	els.omo.textContent = checking ? "작업 상태 확인 중" : ready ? "엔진 연결됨" : omoStatus === "connecting" ? "엔진 연결 중" : "엔진 끊김";
 	els.omo.classList.toggle("ok", ready);
 }
 
@@ -1581,7 +1583,7 @@ function renderModels(info) {
 		modelSelect.append(group);
 	}
 	if (info.current) modelSelect.value = `${info.current.provider}/${info.current.id}`;
-	modelSelect.title = info.current ? `omo 모델: ${info.current.name}` : "omo 모델";
+	modelSelect.title = info.current ? `엔진 모델: ${info.current.name}` : "엔진 모델";
 	// A held switch stays on the current model until the next message compacts the context for the target.
 	const pending = info.pending ?? null;
 	modelPending.hidden = !pending;
@@ -2027,7 +2029,7 @@ function renderSlashMenu() {
 		});
 		return row;
 	});
-	const note = slash.loading ? "omo 명령과 스킬을 불러오는 중…" : slash.failed ? "omo 명령과 스킬을 불러오지 못했습니다. 웹 지그 명령만 보입니다." : rows.length === 0 ? "맞는 명령이나 스킬이 없습니다." : "";
+	const note = slash.loading ? "엔진 명령과 스킬을 불러오는 중…" : slash.failed ? "엔진 명령과 스킬을 불러오지 못했습니다. 웹 지그 명령만 보입니다." : rows.length === 0 ? "맞는 명령이나 스킬이 없습니다." : "";
 	if (note) {
 		const div = document.createElement("div");
 		div.className = "slash-note";
@@ -2110,7 +2112,7 @@ $("new-conv").onclick = () => {
 };
 $("interrupt").onclick = () => send({ type: "input.interrupt", conv: state.current, data: {} });
 $("rotate-session").onclick = () => {
-	if (!confirm("이 대화의 omo 세션을 새로 시작할까요?\n화면의 기록은 그대로 남고, 최근 대화 일부를 새 세션에 넘겨 줍니다.")) return;
+	if (!confirm("이 대화의 엔진 세션을 새로 시작할까요?\n화면의 기록은 그대로 남고, 최근 대화 일부를 새 세션에 넘겨 줍니다.")) return;
 	send({ type: "conversation.rotate", conv: state.current });
 };
 function toggleDevPanel() {
@@ -2583,6 +2585,12 @@ async function fetchDecisions(cursor) {
 }
 
 /** `refresh`: load the current copy even though one is cached (a mounted card the reset page no longer lists). */
+/** The mounted cards a detail load reports to: every card of the decision id, so a second card never waits on the first. */
+function detailCards(id, card) {
+	const cards = [...els.messages.querySelectorAll(`.approval[data-decision-id="${CSS.escape(id)}"]`)];
+	return card?.isConnected && !cards.includes(card) ? [...cards, card] : cards;
+}
+
 async function loadDecisionDetail(id, card, { refresh = false } = {}) {
 	const generation = decisionGeneration;
 	if ((!refresh && decisionById(inbox.state, id)) || !inbox.online || !beginDetailLoad(inbox.state, id, generation)) return;
@@ -2592,19 +2600,19 @@ async function loadDecisionDetail(id, card, { refresh = false } = {}) {
 		const body = await res.json().catch(() => null);
 		if (!res.ok) {
 			if (!failDetailLoad(inbox.state, id, generation)) return;
-			if (card?.isConnected) setCardState(card, { disabled: true, note: `결정 상태를 불러오지 못했습니다 (${res.status}).`, retry });
+			for (const shown of detailCards(id, card)) setCardState(shown, { disabled: true, note: `결정 상태를 불러오지 못했습니다 (${res.status}).`, retry });
 			return;
 		}
 		const result = finishDetailLoad(inbox.state, id, generation, body);
 		if (!result.accepted) {
-			if (card?.isConnected && result.reason === "mismatch") setCardState(card, { disabled: true, note: "결정 식별자가 일치하지 않습니다.", retry });
+			if (result.reason === "mismatch") for (const shown of detailCards(id, card)) setCardState(shown, { disabled: true, note: "결정 식별자가 일치하지 않습니다.", retry });
 			return;
 		}
 		const decision = decisionById(inbox.state, id);
 		if (decision) syncCard(decision);
 	} catch (err) {
 		if (!failDetailLoad(inbox.state, id, generation)) return;
-		if (card?.isConnected) setCardState(card, {
+		for (const shown of detailCards(id, card)) setCardState(shown, {
 			disabled: true,
 			note: `결정 상태를 불러오지 못했습니다: ${err instanceof Error ? err.message : String(err)}`,
 			retry,
@@ -2938,8 +2946,7 @@ function reviewLatest(decision) {
 
 /** Both surfaces render the same canonical decision; the surface being edited keeps its focus. */
 function syncDecisionSurfaces(decision, except = null) {
-	const card = cardOf(decision);
-	if (card && card !== except) syncCard(decision);
+	syncCard(decision, except);
 	if (inbox.state.items.has(decision.id) && inbox.nodes.get(decision.id) !== except) renderInboxItem(decision);
 }
 
@@ -3175,8 +3182,7 @@ function settleSubmit(decision, result) {
 			break;
 		case "gone": {
 			forgetDecision(inbox.state, id);
-			const card = cardForDecision(id);
-			if (card) {
+			for (const card of els.messages.querySelectorAll(`.approval[data-decision-id="${CSS.escape(id)}"]`)) {
 				card.removeAttribute("aria-busy");
 				setCardState(card, { disabled: true, note: "서버에 더 이상 없는 요청입니다." });
 			}
@@ -3596,10 +3602,12 @@ function gcRow(row) {
 	const name = document.createElement("span");
 	name.className = "gc-name";
 	name.textContent = row.label;
-	name.title = row.title;
+	name.dataset.tip = row.title;
+	name.dataset.tipOverflow = "";
 	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);

package/web/cardbind.d.ts

@@ -0,0 +1,3 @@
+export function cardsOfDecision<T extends { readonly dataset: { decisionId?: string; actionId?: string } }>(
+	cards: Iterable<T>, decisionId: string, aliasActionId: string,
+): T[];

package/web/cardbind.js

@@ -0,0 +1,15 @@
+// Which chat cards show one decision (bug 154). A question that is rebound (for example after a session change) gets a
+// new card that keeps the same decision id, so one decision can own several cards. Every one of them must follow the
+// canonical decision; updating only the first left the others open or stuck at "확인 중…" after the answer was delivered.
+
+/**
+ * Every mounted card of a decision: the cards that carry its explicit id, else the id-less cards of its original action
+ * alias. A card bound to another decision never matches.
+ */
+export function cardsOfDecision(cards, decisionId, aliasActionId) {
+	const list = [...cards];
+	const explicit = list.filter((card) => card.dataset.decisionId === decisionId);
+	if (explicit.length > 0) return explicit;
+	return list.filter((card) => card.dataset.actionId === aliasActionId &&
+		(card.dataset.decisionId === undefined || card.dataset.decisionId === decisionId));
+}

package/web/devlog.js

@@ -71,9 +71,9 @@ function summary(type, d = {}) {
 		case "notice":
 			return clip(d.message);
 		case "omo.status":
-			return clip(`omo ${d.status}${d.detail ? ` · ${d.detail}` : ""}`);
+			return clip(`엔진 ${d.status}${d.detail ? ` · ${d.detail}` : ""}`);
 		case "state.snapshot":
-			return `대화 ${d.conversations?.length ?? 0} · 승인 대기 ${d.approvals?.length ?? 0} · omo ${d.omo}`;
+			return `대화 ${d.conversations?.length ?? 0} · 승인 대기 ${d.approvals?.length ?? 0} · 엔진 ${d.omo}`;
 		case "history":
 			return `${d.conv} 기록 ${d.events?.length ?? 0}건`;
 		case "conversation.created":

package/web/gc.js

@@ -5,7 +5,7 @@ export const GC_PATH = "/api/gc";
 export const GC_CLEAN_PATH = "/api/gc/clean";
 export const KIND_LABELS = Object.freeze({
 	"db-backup": "DB 백업",
-	"omo-version": "OMO 버전 폴더",
+	"omo-version": "엔진 버전 폴더",
 	"update-file": "업데이트 남은 파일",
 	"temp-dir": "임시 폴더",
 	"rpc-daemon": "이전 RPC 데몬",

package/web/index.html

@@ -11,7 +11,7 @@
   <aside class="sidebar">
     <header class="sidebar-head">
       <span class="sidebar-title">zigmini</span>
-      <span class="badge" id="omo-status" title="omo app-server 연결 상태">omo</span>
+      <span class="badge" id="omo-status" title="엔진 연결 상태">엔진</span>
     </header>
     <div class="sidebar-section">
       <div class="section-label">
@@ -60,9 +60,9 @@
       <span class="login-notice" id="schema-notice" role="alert" hidden></span>
       <button type="button" class="update-notice" id="update-notice" title="설정의 업데이트 열기" hidden></button>
       <div class="chat-actions">
-        <select class="model-select" id="model-select" title="omo가 쓸 모델" disabled><option>모델 불러오는 중</option></select>
+        <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="이 대화의 omo 세션을 새로 시작합니다. 화면의 기록은 그대로 남습니다.">새 세션</button>
+        <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>

package/web/style.css

@@ -561,3 +561,7 @@ button { font: inherit; color: inherit; cursor: pointer; }
 	.app.status-open .ws-title { font-size: 14px; color: var(--text); }
 	.app.status-open .ws-caption { font-size: 13px; padding: 4px 10px; }
 }
+
+/* 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; }

package/web/tooltip.d.ts

@@ -0,0 +1,22 @@
+export type Box = { left: number; top: number; right: number; bottom: number };
+export type TipElement = {
+	getAttribute(name: string): string | null;
+	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;
+export function removeId(list: string | null, id: string): string;
+export function installTooltips(doc: Document, win: Window & typeof globalThis): void;

package/web/tooltip.js

@@ -0,0 +1,117 @@
+// 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.
+
+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]";
+
+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));
+	const below = anchor.bottom + TIP_GAP;
+	const above = anchor.top - TIP_GAP - tip.height;
+	const fitsBelow = below + tip.height <= view.height - TIP_MARGIN;
+	if (!fitsBelow && above >= TIP_MARGIN) return { left, top: above, side: "above" };
+	const top = Math.max(TIP_MARGIN, Math.min(below, view.height - tip.height - TIP_MARGIN));
+	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");
+}
+
+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 : "") || "";
+}
+
+export function addId(list, id) {
+	const ids = (list ?? "").split(/\s+/).filter(Boolean);
+	return ids.includes(id) ? ids.join(" ") : [...ids, id].join(" ");
+}
+
+export function removeId(list, id) {
+	return (list ?? "").split(/\s+/).filter((part) => part && part !== id).join(" ");
+}
+
+export function installTooltips(doc, win) {
+	const tip = doc.createElement("div");
+	tip.id = TIP_ID;
+	tip.className = "zgw-tip";
+	tip.setAttribute("role", "tooltip");
+	tip.hidden = true;
+	doc.body.append(tip);
+	let owner = null;
+	let timer = 0;
+
+	const adoptAll = (root) => {
+		if (root.nodeType !== 1) return;
+		adoptTitle(root);
+		for (const el of root.querySelectorAll("[title]")) adoptTitle(el);
+	};
+	adoptAll(doc.body);
+	new win.MutationObserver((records) => {
+		for (const record of records) {
+			if (record.type === "attributes") adoptTitle(record.target);
+			else for (const node of record.addedNodes) adoptAll(node);
+		}
+	}).observe(doc.body, { subtree: true, childList: true, attributes: true, attributeFilter: ["title"] });
+
+	const hide = () => {
+		win.clearTimeout(timer);
+		if (owner) {
+			const rest = removeId(owner.getAttribute("aria-describedby"), TIP_ID);
+			if (rest) owner.setAttribute("aria-describedby", rest);
+			else owner.removeAttribute("aria-describedby");
+		}
+		owner = null;
+		tip.hidden = true;
+	};
+	const show = (el) => {
+		const text = tipText(el);
+		if (!text || !el.isConnected) return hide();
+		if (owner !== el) hide();
+		owner = el;
+		tip.textContent = text;
+		tip.style.left = "0px";
+		tip.style.top = "0px";
+		tip.hidden = false;
+		el.setAttribute("aria-describedby", addId(el.getAttribute("aria-describedby"), TIP_ID));
+		const place = placeTip(el.getBoundingClientRect(), tip.getBoundingClientRect(), { width: win.innerWidth, height: win.innerHeight });
+		tip.style.left = `${Math.round(place.left)}px`;
+		tip.style.top = `${Math.round(place.top)}px`;
+		tip.dataset.side = place.side;
+	};
+	const target = (event) => event.target instanceof win.Element ? event.target.closest(SELECTOR) : null;
+
+	doc.addEventListener("pointerover", (event) => {
+		if (event.pointerType === "touch") return;
+		const el = target(event);
+		if (el === owner) return;
+		hide();
+		if (el) timer = win.setTimeout(() => show(el), HOVER_DELAY_MS);
+	});
+	doc.addEventListener("pointerout", (event) => {
+		const el = target(event);
+		if (el && !(event.relatedTarget instanceof win.Node && el.contains(event.relatedTarget))) hide();
+	});
+	doc.addEventListener("focusin", (event) => {
+		const el = target(event);
+		if (el && event.target.matches(":focus-visible")) show(el);
+	});
+	doc.addEventListener("focusout", hide);
+	doc.addEventListener("pointerdown", hide, true);
+	doc.addEventListener("keydown", (event) => { if (event.key === "Escape" && owner) hide(); });
+	win.addEventListener("scroll", hide, true);
+	win.addEventListener("resize", hide);
+}