makdoong2-team 3.0.0 → 3.0.1

package/dist/config.d.ts

@@ -92,7 +92,7 @@ export declare function parseJsoncLoose(text: string): unknown;
  * 서브세션의 permission 요청이 auto-reject 됐다.
  * (install-lib 의 computeExternalDirPaths 가 그 값을 쓰는 쪽이다.)
  */
-export declare function loadOpencodeExternalDirAllows(): string[];
+export declare function loadOpencodeExternalDirAllows(diag?: (reason: string) => void): string[];
 /** Resolve the five runtime path roots (JSON paths.* override → default).
  *
  * `skills` default is the opencode config dir (`${XDG_CONFIG_HOME:-$HOME/.config}/opencode/skills`)

package/dist/config.js

@@ -175,20 +175,36 @@ export function parseJsoncLoose(text) {
  * 서브세션의 permission 요청이 auto-reject 됐다.
  * (install-lib 의 computeExternalDirPaths 가 그 값을 쓰는 쪽이다.)
  */
-export function loadOpencodeExternalDirAllows() {
+export function loadOpencodeExternalDirAllows(diag) {
+    // 빈 배열로 끝나는 이유를 호출자가 알 수 있게 한다. 이 모듈은 logger 를 import
+    // 하지 못하므로(logger→config) 콜백으로 돌려준다. 같은 pid 의 두 플러그인 사본이
+    // 서로 다른 개수를 읽은 사례(issue #10: 7개→5개)에서 파일 부재였는지 파싱
+    // 실패였는지 키 부재였는지가 로그에 남지 않았다.
+    const file = join(configDir(), "opencode.json");
+    let raw;
     try {
-        const raw = readFileSync(join(configDir(), "opencode.json"), "utf8");
-        const oc = parseJsoncLoose(raw);
-        const ext = oc?.permission?.external_directory;
-        if (!ext || typeof ext !== "object")
-            return [];
-        return Object.entries(ext)
-            .filter(([, action]) => action === "allow")
-            .map(([pattern]) => pattern);
+        raw = readFileSync(file, "utf8");
     }
-    catch {
-        return []; // 부재 / 파싱 실패 → 설정된 allow 없음
+    catch (err) {
+        diag?.(`read failed: ${file}: ${err.message}`);
+        return []; // 부재 → 설정된 allow 없음
+    }
+    let oc;
+    try {
+        oc = parseJsoncLoose(raw);
+    }
+    catch (err) {
+        diag?.(`parse failed: ${file} (${raw.length} bytes): ${err.message}`);
+        return []; // 파싱 실패 → 설정된 allow 없음
+    }
+    const ext = oc?.permission?.external_directory;
+    if (!ext || typeof ext !== "object") {
+        diag?.(`permission.external_directory absent: ${file}`);
+        return [];
     }
+    return Object.entries(ext)
+        .filter(([, action]) => action === "allow")
+        .map(([pattern]) => pattern);
 }
 /** Resolve the five runtime path roots (JSON paths.* override → default).
  *

package/dist/opencode-plugin.js

@@ -21,6 +21,7 @@ import { homedir } from "node:os";
 import { basename as pathBasename, dirname as pathDirname, join, resolve as pathResolve, sep as pathSep } from "node:path";
 import { tool } from "@opencode-ai/plugin";
 import { appendSessionIndex, findWorktreeRoot, lookupSessionFromIndex } from "./session-index.js";
+import { activeToolCount, clearToolCalls, forgetSession, isToolExecuting as registryIsToolExecuting, normalizePermissionEvent, notifySessionDeleted, pendingPermissionsFor, permissionAsked, permissionReplied, settleToolCalls, sharedSubSessionRegistry, toolFinished, toolStarted, } from "./sub-session-registry.js";
 import { computeVerdictHash } from "./verdict-hash.js";
 import { classifyVerifierOutcome, nextVerifierErrorStreak, verifierErrorStreakExceeded, VERIFIER_ERROR_STREAK_LIMIT, } from "./verifier-verdict.js";
 import { nextModel, applyConfigOverrides, POLICIES } from "./model-fallback-policy.js";
@@ -327,6 +328,15 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
     const cwd = worktree || directory || ".";
     const config = loadConfig();
     applyConfigOverrides(config.agents, config.model_policy);
+    // opencode 는 디렉토리(Instance)마다 이 factory 를 따로 부른다 — 같은 pid 안에
+    // 사본이 여럿이다. 어느 사본이 어떤 로그를 찍는지 구분하려고 진입 시점에 남긴다.
+    // 로그에 worktree 경로의 `[init]` 이 없으면 서브세션 훅이 어디서도 발화하지
+    // 않는 것이고, 그것이 issue #10 의 `tool_call_stall` 처방 1번이다.
+    logger.debug(`[init] plugin instance directory=${directory} worktree=${worktree} pid=${process.pid}`);
+    // 사본을 가로지르는 세션 신호(툴 실행 · 권한 요청 · 이슈키 · worktree · deleted
+    // 대기자)는 프로세스 전역 레지스트리에 둔다. 사본마다 Map 을 들면 worktree 사본의
+    // 훅이 올린 신호를 main 사본의 폴러가 영영 보지 못한다 (issue #10).
+    const registry = sharedSubSessionRegistry();
     // Sub-session monitor — splits a tmux pane next to 부장님 for each spawned
     // 막둥이 when invoked inside tmux with tmux.enabled=true in makdoong2-team.json.
     // No-op otherwise, so non-tmux runs are unaffected.
@@ -422,8 +432,8 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                 const guard = orphanCleanupGuard(p, {
                     nowMs,
                     ownerPid: tmuxMonitor.ownerProcessId,
-                    lastToolExecuteAtMs: sessionLastToolExecuteAt.get(sid),
-                    activeToolCount: sessionActiveToolCount.get(sid),
+                    lastToolExecuteAtMs: registry.lastToolExecuteAt.get(sid),
+                    activeToolCount: activeToolCount(registry, sid),
                     toolAliveWindowMs: TOOL_EXECUTE_ALIVE_WINDOW_MS,
                 });
                 if (guard) {
@@ -448,11 +458,9 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                 if (sessionGone) {
                     logger.debug(`[orphan-scan] pane-kill-only (session gone) sid=${sid} reason=${reason}`);
                     await tmuxMonitor.forceKillBySessionId(sid).catch(() => undefined);
-                    sessionIssue.delete(sid);
+                    forgetSession(registry, sid);
                     pendingDispatch.delete(sid);
                     subSessionIds.delete(sid);
-                    sessionLastToolExecuteAt.delete(sid);
-                    sessionActiveToolCount.delete(sid);
                 }
                 else {
                     logger.debug(`[orphan-scan] cleaning sid=${sid} reason=${reason}`);
@@ -607,29 +615,29 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
     const pluginOwnPatterns = pluginOwnAllowPatterns();
     const configuredAllowPatterns = [
         ...pluginOwnPatterns,
-        ...loadOpencodeExternalDirAllows(),
+        ...loadOpencodeExternalDirAllows((reason) => logger.warn(`[permission] opencode.json external_directory allows unavailable — ${reason} directory=${directory}`)),
     ];
+    // 사본마다 한 번씩 찍힌다 — 같은 pid 에 개수가 다른 두 줄이 있으면 사본이
+    // 둘이라는 뜻이지 설정이 바뀐 것이 아니다 (issue #10 의 7개→5개). directory 를
+    // 같이 남겨 어느 사본이 몇 개를 읽었는지 바로 대응시킨다.
     logger.debug(`[permission] plugin-own allows: ${pluginOwnPatterns.length}개 ` +
-        `(${pluginOwnPatterns.join(", ")})`);
+        `(${pluginOwnPatterns.join(", ")}) directory=${directory}`);
     logger.debug(`[permission] configured external_directory allows: ${configuredAllowPatterns.length}개` +
-        (configuredAllowPatterns.length ? ` (${configuredAllowPatterns.slice(0, 3).join(", ")}…)` : ""));
-    const sessionLastToolExecuteAt = new Map();
-    const sessionActiveToolCount = new Map();
-    /** 활성 툴 카운터를 1 감소시킨다 (0 이면 항목 삭제). */
-    function releaseActiveTool(sid) {
-        const cur = sessionActiveToolCount.get(sid) ?? 0;
-        if (cur <= 1)
-            sessionActiveToolCount.delete(sid);
-        else
-            sessionActiveToolCount.set(sid, cur - 1);
-    }
+        (configuredAllowPatterns.length ? ` (${configuredAllowPatterns.slice(0, 3).join(", ")}…)` : "") +
+        ` directory=${directory}`);
+    // 툴 실행 신호는 레지스트리(`registry.activeToolCalls` / `lastToolExecuteAt`)에
+    // 있다 — before 훅에서 toolStarted, after 훅·툴 part 종결·idle 에서 toolFinished /
+    // clearToolCalls. 종전의 사본-로컬 카운터는 issue #10 으로 제거됐다.
     const TOOL_EXECUTE_ALIVE_WINDOW_MS = 300_000;
     // MESSAGE_STALL 후 client.session.abort() 는 즉시 반환하지만 opencode 서버는 잠시 후
     // session.deleted 이벤트를 fire 한다. 그 사이(관측 최대 112s) sub-agent 가 tool call 을
     // 계속 발사할 수 있어 좀비 실행이 발생한다. abort 직후 session.deleted 를 대기하는
     // 헬퍼로 이 race window 를 닫는다. event 핸들러가 session.deleted 를 수신하면 이 map 의
     // pending waiter 를 resolve 한다.
-    const sessionDeletedWaiters = new Map();
+    // 대기자 목록은 레지스트리에 있다 — session.deleted 이벤트는 세션의 디렉토리
+    // 사본에만 도착하므로(worktree 서브세션이면 worktree 사본), 여기서 기다리는
+    // main 사본과 이벤트를 받는 사본이 같은 목록을 봐야 한다.
+    const sessionDeletedWaiters = registry.sessionDeletedWaiters;
     const waitForSessionDeleted = (sessionId, maxWaitMs) => {
         return new Promise((resolve) => {
             let done = false;
@@ -659,7 +667,9 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
     const SESSION_DELETED_WAIT_MS = 30_000;
     const eventMaxChars = readLoggingConfig(config.logging).eventMaxChars;
     const WRITE_TOOLS = new Set(["write", "edit", "apply_patch"]);
-    const sessionWorktree = new Map();
+    // dispatch 사본이 채우고 worktree 사본의 tool.execute.after 가 읽는다 — 레지스트리.
+    // 디스크의 session-index.ndjson 은 사본이 다른 프로세스에 있을 때의 2차 경로로 남는다.
+    const sessionWorktree = registry.sessionWorktree;
     const extractFilePathFromToolArgs = (args) => {
         if (!args || typeof args !== "object")
             return undefined;
@@ -749,7 +759,41 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
         }
         return { ok: true, relPath };
     };
-    const pollSubSession = (sessionId, timeoutMs = substageTimeoutMs, allowedWorktree, onNudge, messageStallThresholdMs) => pollSubSessionCore(client, sessionId, {
+    // 폴러에 건네는 권한 요청 소스. v1 SDK 클라이언트에는 `permission` 네임스페이스가
+    // 없고, `GET /permission` 은 클라이언트가 묶인 디렉토리 스코프라 worktree
+    // 서브세션의 요청이 보이지 않는다 — 종전에는 이 소스가 항상 undefined 라
+    // 자동 승인·거부 루프가 한 번도 돌지 않았고 stall 메시지는 언제나 "unknown" 이었다
+    // (issue #10). 대신 그 세션의 사본이 `permission.asked` 이벤트로 레지스트리에
+    // 넣은 것을 읽고, 응답은 세션-라우팅 엔드포인트
+    // (`POST /session/{id}/permissions/{permissionID}`) 로 보낸다 — 세션 ID 로
+    // 라우팅되므로 어느 사본에서 불러도 맞는 Instance 에 닿는다.
+    const permissionSourceFor = (sessionId) => ({
+        list: async () => ({
+            data: pendingPermissionsFor(registry, sessionId).map((p) => ({
+                id: p.id,
+                sessionID: p.sessionID,
+                permission: p.permission,
+                patterns: p.patterns,
+            })),
+        }),
+        reply: async (req) => {
+            const c = client;
+            if (typeof c.postSessionIdPermissionsPermissionId !== "function") {
+                throw new Error("permission reply endpoint unavailable on this client");
+            }
+            const res = await c.postSessionIdPermissionsPermissionId({
+                path: { id: sessionId, permissionID: req.path.requestID },
+                body: { response: req.body.reply },
+            });
+            // permission.replied 이벤트는 세션의 사본에 도착하지만, 그 사본이 이벤트를
+            // 놓치더라도 다음 폴이 같은 요청을 다시 처리하지 않도록 즉시 뺀다.
+            permissionReplied(registry, sessionId, req.path.requestID);
+            return res;
+        },
+    });
+    const pollSubSession = (sessionId, timeoutMs = substageTimeoutMs, allowedWorktree, onNudge, messageStallThresholdMs) => 
+    // 클래스 인스턴스를 spread 하면 프로토타입 메서드가 빠지므로 필요한 것만 집는다.
+    pollSubSessionCore({ session: client.session, permission: permissionSourceFor(sessionId) }, sessionId, {
         timeoutMs,
         allowedWorktree,
         configuredAllowPatterns,
@@ -764,16 +808,26 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
         contentStableCompletionMs: 300_000,
         preambleOnlyTextThreshold: 200,
         isRecentlyActive: () => {
-            if ((sessionActiveToolCount.get(sessionId) ?? 0) > 0)
+            if (registryIsToolExecuting(registry, sessionId))
                 return true;
-            const last = sessionLastToolExecuteAt.get(sessionId);
+            const last = registry.lastToolExecuteAt.get(sessionId);
             return typeof last === "number" && Date.now() - last < TOOL_EXECUTE_ALIVE_WINDOW_MS;
         },
-        // "지금 이 순간 툴이 실행 중인가" — before 훅에서 올리고 after 훅에서 내리는
-        // 활성 카운터 그대로다. isRecentlyActive 의 5분 창과 달리 순간값이라 완료
+        // "지금 이 순간 툴이 실행 중인가" — before 훅에서 넣고 after 훅에서 빼는
+        // callID 집합 그대로다. isRecentlyActive 의 5분 창과 달리 순간값이라 완료
         // 판정에 쓸 수 있다. 폴러가 읽는 메시지 스냅샷보다 항상 앞선다 (issue #7:
         // tool.execute.before 발화 110ms 뒤의 폴이 tool part 를 아직 못 봤다).
-        isToolExecuting: () => (sessionActiveToolCount.get(sessionId) ?? 0) > 0,
+        //
+        // 읽기 전에 스냅샷과 대조한다: 툴이 throw 하면 after 훅이 오지 않아 항목이
+        // 남는데, 스냅샷에서 이미 completed/error 인 callID 는 확실히 끝난 것이다.
+        // 스냅샷에 아직 없는 callID 는 그대로 둔다 (110ms 창).
+        isToolExecuting: (snapshot) => {
+            const settled = settleToolCalls(registry, sessionId, snapshot.settledCallIDs);
+            if (settled > 0) {
+                logger.debug(`[pollSubSession] settled ${settled} stale tool call(s) from snapshot sid=${sessionId}`);
+            }
+            return registryIsToolExecuting(registry, sessionId);
+        },
     });
     // ── sessionID → agent 매핑. chat.params hook에서 채우고, tool.execute.before
     //    hook에서 조회한다. 이 매핑을 통해 hook input에 없는 agent 식별을 우회한다.
@@ -796,7 +850,9 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
     // git branch 이름이나 worktree 경로를 추론하지 않고 신뢰할 수 있는 ISSUE를
     // 직접 전달받을 수 있다. 이 설계로 multi-worktree / 비-makdoong2-team 워크트리
     // 오탐 문제가 근본적으로 해결된다.
-    const sessionIssue = new Map();
+    // 레지스트리에 둔다 — dispatch 사본이 넣고, 서브세션의 훅 사본(guard-bash.sh /
+    // sync-state.sh 인자)이 읽는다.
+    const sessionIssue = registry.sessionIssue;
     // ── skill_mcp lazy-load 방어 (mcp_name → skill_name 매핑).
     //    SKILL.md frontmatter 를 스캔해 각 MCP 서버가 어떤 skill 에 embedded 인지
     //    캐시한다. `skill(name="...")` 로 skill 이 로드되기 전에는 opencode 가
@@ -873,11 +929,9 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
             }
         }
         finally {
-            sessionIssue.delete(sid);
+            forgetSession(registry, sid);
             pendingDispatch.delete(sid);
             subSessionIds.delete(sid);
-            sessionLastToolExecuteAt.delete(sid);
-            sessionActiveToolCount.delete(sid);
         }
     };
     // team-leader가 직접 실행 시 물리적으로 차단할 툴 목록.
@@ -992,26 +1046,72 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
         }
     })();
     return {
+        // 이벤트는 **세션의 디렉토리 사본**에만 도착한다 (opencode 의 이벤트 브리지가
+        // `location.directory` 로 필터링한다). worktree 서브세션의 permission.asked ·
+        // message.part.updated · session.deleted 는 worktree 사본이 받고, 그 세션을
+        // 폴링하는 것은 main 사본이다. 그래서 여기서 관측한 것은 전부 레지스트리에
+        // 쓴다 — 사본-로컬 변수에 쓰면 폴러는 영영 보지 못한다 (issue #10).
         event: async ({ event }) => {
-            if (logger.isDebug() && event?.type?.startsWith("session.")) {
+            if (logger.isDebug() && (event?.type?.startsWith("session.") || event?.type?.startsWith("permission."))) {
                 try {
-                    logger.debug(`[event] type=${event.type} properties=${JSON.stringify(event.properties).slice(0, eventMaxChars)}`);
+                    logger.debug(`[event] type=${event.type} directory=${directory} properties=${JSON.stringify(event.properties).slice(0, eventMaxChars)}`);
                 }
                 catch { /* ignore */ }
             }
+            if (event?.type === "permission.asked" || event?.type === "permission.updated") {
+                const req = normalizePermissionEvent(event.type, event.properties);
+                if (req) {
+                    permissionAsked(registry, req);
+                    logger.debug(`[event] permission pending sid=${req.sessionID} requestID=${req.id} ` +
+                        `permission=${req.permission} patterns=${JSON.stringify(req.patterns)}`);
+                }
+                return;
+            }
+            if (event?.type === "permission.replied") {
+                const props = event.properties;
+                const sid = typeof props?.sessionID === "string" ? props.sessionID : undefined;
+                const requestID = typeof props?.requestID === "string" ? props.requestID
+                    : typeof props?.permissionID === "string" ? props.permissionID
+                        : undefined;
+                if (sid && requestID)
+                    permissionReplied(registry, sid, requestID);
+                return;
+            }
+            if (event?.type === "message.part.updated") {
+                // 툴 part 가 completed/error 로 바뀌면 그 호출은 끝났다. 툴이 throw 한
+                // 경우 tool.execute.after 가 오지 않으므로 이것이 유일한 종결 신호다.
+                const props = event.properties;
+                const part = props?.part;
+                if (part && part.type === "tool") {
+                    const state = part.state;
+                    const status = typeof state?.status === "string" ? state.status : undefined;
+                    if (status === "completed" || status === "error") {
+                        const sid = typeof part.sessionID === "string" ? part.sessionID
+                            : typeof props?.sessionID === "string" ? props.sessionID
+                                : undefined;
+                        const callID = typeof part.callID === "string" ? part.callID : undefined;
+                        if (sid)
+                            toolFinished(registry, sid, callID);
+                    }
+                }
+                return;
+            }
+            if (event?.type === "session.idle") {
+                // idle 로 전이한 세션에 실행 중인 툴은 정의상 없다 — 남은 항목은 전부 누수다.
+                const props = event.properties;
+                if (typeof props?.sessionID === "string")
+                    clearToolCalls(registry, props.sessionID);
+                return;
+            }
             if (event?.type === "session.deleted") {
                 const props = event.properties;
                 const sid = props?.info?.id ?? props?.sessionID;
                 if (sid) {
-                    const waiters = sessionDeletedWaiters.get(sid);
-                    if (waiters && waiters.length > 0) {
-                        for (const w of [...waiters]) {
-                            try {
-                                w();
-                            }
-                            catch { /* ignore */ }
-                        }
-                    }
+                    notifySessionDeleted(registry, sid);
+                    // 세션이 사라졌으니 실행 신호·권한 요청도 의미가 없다. sessionIssue /
+                    // sessionWorktree 는 dispatch 사본의 cleanupSubSession 이 지운다.
+                    clearToolCalls(registry, sid);
+                    registry.pendingPermissions.delete(sid);
                 }
                 return;
             }
@@ -1066,16 +1166,17 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                 : undefined;
             const toolLower = (input.tool || "").toLowerCase();
             logger.debug(`[makdoong2-team hook] tool.execute.before fired: tool="${input.tool}" sessionID="${sessionID}" agent="${agent ?? "unknown"}" callID="${input.callID}"`);
-            // 활성 툴 카운터는 **증분과 감소가 반드시 짝을 이뤄야 한다**.
+            // 활성 툴 집합은 **넣기와 빼기가 반드시 짝을 이뤄야 한다**.
             // tool.execute.after 는 툴이 실제로 실행된 뒤에만 돈다. 아래 가드들이 throw 하면
             // (차단된 bash · sealed 서브에이전트의 outer-world 툴 · leader 의 파일 쓰기 등)
-            // after 훅이 돌지 않아 카운터가 영구히 ≥1 로 남고, 그러면 isRecentlyActive() 가
+            // after 훅이 돌지 않아 항목이 영구히 남고, 그러면 isRecentlyActive() 가
             // 항상 true 가 되어 그 세션의 gone 감지와 orphan 회수가 **영구 비활성**된다.
             // 차단은 정상 동작이라 반드시 일어나므로 확정적으로 누수됐다.
-            if (sessionID) {
-                sessionLastToolExecuteAt.set(sessionID, Date.now());
-                sessionActiveToolCount.set(sessionID, (sessionActiveToolCount.get(sessionID) ?? 0) + 1);
-            }
+            // (툴 자체가 throw 하는 경우 — 권한 거부 · 파일 없음 — 는 여기서 잡을 수 없다.
+            // 그쪽은 폴러가 스냅샷의 completed/error part 로 정리한다: settleToolCalls.)
+            const activeToolKey = sessionID
+                ? toolStarted(registry, sessionID, input.callID)
+                : undefined;
             try {
                 if (sessionID && (toolLower === "dispatch_stage" || toolLower === "dispatch_verifier")) {
                     const callID = input.callID;
@@ -1322,9 +1423,9 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                 }
             }
             catch (err) {
-                // 차단으로 끝난 호출은 실행되지 않았다 → 증분을 되돌린다.
+                // 차단으로 끝난 호출은 실행되지 않았다 → 넣은 항목을 되돌린다.
                 if (sessionID)
-                    releaseActiveTool(sessionID);
+                    toolFinished(registry, sessionID, activeToolKey);
                 throw err;
             }
         },
@@ -1337,8 +1438,7 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
             const toolLowerAfter = (input.tool || "").toLowerCase();
             const afterSessionID = input.sessionID;
             if (afterSessionID) {
-                sessionLastToolExecuteAt.set(afterSessionID, Date.now());
-                releaseActiveTool(afterSessionID);
+                toolFinished(registry, afterSessionID, input.callID);
             }
             // ── Issue-reporter 표시 증명 기록·소멸 ──
             // 기록: 단독 `cat <payload>` 가 실행되면 그 시점의 파일 해시를 남긴다. 이

package/dist/poll-sub-session.d.ts

@@ -5,6 +5,19 @@ export type MessagePartLike = {
     state?: {
         status?: string;
     };
+    /** ToolPart 의 호출 ID — `tool.execute.before/after` 훅의 callID 와 같은 값. */
+    callID?: string;
+};
+/**
+ * 폴 시점 스냅샷에서 읽은 툴 호출 상태. `isToolExecuting` 에 넘겨 훅 레지스트리와
+ * 대조하게 한다 — throw 로 끝난 툴은 after 훅이 돌지 않아 레지스트리에 남는데,
+ * 스냅샷의 completed/error part 가 그 호출이 끝났음을 확정해 준다.
+ */
+export type ToolSnapshot = {
+    /** completed / error 로 끝난 호출 ID (스냅샷 전체 메시지 기준). */
+    settledCallIDs: ReadonlySet<string>;
+    /** pending / running 인 호출 ID (마지막 assistant 메시지 기준). */
+    inFlightCallIDs: ReadonlySet<string>;
 };
 export type MessageInfoLike = {
     id?: string;
@@ -109,7 +122,7 @@ export interface PollOptions {
     messageStallThresholdMs?: number;
     statusAbsentGraceMs?: number;
     isRecentlyActive?: () => boolean;
-    isToolExecuting?: () => boolean;
+    isToolExecuting?: (snapshot: ToolSnapshot) => boolean;
     contentStableCompletionMs?: number;
     preambleOnlyTextThreshold?: number;
     nudgeAtFraction?: number;

package/dist/poll-sub-session.js

@@ -29,6 +29,37 @@
 const TOOL_CALL_PART_TYPES = new Set(["tool", "tool_call", "tool-call", "tool_use"]);
 /** 아직 끝나지 않은 툴 상태 (ToolStatePending / ToolStateRunning). */
 const IN_FLIGHT_TOOL_STATUSES = new Set(["pending", "running"]);
+/** 확실히 끝난 툴 상태 (ToolStateCompleted / ToolStateError). */
+const SETTLED_TOOL_STATUSES = new Set(["completed", "error"]);
+/**
+ * 스냅샷에서 툴 호출 ID 를 상태별로 모은다. settled 는 전체 메시지를 훑는다 —
+ * 레지스트리에 남은 항목은 이전 turn 의 호출일 수도 있다. inFlight 는 마지막
+ * assistant 메시지만 본다 (`hasPendingToolCall` 과 같은 기준).
+ */
+function collectToolSnapshot(messages, lastAssistant) {
+    const settledCallIDs = new Set();
+    const inFlightCallIDs = new Set();
+    for (const m of messages) {
+        if (m.info?.role !== "assistant")
+            continue;
+        for (const part of m.parts ?? []) {
+            if (!TOOL_CALL_PART_TYPES.has(part.type))
+                continue;
+            if (typeof part.callID !== "string" || part.callID.length === 0)
+                continue;
+            const status = part.state?.status;
+            if (typeof status === "string" && SETTLED_TOOL_STATUSES.has(status))
+                settledCallIDs.add(part.callID);
+        }
+    }
+    for (const part of lastAssistant?.parts ?? []) {
+        if (!isInFlightToolPart(part))
+            continue;
+        if (typeof part.callID === "string" && part.callID.length > 0)
+            inFlightCallIDs.add(part.callID);
+    }
+    return { settledCallIDs, inFlightCallIDs };
+}
 /**
  * "지금 실행 중인 툴 호출이 있는가".
  *
@@ -236,7 +267,9 @@ export async function pollSubSession(client, sessionId, options = {}) {
         // 둘 중 하나라도 "툴이 떠 있다" 고 하면 완료로 판정하지 않는다 — 스냅샷은
         // 서버 반영이 늦고(issue #7), 훅 신호는 훅이 안 붙은 환경에서 아예 없다.
         // OR 로 묶어야 각자의 사각지대를 서로 덮는다.
-        const toolExecuting = isToolExecuting?.() === true;
+        const toolExecuting = isToolExecuting
+            ? isToolExecuting(collectToolSnapshot(messages, lastAssistant)) === true
+            : false;
         const toolInFlight = hasPendingToolCall || toolExecuting;
         const stalledMs = now() - lastProgressAt;
         // session_gone (status_absent) has two admission paths with different
@@ -376,7 +409,9 @@ export async function pollSubSession(client, sessionId, options = {}) {
             err(`[pollSubSession] PERMISSION_STALL session=${sessionId} polls=${pollCount} stalledMs=${stalledMs}` +
                 (stalledPerm
                     ? ` pending permissionID=${stalledPerm.id} type=${stalledPerm.permission} patterns=${JSON.stringify(stalledPerm.patterns)}`
-                    : ` pending permission unknown (permission.list unavailable or empty)`));
+                    : client.permission
+                        ? ` no pending permission observed for this session (tool part in flight, no tool.execute signal)`
+                        : ` pending permission unknown (permission source unavailable)`));
             await client.session.abort({ path: { id: sessionId } }).catch(() => undefined);
             return {
                 kind: "permission_stall",
@@ -629,8 +664,10 @@ export function pollOutcomeToLegacy(outcome) {
                             "에이전트 permission 설정 문제다. 해당 에이전트의 frontmatter `permission:` 블록을 점검하라 " +
                             "(정식 키는 `edit`; `write` 키는 존재하지 않아 조용히 무시된다).";
                     default:
-                        return "대기 대상을 특정하지 못했다. 점검: opencode.json 의 permission.external_directory 시드 존재 여부 " +
-                            "(`npx makdoong2-team doctor`).";
+                        return "툴 호출 part 가 떠 있는데 실행 신호(tool.execute.before)도 권한 요청도 관측되지 않았다. 점검: " +
+                            "(1) 세션의 디렉토리에서도 플러그인이 로드되는가 — 로그의 `[init] plugin instance directory=…` 가 " +
+                            "worktree 경로로도 찍혀야 한다 (opencode 는 디렉토리마다 플러그인을 따로 초기화한다) " +
+                            "(2) opencode.json 의 permission.external_directory 시드 (`npx makdoong2-team doctor`).";
                 }
             })();
             return {

package/dist/sub-session-registry.d.ts

@@ -0,0 +1,74 @@
+export type PendingPermission = {
+    id: string;
+    sessionID: string;
+    permission: string;
+    patterns: string[];
+    askedAt: number;
+};
+export interface SubSessionRegistry {
+    readonly version: 1;
+    /** sessionID → (callID → startedAt). before 에서 넣고 after / 툴 part 종결에서 뺀다. */
+    readonly activeToolCalls: Map<string, Map<string, number>>;
+    /** sessionID → 마지막 tool.execute.* 발화 시각. */
+    readonly lastToolExecuteAt: Map<string, number>;
+    /** sessionID → (requestID → 요청). permission.asked 로 넣고 replied 로 뺀다. */
+    readonly pendingPermissions: Map<string, Map<string, PendingPermission>>;
+    /** sessionID → 이슈키. dispatch 사본이 쓰고 훅 사본(guard-bash.sh 인자)이 읽는다. */
+    readonly sessionIssue: Map<string, string>;
+    /** sessionID → worktree 절대경로. auto-git-add 가 읽는다. */
+    readonly sessionWorktree: Map<string, string>;
+    /** session.deleted 대기자. abort 후 재디스패치 전 race window 를 닫는다. */
+    readonly sessionDeletedWaiters: Map<string, Array<() => void>>;
+    /** callID 가 없는 before 훅에 붙일 대체 키 일련번호. */
+    anonSeq: number;
+}
+export declare function createSubSessionRegistry(): SubSessionRegistry;
+/**
+ * 프로세스 전역 레지스트리. 첫 호출이 만들고 이후 호출은 같은 객체를 돌려준다.
+ * 키에 버전을 박아 두어, 형태가 다른 미래 버전이 같은 프로세스에 섞여도 서로의
+ * 객체를 깨뜨리지 않는다.
+ */
+export declare function sharedSubSessionRegistry(): SubSessionRegistry;
+/** 테스트 전용 — 전역 객체를 비운다. */
+export declare function resetSharedSubSessionRegistryForTests(): void;
+/** `tool.execute.before` — 이 세션에서 callID 툴이 실행을 시작했다. 사용한 키를 돌려준다. */
+export declare function toolStarted(reg: SubSessionRegistry, sessionID: string, callID: string | undefined, now?: number): string;
+/**
+ * `tool.execute.after` 또는 툴 part 의 completed/error 관측 — 실행이 끝났다.
+ * 멱등이다: 같은 callID 를 두 번 끝내도, 모르는 callID 를 끝내도 아무 일도 없다.
+ * callID 가 없으면 가장 최근에 시작한 항목을 뺀다 (종전 카운터 의미 유지).
+ */
+export declare function toolFinished(reg: SubSessionRegistry, sessionID: string, callID: string | undefined, now?: number): boolean;
+/**
+ * 메시지 스냅샷과 대조해 이미 끝난 호출을 정리한다.
+ *
+ * 툴이 throw 하면(권한 거부 · 파일 없음 · MCP 오류) opencode 는 `tool.execute.after`
+ * 를 부르지 않는다 — 항목이 영영 남아 `isToolExecuting()` 이 참으로 굳고, 그러면
+ * 완료 판정이 유보돼 substage 가 절대 타임아웃까지 기다린다. 스냅샷의 tool part
+ * 가 completed/error 면 그 호출은 확실히 끝난 것이므로 여기서 뺀다. 스냅샷에
+ * **아직 없는** 호출은 건드리지 않는다 (issue #7 의 110ms 창 — 훅은 발화했는데
+ * 서버가 part 를 아직 반영하지 않은 상태). 정리한 개수를 돌려준다.
+ */
+export declare function settleToolCalls(reg: SubSessionRegistry, sessionID: string, settledCallIDs: Iterable<string>): number;
+/** 지금 이 순간 이 세션에서 실행 중인 툴이 있는가 (순간값). */
+export declare function isToolExecuting(reg: SubSessionRegistry, sessionID: string): boolean;
+export declare function activeToolCount(reg: SubSessionRegistry, sessionID: string): number;
+/** 세션이 idle 로 전이했다 — 실행 중인 툴은 정의상 없다. */
+export declare function clearToolCalls(reg: SubSessionRegistry, sessionID: string): void;
+/**
+ * 플러그인 `event` 훅이 받는 권한 요청 이벤트를 공통 형태로 바꾼다.
+ *
+ * 1.18 v1 브리지는 `permission.asked` 를 `PermissionRequest` 그대로 싣는다
+ * (`id / sessionID / permission / patterns`). 더 오래된 SDK 형태 `permission.updated`
+ * 는 `type` · `pattern`(문자열 또는 배열) 을 쓴다. 둘 다 받아 둔다 — 어느 쪽이 오든
+ * 폴러가 보는 것은 같은 shape 이어야 한다. 요청으로 볼 수 없는 페이로드는 null.
+ */
+export declare function normalizePermissionEvent(type: string, properties: unknown, now?: number): PendingPermission | null;
+export declare function permissionAsked(reg: SubSessionRegistry, req: PendingPermission): void;
+export declare function permissionReplied(reg: SubSessionRegistry, sessionID: string, requestID: string): void;
+/** 이 세션에 답을 기다리는 권한 요청 — 오래된 순. */
+export declare function pendingPermissionsFor(reg: SubSessionRegistry, sessionID: string): PendingPermission[];
+/** 세션 하나의 흔적을 전부 지운다 (cleanupSubSession · session.deleted). */
+export declare function forgetSession(reg: SubSessionRegistry, sessionID: string): void;
+/** session.deleted — 대기자를 전부 깨운다. 깨운 수를 돌려준다. */
+export declare function notifySessionDeleted(reg: SubSessionRegistry, sessionID: string): number;

package/dist/sub-session-registry.js

@@ -0,0 +1,204 @@
+// 프로세스 전역 서브세션 레지스트리 — 플러그인 사본 사이의 공유 신호.
+//
+// opencode 1.18 은 **디렉토리(Instance)마다 플러그인을 따로 초기화한다**.
+// `dispatch_stage` 는 서브세션을 `directory=<worktree>` 로 만들므로 그 세션의
+// `tool.execute.before/after` · `event` 훅은 worktree Instance 의 플러그인 사본에서
+// 발화하고, 그 세션을 감시하는 `pollSubSession` 은 main Instance 의 사본에서 돈다.
+// 사본마다 자기 Map 을 들고 있으면 폴러는 언제나 빈 Map 을 본다 —
+// `isToolExecuting()` 이 영영 false 라 60초를 넘는 모든 툴(sbt test 등)이
+// `permission_stall`(reason=tool_call_stall) 로 abort 됐다 (GitHub issue #10).
+//
+// 그래서 사본을 가로지르는 신호는 전부 여기, `globalThis` 에 둔다. 같은 프로세스
+// 안의 모든 사본이 — 모듈 경로가 달라 module cache 가 갈리더라도 — 한 객체를 본다.
+// 여기 두는 것은 "훅 사본이 쓰고 폴러 사본이 읽는" 세션 단위 신호뿐이다.
+// `pendingDispatch` 같은 디스패치 소유 상태는 공유하지 않는다 — 공유하면 worktree
+// 사본의 `session.created` 핸들러가 pane 을 한 번 더 띄운다.
+//
+// 이 파일은 src/opencode-plugin.ts 에서 import 만 한다 (re-export 금지 —
+// 로더가 모든 named export 를 plugin factory 로 호출한다).
+const SHARED_KEY = Symbol.for("makdoong2-team.sub-session-registry.v1");
+export function createSubSessionRegistry() {
+    return {
+        version: 1,
+        activeToolCalls: new Map(),
+        lastToolExecuteAt: new Map(),
+        pendingPermissions: new Map(),
+        sessionIssue: new Map(),
+        sessionWorktree: new Map(),
+        sessionDeletedWaiters: new Map(),
+        anonSeq: 0,
+    };
+}
+/**
+ * 프로세스 전역 레지스트리. 첫 호출이 만들고 이후 호출은 같은 객체를 돌려준다.
+ * 키에 버전을 박아 두어, 형태가 다른 미래 버전이 같은 프로세스에 섞여도 서로의
+ * 객체를 깨뜨리지 않는다.
+ */
+export function sharedSubSessionRegistry() {
+    const g = globalThis;
+    const existing = g[SHARED_KEY];
+    if (existing && existing.version === 1)
+        return existing;
+    const created = createSubSessionRegistry();
+    g[SHARED_KEY] = created;
+    return created;
+}
+/** 테스트 전용 — 전역 객체를 비운다. */
+export function resetSharedSubSessionRegistryForTests() {
+    delete globalThis[SHARED_KEY];
+}
+// ── 툴 실행 신호 ─────────────────────────────────────────────────────────────
+const ANON_PREFIX = "anon#";
+/** `tool.execute.before` — 이 세션에서 callID 툴이 실행을 시작했다. 사용한 키를 돌려준다. */
+export function toolStarted(reg, sessionID, callID, now = Date.now()) {
+    const key = typeof callID === "string" && callID.length > 0 ? callID : `${ANON_PREFIX}${++reg.anonSeq}`;
+    let calls = reg.activeToolCalls.get(sessionID);
+    if (!calls) {
+        calls = new Map();
+        reg.activeToolCalls.set(sessionID, calls);
+    }
+    calls.set(key, now);
+    reg.lastToolExecuteAt.set(sessionID, now);
+    return key;
+}
+/**
+ * `tool.execute.after` 또는 툴 part 의 completed/error 관측 — 실행이 끝났다.
+ * 멱등이다: 같은 callID 를 두 번 끝내도, 모르는 callID 를 끝내도 아무 일도 없다.
+ * callID 가 없으면 가장 최근에 시작한 항목을 뺀다 (종전 카운터 의미 유지).
+ */
+export function toolFinished(reg, sessionID, callID, now = Date.now()) {
+    reg.lastToolExecuteAt.set(sessionID, now);
+    const calls = reg.activeToolCalls.get(sessionID);
+    if (!calls || calls.size === 0)
+        return false;
+    let key;
+    if (typeof callID === "string" && callID.length > 0) {
+        if (!calls.has(callID))
+            return false;
+        key = callID;
+    }
+    else {
+        let latest = -Infinity;
+        for (const [k, startedAt] of calls) {
+            if (startedAt >= latest) {
+                latest = startedAt;
+                key = k;
+            }
+        }
+    }
+    if (key === undefined)
+        return false;
+    calls.delete(key);
+    if (calls.size === 0)
+        reg.activeToolCalls.delete(sessionID);
+    return true;
+}
+/**
+ * 메시지 스냅샷과 대조해 이미 끝난 호출을 정리한다.
+ *
+ * 툴이 throw 하면(권한 거부 · 파일 없음 · MCP 오류) opencode 는 `tool.execute.after`
+ * 를 부르지 않는다 — 항목이 영영 남아 `isToolExecuting()` 이 참으로 굳고, 그러면
+ * 완료 판정이 유보돼 substage 가 절대 타임아웃까지 기다린다. 스냅샷의 tool part
+ * 가 completed/error 면 그 호출은 확실히 끝난 것이므로 여기서 뺀다. 스냅샷에
+ * **아직 없는** 호출은 건드리지 않는다 (issue #7 의 110ms 창 — 훅은 발화했는데
+ * 서버가 part 를 아직 반영하지 않은 상태). 정리한 개수를 돌려준다.
+ */
+export function settleToolCalls(reg, sessionID, settledCallIDs) {
+    const calls = reg.activeToolCalls.get(sessionID);
+    if (!calls || calls.size === 0)
+        return 0;
+    let n = 0;
+    for (const id of settledCallIDs) {
+        if (calls.delete(id))
+            n++;
+    }
+    if (calls.size === 0)
+        reg.activeToolCalls.delete(sessionID);
+    return n;
+}
+/** 지금 이 순간 이 세션에서 실행 중인 툴이 있는가 (순간값). */
+export function isToolExecuting(reg, sessionID) {
+    return (reg.activeToolCalls.get(sessionID)?.size ?? 0) > 0;
+}
+export function activeToolCount(reg, sessionID) {
+    return reg.activeToolCalls.get(sessionID)?.size ?? 0;
+}
+/** 세션이 idle 로 전이했다 — 실행 중인 툴은 정의상 없다. */
+export function clearToolCalls(reg, sessionID) {
+    reg.activeToolCalls.delete(sessionID);
+}
+// ── 권한 요청 관측 ───────────────────────────────────────────────────────────
+/**
+ * 플러그인 `event` 훅이 받는 권한 요청 이벤트를 공통 형태로 바꾼다.
+ *
+ * 1.18 v1 브리지는 `permission.asked` 를 `PermissionRequest` 그대로 싣는다
+ * (`id / sessionID / permission / patterns`). 더 오래된 SDK 형태 `permission.updated`
+ * 는 `type` · `pattern`(문자열 또는 배열) 을 쓴다. 둘 다 받아 둔다 — 어느 쪽이 오든
+ * 폴러가 보는 것은 같은 shape 이어야 한다. 요청으로 볼 수 없는 페이로드는 null.
+ */
+export function normalizePermissionEvent(type, properties, now = Date.now()) {
+    if (type !== "permission.asked" && type !== "permission.updated")
+        return null;
+    if (!properties || typeof properties !== "object")
+        return null;
+    const p = properties;
+    const id = typeof p.id === "string" ? p.id : undefined;
+    const sessionID = typeof p.sessionID === "string" ? p.sessionID : undefined;
+    if (!id || !sessionID)
+        return null;
+    const permission = typeof p.permission === "string" ? p.permission
+        : typeof p.type === "string" ? p.type
+            : "unknown";
+    const rawPatterns = p.patterns ?? p.pattern;
+    const patterns = Array.isArray(rawPatterns)
+        ? rawPatterns.filter((x) => typeof x === "string")
+        : typeof rawPatterns === "string" ? [rawPatterns]
+            : [];
+    return { id, sessionID, permission, patterns, askedAt: now };
+}
+export function permissionAsked(reg, req) {
+    let bySession = reg.pendingPermissions.get(req.sessionID);
+    if (!bySession) {
+        bySession = new Map();
+        reg.pendingPermissions.set(req.sessionID, bySession);
+    }
+    bySession.set(req.id, req);
+}
+export function permissionReplied(reg, sessionID, requestID) {
+    const bySession = reg.pendingPermissions.get(sessionID);
+    if (!bySession)
+        return;
+    bySession.delete(requestID);
+    if (bySession.size === 0)
+        reg.pendingPermissions.delete(sessionID);
+}
+/** 이 세션에 답을 기다리는 권한 요청 — 오래된 순. */
+export function pendingPermissionsFor(reg, sessionID) {
+    const bySession = reg.pendingPermissions.get(sessionID);
+    if (!bySession)
+        return [];
+    return [...bySession.values()].sort((a, b) => a.askedAt - b.askedAt);
+}
+// ── 수명 ─────────────────────────────────────────────────────────────────────
+/** 세션 하나의 흔적을 전부 지운다 (cleanupSubSession · session.deleted). */
+export function forgetSession(reg, sessionID) {
+    reg.activeToolCalls.delete(sessionID);
+    reg.lastToolExecuteAt.delete(sessionID);
+    reg.pendingPermissions.delete(sessionID);
+    reg.sessionIssue.delete(sessionID);
+    reg.sessionWorktree.delete(sessionID);
+}
+/** session.deleted — 대기자를 전부 깨운다. 깨운 수를 돌려준다. */
+export function notifySessionDeleted(reg, sessionID) {
+    const waiters = reg.sessionDeletedWaiters.get(sessionID);
+    if (!waiters || waiters.length === 0)
+        return 0;
+    const copy = [...waiters];
+    for (const w of copy) {
+        try {
+            w();
+        }
+        catch { /* waiter 오류는 이벤트 처리를 막지 않는다 */ }
+    }
+    return copy.length;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "makdoong2-team",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "publishConfig": {
     "access": "public"
   },

package/scripts/run-tests.mts

@@ -76,6 +76,7 @@ const STEPS = [
   "node --test test/verdict-reason-injection.test.ts",
   "node --test test/verdict-hash-normalize.test.ts",
   "node --test test/session-index-fallback.test.ts",
+  "node --test test/sub-session-registry.test.ts",
   "node --test test/plugin-exports-shape.test.ts",
   "node --test test/stale-worktree-recovery.test.ts",
   "node --test test/rollback-commits.test.ts",