makdoong2-team 3.0.3 → 3.0.4

package/README.md

@@ -118,6 +118,7 @@ makdoong2-team doctor            # 설치 진단
 | `timeout.substage_minutes` | 서브에이전트 1회 실행 상한 (기본 30분) |
 | `timeout.per_agent` | 에이전트별 상한 override (기본 seed: engineer 60분) |
 | `timeout.stall_escalate_threshold` | substage 누적 hang 상한 (기본 5). 초과 시 dispatch 차단 후 사용자 에스컬레이션 |
+| `timeout.permission_corrections_per_session` | 스코프 밖 경로 요청을 abort 없이 피드백 거부(툴 오류)로 되돌려 주는 세션당 횟수 (기본 3, 0 이면 첫 위반에서 abort) |
 | `tmux` | 막둥이 pane 모니터. 코드 기본값은 off, seed 되는 설정 파일은 `enabled: true` |
 | `worktree.extra_exclude` | worktree 동기화 추가 제외 패턴 |
 | `logging` | `level` / `mode` / `path` / `max_bytes` |

package/agents/makdoong2-analyzer.md

@@ -137,4 +137,5 @@ verifier 가 파일 존재 + JSON 정합 + 마커 3중 검증하며, VERIFIED
 - **outer-world 에이전트 (Sisyphus / Explore / Librarian / oh-my-openagent 계열 카테고리 등) 위임 금지.** 본 에이전트에는 `Task` 툴이 프론트매터에서 제거되어 있어 물리적으로 스폰 불가. 조사가 필요하면 `skill_mcp` 도 아닌 자체 `Read`/`Grep`/`Glob`/`Bash` 만 사용한다 (본 substage 는 원격 조사 불필요).
 - 검증 절차 생략 후 `done` 마커 기록 (게이트 우회 행위).
 - 3단계 scope 를 넘어선 파일 분석 (scope 에서 확정된 대상과 그 직접 의존 파일에 한정).
+- **검색 루트를 저장소 밖으로 넓히지 말 것 (hardrule).** 저장소 안에서 못 찾은 참조(배포 설정·다른 프로젝트의 파일 등)를 상위 디렉토리로 넓혀 찾지 않는다 — `glob`/`grep` 의 `path` 를 `/root/IdeaProjects` 같은 조부모로 넘긴 것이 실제 차단 사례다 (GitHub #12 재발). 자동 승인 범위는 worktree 의 부모 한 단계(worktree 와 형제 디렉토리)뿐이다. 스코프 밖 요청은 툴 오류 `The user rejected permission … with the following feedback: …` 로 돌아오며 그 안내대로 경로를 좁히면 세션은 계속된다; 안내를 받고도 반복하면(세션당 상한) 세션이 종료된다. 저장소 밖 자료가 꼭 필요하면 조사하지 말고 필요한 이유를 최종 출력에 적어 보고한다.
 - 임의 판단으로 `skipped=true` 마킹 (skip 은 게이트 전용 판정).

package/agents/makdoong2-engineer.md

@@ -162,5 +162,6 @@ bash <SCRIPTS_DIR>/state.sh set {ISSUE_KEY} '.stages."2_implementation".substage
 - 요청 범위 밖 리팩토링·"있으면 좋을" 기능 추가.
 - worktree 외부 파일 편집.
 - **`/tmp` 등 워크스페이스 밖 경로에 임시 파일 생성 (hardrule).** opencode 는 bash 명령이 참조하는 디렉토리마다 `external_directory` 승인을 묻는데, 서브에이전트 세션에서 그 요청은 답할 사람이 없어 **자동 거부되고 세션이 즉시 종료된다** — 하던 작업이 통째로 날아간다. 게다가 워크스페이스 밖에 쓴 것은 worktree 동기화·커밋 대상이 아니라 조용히 사라진다. 임시 파일은 반드시 `<worktree>/.makdoong2-team/<이슈키>/tmp/` 에 만든다 (cwd 안이라 승인 불필요, git exclude 이미 등록됨).
+- **검색 루트를 저장소 밖으로 넓히지 말 것 (hardrule).** 저장소 안에서 못 찾은 참조(배포 설정·다른 프로젝트의 파일 등)를 상위 디렉토리로 넓혀 찾지 않는다 — `glob`/`grep` 의 `path` 를 `/root/IdeaProjects` 같은 조부모로 넘긴 것이 실제 차단 사례다 (GitHub #12 재발). 자동 승인 범위는 worktree 의 부모 한 단계(worktree 와 형제 디렉토리)뿐이다. 스코프 밖 요청은 툴 오류 `The user rejected permission … with the following feedback: …` 로 돌아오며 그 안내대로 경로를 좁히면 세션은 계속된다; 안내를 받고도 반복하면(세션당 상한) 세션이 종료된다. 저장소 밖 자료가 꼭 필요하면 조사하지 말고 필요한 이유를 최종 출력에 적어 보고한다.
 - 테스트 결과 임의 보고 (실제 실행 없이 "pass" 기록 금지 — 게이트 우회).
 - 프로덕션 코드 변경 (test 실패 시 dev substage로 복귀 필수).

package/agents/makdoong2-planner.md

@@ -204,6 +204,7 @@ bash <SCRIPTS_DIR>/state.sh set {ISSUE_KEY} '.stages."1_planning".substages."req
   - **쓰기 툴은 세션에 실제로 존재하는 것을 쓴다.** `write` 가 있으면 `write(filePath=…)`, 없으면 `apply_patch` 다 — opencode 는 `gpt-5` 계열 모델 세션에서 `write`·`edit` 를 노출하지 않고 `apply_patch` 로 대체한다. `apply_patch` 본문은 `*** Begin Patch` / `*** Add File: <허용 경로>` / `*** End Patch` 형식이어야 훅이 대상 경로를 파싱해 통과시킨다. **"write 툴 부재" 를 이유로 산출물 생성을 포기하지 말 것** — 그 판단이 워크플로 전체를 정지시킨다 (issue #8).
   - 같은 경로라도 bash 리디렉션은 어느 경우에도 차단된다.
   - **`/tmp` 등 워크스페이스 밖 경로 사용 금지.** 승인이 자동 거부되고 세션이 즉시 종료된다. planning 산출물은 전부 `.makdoong2-team/<이슈키>/` 아래에 만들면 되므로 임시 파일이 필요한 상황 자체가 없다.
+  - **검색 루트를 저장소 밖으로 넓히지 말 것 (hardrule).** 저장소 안에서 못 찾은 참조(배포 설정·다른 프로젝트의 파일 등)를 상위 디렉토리로 넓혀 찾지 않는다 — `glob`/`grep` 의 `path` 를 `/root/IdeaProjects` 같은 조부모로 넘긴 것이 실제 차단 사례다 (GitHub #12 재발). 자동 승인 범위는 worktree 의 부모 한 단계(worktree 와 형제 디렉토리)뿐이다. 스코프 밖 요청은 툴 오류 `The user rejected permission … with the following feedback: …` 로 돌아오며 그 안내대로 경로를 좁히면 세션은 계속된다; 안내를 받고도 반복하면(세션당 상한) 세션이 종료된다. 저장소 밖 자료가 꼭 필요하면 조사하지 말고 필요한 이유를 최종 출력에 적어 보고한다.
   - **금지 패턴**: `echo >`, `cat > file`, `cat <<EOF > file`, `tee file`, `sed -i`, `awk ... > file`, `printf > file`, `> file`, `>> file`, `python -c "... open(..., 'w') ..."`, `node -e "... fs.writeFileSync(...) ..."`
   - **위반 예시**:
     ```bash

package/agents/makdoong2-publisher.md

@@ -467,6 +467,7 @@ bash <SCRIPTS_DIR>/state.sh set {ISSUE_KEY} '.stages."3_delivery".substages."rev
 ## 금지
 
 - **소스코드 파일 편집·생성** — 본 에이전트의 Write 권한은 `change-report.md` 전용. 그 외 파일은 engineer 가 이미 완료했어야 함.
+- **검색 루트를 저장소 밖으로 넓히지 말 것 (hardrule).** 저장소 안에서 못 찾은 참조(배포 설정·다른 프로젝트의 파일 등)를 상위 디렉토리로 넓혀 찾지 않는다 — `glob`/`grep` 의 `path` 를 `/root/IdeaProjects` 같은 조부모로 넘긴 것이 실제 차단 사례다 (GitHub #12 재발). 자동 승인 범위는 worktree 의 부모 한 단계(worktree 와 형제 디렉토리)뿐이다. 스코프 밖 요청은 툴 오류 `The user rejected permission … with the following feedback: …` 로 돌아오며 그 안내대로 경로를 좁히면 세션은 계속된다; 안내를 받고도 반복하면(세션당 상한) 세션이 종료된다. 저장소 밖 자료가 꼭 필요하면 조사하지 말고 필요한 이유를 최종 출력에 적어 보고한다.
 - **`git add .` / `-A` / `-u` 사용** — 여러 파일을 한 번에 stage. 반드시 파일별 `git add -- "$FILE"` 만 허용.
 - **1 commit 에 2개 이상 파일 포함** — atomic 원칙 절대 위반. post-commit 게이트가 REJECT.
 - **결합어(`and`/`&`/`+`/`및`/`그리고`) 를 commit subject 에 사용** — 여러 변경을 한 커밋에 합친 신호. 게이트가 REJECT.

package/agents/makdoong2-team-leader.md

@@ -134,10 +134,11 @@ permission:
 | `permission_reason` | `outside_allowed_roots` / `non_external_permission` / `tool_call_stall` — **처방이 서로 다르다** |
 | `permission_patterns` | 실제로 차단된 경로 패턴 |
 | `permission_scope` | 자동 승인되는 범위 (worktree 의 부모 디렉토리 이하) |
+| `permission_corrections` | abort **전에** 세션 안에서 "경로를 좁혀라" 는 피드백 거부를 받은 횟수. `>0` 이면 안내를 받고도 같은 범위를 반복한 것 |
 
 `permission_reason` 별 조치:
 
-- **`outside_allowed_roots`** — 서브에이전트가 워크스페이스 밖 경로를 요청했다. `dispatch_stage` 가 이미 허용 범위를 프롬프트에 주입해 자동 재디스패치를 시도했고(`attempts` 확인), 그 예산까지 소진한 상태다. **같은 인자로 재호출하지 않는다.** `permission_patterns` 와 `permission_scope` 를 그대로 인용해 보고하고 사용자 지시를 기다린다. 스코프를 넓혀 달라는 요청은 하지 않는다 — 조부모 이상을 여는 것은 형제 프로젝트 전체를 사람 확인 없이 승인 대상으로 만드는 일이라 설계상 거부된다.
+- **`outside_allowed_roots`** — 서브에이전트가 워크스페이스 밖 경로를 요청했다. 방어는 이미 세 번 돌았다: ① 첫 프롬프트에 경로 범위 하드룰이 실려 있었고 ② 스코프 밖 요청은 abort 없이 툴 오류(피드백 거부)로 되돌려져 세션 안에서 고칠 기회를 받았으며(`permission_corrections` 회) ③ 그래도 반복해 abort 된 뒤 `dispatch_stage` 가 허용 범위를 프롬프트에 주입해 자동 재디스패치를 시도했고(`attempts` 확인), 그 예산까지 소진한 상태다. **같은 인자로 재호출하지 않는다.** `permission_patterns` 와 `permission_scope` 를 그대로 인용해 보고하고 사용자 지시를 기다린다. 스코프를 넓혀 달라는 요청은 하지 않는다 — 조부모 이상을 여는 것은 형제 프로젝트 전체를 사람 확인 없이 승인 대상으로 만드는 일이라 설계상 거부된다.
 - **`non_external_permission`** — 경로 문제가 아니라 해당 에이전트 frontmatter 의 `permission:` 블록 문제다 (정식 키는 `edit`; `write` 는 존재하지 않아 조용히 무시된다). 사용자에게 보고한다.
 - **`tool_call_stall`** — 부분 설치 의심. `npx makdoong2-team doctor` 실행을 안내한다.
 
@@ -342,7 +343,7 @@ loop (max_substage_retries=3 per substage):
 - 모델 폴백 시: `[fallback] <agent>: <primary> → <fallback> (reason: ...)`
 - `retry_disallowed` 감지 시: `[substage X RETRY DISALLOWED] outcome=timeout, transient_failures=0 — sub-agent hang. <retry_disallowed_reason>`
 - `session_gone` 최종 실패 시: `[substage X SESSION_GONE gone_reason=<message_stall|status_absent>] dispatch_stage 3회 자동 redispatch 후 실패. attempts=<N>, previous_session_ids=[...]`
-- `permission_stall` 시: `[substage X PERMISSION BLOCKED reason=<permission_reason>] 서브세션이 차단되어 **이미 종료됨** (승인 대기 아님). 차단 경로=<permission_patterns>, 허용 범위=<permission_scope>, attempts=<N>`
+- `permission_stall` 시: `[substage X PERMISSION BLOCKED reason=<permission_reason>] 서브세션이 차단되어 **이미 종료됨** (승인 대기 아님). 차단 경로=<permission_patterns>, 허용 범위=<permission_scope>, 세션 내 교정=<permission_corrections>회, attempts=<N>`
 - verifier ERROR 시: `[substage X VERIFIER ERROR source=<verdict_source>] 검증 미수행 — verifier 만 재호출 (streak=<N>/3). stage 는 건드리지 않음`
 - verifier ERROR streak 초과 시: `[substage X VERIFIER ERROR STREAK EXCEEDED] 판정 3회 연속 실패. source=<verdict_source>. 사용자 개입 필요.`
 - REJECTED 재시도 시: `[substage X REJECTED retry] streak=<N>, reason_prefix="<40자>" → dispatch_stage 재호출`

package/assets/makdoong2-team.schema.json

@@ -141,6 +141,11 @@
           "type": "integer",
           "minimum": 1,
           "description": "Accumulated hang_history entries (message_stall / status_absent) per substage that block further dispatch_stage calls and force user escalation. Counts across tool calls, unlike the per-call MAX_ATTEMPTS budget which resets on every re-dispatch. Default 5."
+        },
+        "permission_corrections_per_session": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "How many times per sub-session an external_directory request outside the allowed scope (worktree parent) is answered with a feedback-reject (tool error telling the model to narrow its path) instead of reject + abort. The session keeps running and can self-correct in place. 0 disables and restores abort-on-first-violation. Default 3."
         }
       }
     },

package/dist/config.d.ts

@@ -31,8 +31,10 @@ export interface TimeoutConfig {
     substage_minutes?: number;
     per_agent?: Record<string, number>;
     stall_escalate_threshold?: number;
+    permission_corrections_per_session?: number;
 }
 export declare const DEFAULT_STALL_ESCALATE_THRESHOLD = 5;
+export declare const DEFAULT_PERMISSION_CORRECTIONS_PER_SESSION = 3;
 export type LogLevel = "silent" | "error" | "warn" | "info" | "debug" | "trace";
 export type LogMode = "stdin" | "file";
 export interface LoggingConfig {

package/dist/config.js

@@ -13,6 +13,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 export const DEFAULT_STALL_ESCALATE_THRESHOLD = 5;
+export const DEFAULT_PERMISSION_CORRECTIONS_PER_SESSION = 3;
 export const LOG_LEVELS = [
     "silent",
     "error",

package/dist/opencode-plugin.js

@@ -21,7 +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 { activeToolCount, clearToolCalls, forgetSession, isToolExecuting as registryIsToolExecuting, normalizePermissionEvent, notifySessionDeleted, pendingPermissionsFor, permissionAsked, permissionReplied, permissionsRejectedCascade, 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";
@@ -30,10 +30,10 @@ import { shouldEscalateStall } from "./stall-escalation.js";
 import { classifyStageCompletion, INCOMPLETE_HANG_REASON } from "./stage-completion.js";
 import { buildStateWriteBlockMessage, classifyStateJsonAccess, looksLikeRedirection, splitUnquotedSegments, WRITE_INDICATORS_UNQUOTED, STATE_SH_CALL_RE, stripQuotedSpans, } from "./state-access-guard.js";
 import { TmuxMonitor, readTmuxConfig, orphanCleanupGuard } from "./tmux-monitor.js";
-import { resolvePaths, loadConfig, loadOpencodeExternalDirAllows, pluginOwnAllowPatterns, readLoggingConfig, DEFAULT_STALL_ESCALATE_THRESHOLD, } from "./config.js";
+import { resolvePaths, loadConfig, loadOpencodeExternalDirAllows, pluginOwnAllowPatterns, readLoggingConfig, DEFAULT_STALL_ESCALATE_THRESHOLD, DEFAULT_PERMISSION_CORRECTIONS_PER_SESSION, } from "./config.js";
 import { scanSkillMcpRegistry, extractMcpName, looksLikeMcpNotFound, looksLikeMcpConnectionFailed, } from "./skill-mcp-registry.js";
 import { injectAllSecrets } from "./mcp-secret-injector.js";
-import { pollSubSession as pollSubSessionCore, pollOutcomeToLegacy } from "./poll-sub-session.js";
+import { pollSubSession as pollSubSessionCore, pollOutcomeToLegacy, buildPathScopePromptBlock, } from "./poll-sub-session.js";
 import { logger } from "./logger.js";
 import { redactAndTruncate } from "./redact-secrets.js";
 import { extractApplyPatchPaths, isApplyPatchTool } from "./apply-patch-paths.js";
@@ -606,6 +606,9 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
     // threshold caps the accumulated hang_history across calls — the stall-path
     // counterpart of same_reason_streak on the REJECTED-verdict path.
     const stallEscalateThreshold = Math.max(1, Math.round(config.timeout?.stall_escalate_threshold ?? DEFAULT_STALL_ESCALATE_THRESHOLD));
+    // 워크스페이스 밖 경로 요청을 세션 안에서 되돌려 주는 예산 (issue #12 재발 보고).
+    // abort → 재디스패치는 대화 이력을 잃는 비싼 경로라 이 예산이 소진된 뒤에만 탄다.
+    const permissionCorrectionsPerSession = Math.max(0, Math.round(config.timeout?.permission_corrections_per_session ?? DEFAULT_PERMISSION_CORRECTIONS_PER_SESSION));
     // 자동 승인 대상 외부 디렉터리 패턴 = 플러그인 자기 경로(항상) + 사용자 시드.
     //
     // 앞쪽이 2차 방어다: 설치가 opencode.json 패치를 남기지 못해도 서브에이전트가
@@ -792,6 +795,38 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
             // permission.replied 이벤트는 세션의 사본에 도착하지만, 그 사본이 이벤트를
             // 놓치더라도 다음 폴이 같은 요청을 다시 처리하지 않도록 즉시 뺀다.
             permissionReplied(registry, sessionId, req.path.requestID);
+            // reject 는 같은 세션의 나머지 대기 요청까지 연쇄 거부한다 — 이벤트가 오기
+            // 전에 다음 폴이 그것들에 다시 답하지 않도록 즉시 비운다.
+            if (req.body.reply === "reject")
+                permissionsRejectedCascade(registry, sessionId);
+            return res;
+        },
+        // 피드백 거부(in-place correction). 세션-라우팅 엔드포인트는 `{response}` 만
+        // 받아 문구를 실을 수 없으므로 `POST /permission/{requestID}/reply` 를 쓴다.
+        // 그 라우트는 **디렉토리 스코프**(`?directory=` 가 헤더보다 우선)라 worktree
+        // 서브세션의 요청에 닿으려면 세션의 worktree 를 query 로 명시해야 한다 —
+        // 클라이언트 기본 헤더는 main repo 를 가리키므로 생략하면 NotFound 다.
+        // `reject` + `message` 는 opencode 가 `CorrectedError` 로 바꿔 툴 호출 하나만
+        // 실패시키고 세션 루프는 계속 돌린다 (`RejectedError` 는 루프를 세운다).
+        correct: async (req) => {
+            const raw = client._client;
+            if (!raw || typeof raw.post !== "function") {
+                throw new Error("raw permission reply endpoint unavailable on this client");
+            }
+            const directory = registry.sessionWorktree.get(sessionId);
+            const res = await raw.post({
+                url: "/permission/{requestID}/reply",
+                path: { requestID: req.path.requestID },
+                query: directory ? { directory } : undefined,
+                body: { reply: "reject", message: req.body.message },
+                headers: { "Content-Type": "application/json" },
+            });
+            if (res?.error !== undefined) {
+                throw new Error(`permission correction rejected by server: status=${res.response?.status ?? "?"} ` +
+                    `error=${JSON.stringify(res.error).slice(0, 200)}`);
+            }
+            permissionReplied(registry, sessionId, req.path.requestID);
+            permissionsRejectedCascade(registry, sessionId);
             return res;
         },
     });
@@ -803,9 +838,11 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
         configuredAllowPatterns,
         logger: {
             debug: (msg) => logger.debug(msg),
+            warn: (msg) => logger.warn(msg),
             error: (msg) => logger.error(msg),
         },
         permissionCheckIntervalPolls: 1,
+        maxPermissionCorrections: permissionCorrectionsPerSession,
         nudgeAtFraction: onNudge ? 0.8 : undefined,
         onNudge,
         messageStallThresholdMs,
@@ -1900,6 +1937,10 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                             `Stage spec: read ${specPath} and follow it strictly.`,
                             `모든 state.sh / wt-sync-ignored.sh / config.sh 호출은 위 Scripts directory 경로를 사용하시오. \`$HOME/.config/opencode/scripts/\`나 \`scripts/\` 상대경로를 사용하지 마시오.`,
                             `Stage 명세 파일은 위 Stages directory 경로에서 읽으시오. \`<SCRIPTS_DIR>/../stages/\` 상대경로를 사용하지 마시오.`,
+                            // 경로 범위는 차단이 난 뒤가 아니라 첫 프롬프트부터 알린다. 관측된
+                            // 위반은 모델이 저장소 밖을 검색 루트로 **명시적으로** 고른 것이라
+                            // (issue #12 재발 보고), 사후 안내만으로는 첫 시도를 막지 못한다.
+                            ...buildPathScopePromptBlock(effectiveWorktree, permissionCorrectionsPerSession),
                         ];
                         if (args.target_stage === "2_implementation.dev") {
                             base.push(`\n=== dev substage 요구사항 소스 우선순위 ===`, `구현 착수 전 요구사항은 반드시 다음 순서로 참조한다:`, `  a) FIRST — requirements-draft.md 를 우선 확인 (아래 bash 스니펫 그대로 실행):`, buildDraftPathReadSnippet(args.issue, "       "), `     파일이 존재하고 비어있지 않으면 이 파일이 요구사항의 진실의 원천이다.`, `  b) FALLBACK — draft_path 미기록/파일 부재/빈 파일 인 경우 Jira 이슈 조회:`, `       skill(name="jira-research") 로 works MCP 로드 →`, `       skill_mcp(mcp_name="works", tool_name="getIssue", arguments={"issueKey":"${args.issue}"})`, `  c) 두 소스 모두 접근 불가하면 사용자에게 상황을 보고하고 즉시 종료.`, `주의: requirements-draft.md 없이 Jira 이슈만으로 구현 범위를 재결정하지 말 것 — draft 가 없다는 것은 planning 이 부적절하게 진행된 신호이므로 사용자에게 보고하고 종료하시오.`, `\n=== 테스트 동반 원칙은 requirements 의 선언을 따른다 (issue #11) ===`, `테스트 추가 여부는 스스로 정하지 않는다. 아래를 실행해 1_planning.requirements 가 승인·동결한 선언을 먼저 읽는다:`, `  bash ${SCRIPTS_DIR}/state.sh get ${args.issue} '.stages."1_planning".substages."requirements".test_scope'`, `  - new_tests_required=true (마커 부재·null 도 true 로 간주 — fail-closed) → 변경에 대한 테스트를 함께 추가하고 self_check.new_tests_added=true 로 기록한다.`, `  - new_tests_required=false → 테스트 추가는 이번 이슈의 범위 밖이다. 추가하지 않는 것이 정답이며, self_check.new_tests_added=false 와 함께 dev.new_tests_waived=true 마커를 남긴다.`, `이 마커는 읽기 전용이다 — engineer 가 test_scope 를 쓰거나 고치지 않는다. 선언과 실제 작업이 맞지 않으면 임의로 면제·추가하지 말고 최종 출력에 적어 보고한다.`);
@@ -2240,10 +2281,15 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                                     const scopeLine = outcome.permissionScope
                                         ? `자동 승인 범위: ${outcome.permissionScope}/ 이하 — worktree(${effectiveWorktree}) 와 그 형제 디렉토리까지다. 그 위(조부모 이상)는 열리지 않는다.`
                                         : `자동 승인 범위: worktree(${effectiveWorktree}) 와 그 형제 디렉토리까지다. 그 위는 열리지 않는다.`;
+                                    const corrections = outcome.permissionCorrections ?? 0;
+                                    const correctionLine = corrections > 0
+                                        ? `그 세션은 abort 전에 이미 ${corrections}회 "경로를 좁혀라" 는 피드백 거부를 받았는데도 같은 범위를 다시 요청했다. 이번에는 첫 안내에서 멈춰야 한다.`
+                                        : null;
                                     permissionBlockNote = [
                                         `직전 attempt(${attempt}) 는 워크스페이스 밖 경로에 대한 external_directory 권한 요청 때문에 자동 거부되고 세션이 abort 됐다.`,
                                         `차단된 요청 패턴: ${JSON.stringify(blockedPatterns)}`,
                                         scopeLine,
+                                        ...(correctionLine ? [correctionLine] : []),
                                         `서브세션에는 이 승인을 받을 채널이 없다 — 같은 경로를 다시 요청하면 또 즉시 중단되고, 그때까지 한 작업은 전부 버려진다.`,
                                         `조치:`,
                                         `  - glob / grep / read / list 의 경로 인자를 위 허용 범위 안으로 좁혀라. 경로 인자를 아예 주지 않고 cwd 기준 상대 패턴을 쓰는 것이 가장 안전하다.`,
@@ -2253,7 +2299,7 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                                     logger.warn(`[dispatch_stage] PERMISSION_BLOCK session=${subSessionID} stage=${args.target_stage} ` +
                                         `attempt=${attempt}/${currentMaxAttempts} reason=${outcome.permissionReason} ` +
                                         `patterns=${JSON.stringify(blockedPatterns)} scope=${outcome.permissionScope ?? "unknown"} ` +
-                                        `— redispatching with allowed-scope guidance injected`);
+                                        `corrections=${corrections} — redispatching with allowed-scope guidance injected`);
                                     continue;
                                 }
                                 // 예산 소진(또는 회복 불가 사유). hang_history 는 dispatch_stage 호출
@@ -2265,6 +2311,7 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                                     reason: `permission_stall:${outcome.permissionReason ?? "unknown"}`,
                                     patterns: blockedPatterns,
                                     scope: outcome.permissionScope ?? null,
+                                    corrections: outcome.permissionCorrections ?? 0,
                                     elapsed_ms: outcome.elapsedMs,
                                     polls: outcome.polls,
                                     session_id: subSessionID,
@@ -2293,6 +2340,9 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                                     permission_reason: outcome.permissionReason ?? "unknown",
                                     permission_patterns: blockedPatterns,
                                     permission_scope: outcome.permissionScope ?? null,
+                                    // abort 전에 세션 안에서 돌려보낸 횟수. 0 이면 교정 경로가 없었다는
+                                    // 뜻(0 예산 또는 회복 불가 사유)이고, >0 이면 안내를 받고도 반복한 것.
+                                    permission_corrections: outcome.permissionCorrections ?? 0,
                                     permission_id: outcome.permissionID,
                                     permission_type: outcome.permissionType,
                                     // 승인 대기가 아니라 "이미 종료됨" 이다. 이 두 필드를 읽고 보고한다.

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

@@ -67,6 +67,21 @@ export interface PollClientLike {
                 reply: string;
             };
         }) => Promise<unknown>;
+        /**
+         * 피드백을 실은 거부. opencode 는 `reject` + `message` 를 `RejectedError` 가 아니라
+         * `CorrectedError` 로 바꾼다 — 툴 호출은 그 문구를 오류로 돌려받고, **세션 루프는
+         * 멈추지 않는다** (`processor.ts` 의 `ctx.blocked` 는 `RejectedError` 에만 걸린다).
+         * 그래서 서브에이전트가 경로를 좁혀 같은 자리에서 이어갈 수 있다. 없으면(구버전
+         * 클라이언트) 종전대로 reject + abort 로 떨어진다.
+         */
+        correct?: (req: {
+            path: {
+                requestID: string;
+            };
+            body: {
+                message: string;
+            };
+        }) => Promise<unknown>;
     };
 }
 export type PermissionStallReason = "outside_allowed_roots" | "non_external_permission" | "tool_call_stall";
@@ -100,6 +115,7 @@ export type PollOutcome = {
     permissionPatterns?: string[];
     permissionReason?: PermissionStallReason;
     permissionScope?: string;
+    permissionCorrections?: number;
 } | {
     kind: "session_gone";
     polls: number;
@@ -113,10 +129,12 @@ export interface PollOptions {
     permissionCheckIntervalPolls?: number;
     allowedWorktree?: string;
     configuredAllowPatterns?: string[];
+    maxPermissionCorrections?: number;
     now?: () => number;
     sleep?: (ms: number) => Promise<void>;
     logger?: {
         debug?: (msg: string) => void;
+        warn?: (msg: string) => void;
         error?: (msg: string) => void;
     };
     toolCallStallThresholdMs?: number;
@@ -141,6 +159,32 @@ export interface PollOptions {
  * permission-block 재디스패치)이 맡는다.
  */
 export declare function worktreeAllowedScope(worktree: string): string;
+/**
+ * 스코프 밖 요청을 abort 없이 돌려보낼 때 툴 오류로 실리는 문구.
+ *
+ * 서브에이전트가 보는 것은 "The user rejected permission … with the following
+ * feedback: <이 문구>" 다. 재디스패치 노트(`permissionBlockNote`)와 같은 내용을
+ * 담되, **지금 이 세션에서 바로 고칠 수 있다**는 전제로 쓴다 — 대화 이력이 그대로
+ * 남아 있으므로 새 세션에 실었던 "직전 세션이 죽었다" 류 설명은 필요 없다.
+ * `remaining` 은 이번 교정 이후 남은 횟수다. 0 이면 다음 위반에서 세션이 종료된다.
+ */
+export declare function buildPermissionCorrectionMessage(input: {
+    patterns: string[];
+    worktree?: string;
+    scope?: string;
+    remaining: number;
+}): string;
+/**
+ * 모든 dispatch_stage 프롬프트에 상시 주입되는 경로 범위 안내 (선제 방어).
+ *
+ * 재디스패치 노트와 in-place 교정은 둘 다 **차단이 난 뒤**에 작동한다. 관측된
+ * 위반은 우연이 아니라 의도된 것이었다 — 저장소 안 검색이 비자 모델이 상위
+ * 디렉토리를 검색 루트로 **명시적으로** 넘겼다 (`glob {path:"/root/IdeaProjects"}`,
+ * GitHub #12 재발 보고). 그 판단이 내려지기 전에 규칙을 보여주는 것이 가장 싸다.
+ * 문구는 교정 메시지·재디스패치 노트와 같은 어휘를 쓴다 — 세 층이 다른 말을
+ * 하면 모델은 어느 것이 규칙인지 모른다.
+ */
+export declare function buildPathScopePromptBlock(worktree: string, maxCorrections: number): string[];
 export declare function isWithinWorktreeScope(patterns: string[], worktree: string): boolean;
 export declare function isMatchedByConfiguredRules(patterns: string[], allowedGlobs: string[]): boolean;
 /**

package/dist/poll-sub-session.js

@@ -101,6 +101,57 @@ function posixDirname(p) {
 export function worktreeAllowedScope(worktree) {
     return posixDirname(worktree);
 }
+/**
+ * 스코프 밖 요청을 abort 없이 돌려보낼 때 툴 오류로 실리는 문구.
+ *
+ * 서브에이전트가 보는 것은 "The user rejected permission … with the following
+ * feedback: <이 문구>" 다. 재디스패치 노트(`permissionBlockNote`)와 같은 내용을
+ * 담되, **지금 이 세션에서 바로 고칠 수 있다**는 전제로 쓴다 — 대화 이력이 그대로
+ * 남아 있으므로 새 세션에 실었던 "직전 세션이 죽었다" 류 설명은 필요 없다.
+ * `remaining` 은 이번 교정 이후 남은 횟수다. 0 이면 다음 위반에서 세션이 종료된다.
+ */
+export function buildPermissionCorrectionMessage(input) {
+    const blocked = input.patterns.length ? JSON.stringify(input.patterns) : "(패턴 미상)";
+    const scope = input.scope
+        ? `${input.scope}/ 이하(worktree 와 그 형제 디렉토리)`
+        : "worktree 와 그 형제 디렉토리";
+    const wt = input.worktree ? `worktree(${input.worktree})` : "worktree";
+    const budget = input.remaining > 0
+        ? `남은 자동 교정 ${input.remaining}회 — 그 뒤에는 세션이 종료되고 지금까지의 작업이 버려진다.`
+        : `자동 교정 한도에 도달했다 — 한 번 더 스코프 밖을 요청하면 세션이 종료되고 지금까지의 작업이 버려진다.`;
+    return [
+        `워크스페이스 밖 경로 요청이라 자동 거부됐다 (요청 패턴 ${blocked}). 이 세션에는 승인 채널이 없다 — 사용자에게 승인을 요청하지 말 것.`,
+        `자동 승인 범위는 ${scope}뿐이고 그 위(조부모 이상)는 열리지 않는다.`,
+        `조치: glob / grep / read / list / bash 의 경로 인자를 ${wt} 안으로 좁혀 다시 시도하라. 경로 인자를 아예 주지 않고 cwd 기준 상대 패턴을 쓰는 것이 가장 안전하다.`,
+        `저장소 안에서 못 찾은 참조를 상위 디렉토리로 넓혀 찾지 말 것. 저장소 밖 자료가 꼭 필요하면 조사하지 말고, 필요한 이유를 최종 출력에 적어 보고하라.`,
+        `임시 파일은 /tmp 가 아니라 worktree 안의 .makdoong2-team/<이슈키>/tmp/ 에 만든다.`,
+        budget,
+    ].join(" ");
+}
+/**
+ * 모든 dispatch_stage 프롬프트에 상시 주입되는 경로 범위 안내 (선제 방어).
+ *
+ * 재디스패치 노트와 in-place 교정은 둘 다 **차단이 난 뒤**에 작동한다. 관측된
+ * 위반은 우연이 아니라 의도된 것이었다 — 저장소 안 검색이 비자 모델이 상위
+ * 디렉토리를 검색 루트로 **명시적으로** 넘겼다 (`glob {path:"/root/IdeaProjects"}`,
+ * GitHub #12 재발 보고). 그 판단이 내려지기 전에 규칙을 보여주는 것이 가장 싸다.
+ * 문구는 교정 메시지·재디스패치 노트와 같은 어휘를 쓴다 — 세 층이 다른 말을
+ * 하면 모델은 어느 것이 규칙인지 모른다.
+ */
+export function buildPathScopePromptBlock(worktree, maxCorrections) {
+    const scope = worktreeAllowedScope(worktree);
+    const budget = maxCorrections > 0
+        ? `위반하면 툴 호출이 "The user rejected permission … with the following feedback: …" 오류로 실패하고 경로를 좁히라는 안내가 실린다 (세션당 ${maxCorrections}회). 그 이상 반복하면 세션이 종료되고 지금까지의 작업이 버려진다.`
+        : `위반하면 세션이 즉시 종료되고 지금까지의 작업이 버려진다.`;
+    return [
+        `\n=== 경로 범위 (hardrule) ===`,
+        `이 세션은 헤드리스라 권한 요청에 답할 사람이 없다. 자동 승인 범위는 ${scope}/ 이하(worktree 와 그 형제 디렉토리)뿐이고, 그 위(조부모 이상)는 열리지 않는다.`,
+        `glob / grep / read / list / bash 의 경로 인자는 항상 worktree(${worktree}) 안으로 둔다. 경로 인자를 아예 주지 않고 cwd 기준 상대 패턴을 쓰는 것이 가장 안전하다.`,
+        `저장소 안에서 못 찾은 참조(배포 설정·다른 프로젝트의 파일 등)를 상위 디렉토리로 넓혀 찾지 말 것. 저장소 밖 자료가 꼭 필요하면 조사하지 말고, 필요한 이유를 최종 출력에 적어 보고한다.`,
+        `임시 파일은 /tmp 가 아니라 worktree 안의 .makdoong2-team/<이슈키>/tmp/ 에 만든다.`,
+        budget,
+    ];
+}
 // Returns true when every permission pattern resides within the allowed scope,
 // defined as the parent directory of the worktree (siblings are the main repo
 // and other worktrees — all legitimate access targets for engineers).
@@ -158,6 +209,7 @@ export async function pollSubSession(client, sessionId, options = {}) {
     const sleep = options.sleep ?? ((ms) => new Promise(r => setTimeout(r, ms)));
     const dbg = options.logger?.debug;
     const err = options.logger?.error ?? ((msg) => console.error(msg));
+    const warn = options.logger?.warn ?? err;
     const startTime = now();
     const deadline = startTime + timeoutMs;
     const expectedPolls = Math.ceil(timeoutMs / pollIntervalMs);
@@ -170,7 +222,9 @@ export async function pollSubSession(client, sessionId, options = {}) {
     const isRecentlyActive = options.isRecentlyActive;
     const isToolExecuting = options.isToolExecuting;
     const permissionCheckIntervalPolls = options.permissionCheckIntervalPolls ?? 5;
+    const maxPermissionCorrections = options.maxPermissionCorrections ?? 3;
     let pollCount = 0;
+    let permissionCorrections = 0;
     let transientFailures = 0;
     let sessionEverAppeared = false;
     let hasProducedAssistantMessage = false;
@@ -349,47 +403,97 @@ export async function pollSubSession(client, sessionId, options = {}) {
         if (client.permission && pollCount % permissionCheckIntervalPolls === 0) {
             const permResult = await client.permission.list().catch(() => null);
             const pending = (permResult?.data ?? []).filter(p => p.sessionID === sessionId);
-            for (const p of pending) {
-                const withinScope = p.permission === "external_directory" && ((!!options.allowedWorktree && isWithinWorktreeScope(p.patterns, options.allowedWorktree)) ||
-                    isMatchedByConfiguredRules(p.patterns, options.configuredAllowPatterns ?? []));
-                if (withinScope) {
-                    dbg?.(`[pollSubSession] PERMISSION_ALLOW session=${sessionId} polls=${pollCount}` +
-                        ` permissionID=${p.id} type=${p.permission} patterns=${JSON.stringify(p.patterns)}` +
-                        ` scope=dirname(${options.allowedWorktree})`);
-                    await client.permission
-                        .reply({ path: { requestID: p.id }, body: { reply: "once" } })
-                        .catch(() => undefined);
-                }
-                else {
-                    // 두 실패를 뭉뚱그리지 않는다. "허용 경로 밖" 은 대안 경로를 알려주면
-                    // 회복 가능하고, "external_directory 가 아닌 권한" 은 경로와 무관한
-                    // 에이전트 설정 문제라 조치가 정반대다. 종전에는 한 문장이었다.
-                    const reason = p.permission === "external_directory"
-                        ? "outside_allowed_roots"
-                        : "non_external_permission";
-                    err(`[pollSubSession] PERMISSION_STALL session=${sessionId} polls=${pollCount}` +
-                        ` permissionID=${p.id} type=${p.permission} patterns=${JSON.stringify(p.patterns)}` +
-                        ` reason=${reason} — auto-rejecting`);
-                    await client.permission
-                        .reply({ path: { requestID: p.id }, body: { reply: "reject" } })
-                        .catch(() => undefined);
-                    await client.session.abort({ path: { id: sessionId } }).catch(() => undefined);
-                    return {
-                        kind: "permission_stall",
-                        polls: pollCount,
-                        elapsedMs: now() - startTime,
-                        stalledMs,
-                        permissionID: p.id,
-                        permissionType: p.permission,
-                        permissionPatterns: p.patterns,
-                        permissionReason: reason,
-                        // 무엇이 막혔는지(patterns)만으로는 처방이 안 나온다 — **어디까지가
-                        // 허용인지**를 같이 실어야 서브에이전트가 경로를 좁혀 재시도할 수 있다.
-                        permissionScope: options.allowedWorktree
-                            ? worktreeAllowedScope(options.allowedWorktree)
-                            : undefined,
-                    };
+            const isWithinScope = (p) => p.permission === "external_directory" && ((!!options.allowedWorktree && isWithinWorktreeScope(p.patterns, options.allowedWorktree)) ||
+                isMatchedByConfiguredRules(p.patterns, options.configuredAllowPatterns ?? []));
+            // 허용을 먼저 전부 답하고 거부는 그 뒤에 한다. opencode 의 `reject` 는 같은
+            // 세션의 **다른 대기 요청까지 연쇄 거부**하므로(`Permission.reply`), 순서를
+            // 섞으면 병렬 배치의 정당한 형제 디렉토리 요청이 스코프 밖 요청 하나에
+            // 딸려 죽는다.
+            const allowed = pending.filter(isWithinScope);
+            const denied = pending.filter(p => !isWithinScope(p));
+            for (const p of allowed) {
+                dbg?.(`[pollSubSession] PERMISSION_ALLOW session=${sessionId} polls=${pollCount}` +
+                    ` permissionID=${p.id} type=${p.permission} patterns=${JSON.stringify(p.patterns)}` +
+                    ` scope=dirname(${options.allowedWorktree})`);
+                await client.permission
+                    .reply({ path: { requestID: p.id }, body: { reply: "once" } })
+                    .catch(() => undefined);
+            }
+            for (const p of denied) {
+                // 두 실패를 뭉뚱그리지 않는다. "허용 경로 밖" 은 대안 경로를 알려주면
+                // 회복 가능하고, "external_directory 가 아닌 권한" 은 경로와 무관한
+                // 에이전트 설정 문제라 조치가 정반대다. 종전에는 한 문장이었다.
+                const reason = p.permission === "external_directory"
+                    ? "outside_allowed_roots"
+                    : "non_external_permission";
+                const permissionScope = options.allowedWorktree
+                    ? worktreeAllowedScope(options.allowedWorktree)
+                    : undefined;
+                // ── in-place correction: 세션을 죽이지 않고 경로를 좁히게 한다 ─────────
+                //
+                // 관측된 차단은 전부 모델이 **명시적으로** 조부모를 검색 루트로 넘긴
+                // 것이었다 (`glob {path:"/root/IdeaProjects"}` — 저장소 안 검색이 비어
+                // 상위로 넓힌 것, GitHub #12 재발 보고). 이건 세션을 abort 할 일이 아니라
+                // 툴 오류 하나로 고쳐질 일이다. `reject` 에 `message` 를 실으면 opencode 가
+                // `CorrectedError` 로 바꿔 툴 호출만 실패시키고 루프는 계속 돈다 — 모델은
+                // 그 문구를 읽고 같은 자리에서 경로를 좁힌다. 대화 이력·진행 중이던 병렬
+                // 툴·지금까지의 작업이 전부 보존된다. 재디스패치는 이 예산이 소진된 뒤의
+                // 후순위 경로다.
+                //
+                // 예산은 세션당 `maxPermissionCorrections` 회. 안내를 받고도 반복하면
+                // 프롬프트로 고쳐지지 않는 것이므로 종전대로 abort → 재디스패치 →
+                // hang_history 상한으로 넘긴다.
+                const canCorrect = reason === "outside_allowed_roots" &&
+                    typeof client.permission.correct === "function" &&
+                    permissionCorrections < maxPermissionCorrections;
+                if (canCorrect) {
+                    const remaining = maxPermissionCorrections - permissionCorrections - 1;
+                    const message = buildPermissionCorrectionMessage({
+                        patterns: p.patterns,
+                        worktree: options.allowedWorktree,
+                        scope: permissionScope,
+                        remaining,
+                    });
+                    const corrected = await client.permission
+                        .correct({ path: { requestID: p.id }, body: { message } })
+                        .then(() => true)
+                        .catch((e) => {
+                        err(`[pollSubSession] PERMISSION_CORRECT_FAILED session=${sessionId} polls=${pollCount}` +
+                            ` permissionID=${p.id} error=${e} — falling back to reject + abort`);
+                        return false;
+                    });
+                    if (corrected) {
+                        permissionCorrections++;
+                        warn(`[pollSubSession] PERMISSION_CORRECT session=${sessionId} polls=${pollCount}` +
+                            ` permissionID=${p.id} type=${p.permission} patterns=${JSON.stringify(p.patterns)}` +
+                            ` scope=${permissionScope ?? "unknown"} corrections=${permissionCorrections}/${maxPermissionCorrections}` +
+                            ` — rejected with feedback, session continues`);
+                        // 연쇄 거부로 나머지 대기 요청은 이미 opencode 가 정리했다. 이번 폴에서
+                        // 더 답하면 NotFound 만 난다.
+                        break;
+                    }
                 }
+                err(`[pollSubSession] PERMISSION_STALL session=${sessionId} polls=${pollCount}` +
+                    ` permissionID=${p.id} type=${p.permission} patterns=${JSON.stringify(p.patterns)}` +
+                    ` reason=${reason} corrections=${permissionCorrections}/${maxPermissionCorrections} — auto-rejecting`);
+                await client.permission
+                    .reply({ path: { requestID: p.id }, body: { reply: "reject" } })
+                    .catch(() => undefined);
+                await client.session.abort({ path: { id: sessionId } }).catch(() => undefined);
+                return {
+                    kind: "permission_stall",
+                    polls: pollCount,
+                    elapsedMs: now() - startTime,
+                    stalledMs,
+                    permissionID: p.id,
+                    permissionType: p.permission,
+                    permissionPatterns: p.patterns,
+                    permissionReason: reason,
+                    // 무엇이 막혔는지(patterns)만으로는 처방이 안 나온다 — **어디까지가
+                    // 허용인지**를 같이 실어야 서브에이전트가 경로를 좁혀 재시도할 수 있다.
+                    permissionScope,
+                    permissionCorrections,
+                };
             }
         }
         // Tool-call stall — "툴 호출이 떠 있는데 아무 진전이 없다".
@@ -699,7 +803,14 @@ export function pollOutcomeToLegacy(outcome) {
                         const scope = outcome.permissionScope
                             ? `\`${outcome.permissionScope}/\` 이하 (worktree 와 그 형제 디렉토리)`
                             : "worktree 와 그 형제 디렉토리";
-                        return `워크스페이스 밖 경로 접근이라 차단됐다 — 요청 ${blocked}, 자동 승인 범위 ${scope}. ` +
+                        // in-place 교정이 있었다면 abort 는 "안내를 받고도 같은 범위를 다시
+                        // 요청했다" 는 뜻이다. 그 횟수를 보고에 싣지 않으면 리더는 첫 차단과
+                        // 구분할 수 없어 같은 안내를 한 번 더 주입하는 데 그친다.
+                        const corrections = outcome.permissionCorrections ?? 0;
+                        const correctionNote = corrections > 0
+                            ? `세션 안에서 ${corrections}회 경로 교정 안내(피드백 거부)를 받고도 같은 범위를 다시 요청해 abort 됐다. `
+                            : "";
+                        return `워크스페이스 밖 경로 접근이라 차단됐다 — 요청 ${blocked}, 자동 승인 범위 ${scope}. ${correctionNote}` +
                             "그 위(조부모 이상)는 설계상 열지 않는다: 한 번 열면 형제 프로젝트 전체가 사람의 확인 없이 승인 대상이 된다. " +
                             "조치는 둘 중 하나다. " +
                             "(1) 조회(glob/grep/read/list)라면 경로 인자를 허용 범위 안으로 좁혀라 — 경로 인자 없이 cwd 기준 상대 패턴을 쓰는 것이 가장 안전하다. " +

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

@@ -66,6 +66,14 @@ export declare function clearToolCalls(reg: SubSessionRegistry, sessionID: strin
 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;
+/**
+ * 세션의 대기 요청을 전부 뺀다. opencode 는 `reject` 하나에 같은 세션의 나머지
+ * 대기 요청을 **연쇄 거부**하고 각각 `permission.replied` 를 발행한다 — 그 이벤트가
+ * 사본에 도착하기 전 다음 폴이 돌면 이미 없는 요청에 다시 답하려다 NotFound 를
+ * 받는다 (피드백 거부 경로에서는 그 오류가 abort 로 격상된다). 거부 응답 직후
+ * 폴러 쪽에서 선제로 비운다. 반환값은 뺀 개수.
+ */
+export declare function permissionsRejectedCascade(reg: SubSessionRegistry, sessionID: string): number;
 /** 이 세션에 답을 기다리는 권한 요청 — 오래된 순. */
 export declare function pendingPermissionsFor(reg: SubSessionRegistry, sessionID: string): PendingPermission[];
 /** 세션 하나의 흔적을 전부 지운다 (cleanupSubSession · session.deleted). */

package/dist/sub-session-registry.js

@@ -172,6 +172,21 @@ export function permissionReplied(reg, sessionID, requestID) {
     if (bySession.size === 0)
         reg.pendingPermissions.delete(sessionID);
 }
+/**
+ * 세션의 대기 요청을 전부 뺀다. opencode 는 `reject` 하나에 같은 세션의 나머지
+ * 대기 요청을 **연쇄 거부**하고 각각 `permission.replied` 를 발행한다 — 그 이벤트가
+ * 사본에 도착하기 전 다음 폴이 돌면 이미 없는 요청에 다시 답하려다 NotFound 를
+ * 받는다 (피드백 거부 경로에서는 그 오류가 abort 로 격상된다). 거부 응답 직후
+ * 폴러 쪽에서 선제로 비운다. 반환값은 뺀 개수.
+ */
+export function permissionsRejectedCascade(reg, sessionID) {
+    const bySession = reg.pendingPermissions.get(sessionID);
+    if (!bySession)
+        return 0;
+    const n = bySession.size;
+    reg.pendingPermissions.delete(sessionID);
+    return n;
+}
 /** 이 세션에 답을 기다리는 권한 요청 — 오래된 순. */
 export function pendingPermissionsFor(reg, sessionID) {
     const bySession = reg.pendingPermissions.get(sessionID);

package/package.json

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