makdoong2-team 3.0.2 → 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

@@ -121,6 +121,29 @@ permission:
 
 `ok: true` 만 보고 넘어가지 말 것 — `paused` 와 `unknown` 도 `ok: true` 이며, 둘 다 substage 는 끝나지 않았다.
 
+## `permission_stall` 은 "승인 대기" 가 아니다 — 이미 종료된 것이다 (hardrule)
+
+`dispatch_stage` 가 `outcome_kind: "permission_stall"` 을 반환하면, 그 시점에 이미 **권한 요청은 자동 거부됐고 서브세션은 abort 됐다.** 헤드리스 서브세션에는 승인을 받을 채널 자체가 없어서 훅이 대신 거부한 것이다 — 사용자가 승인할 대상이 애초에 존재하지 않는다.
+
+**금지**: "worktree 접근 권한 승인 대기 — 승인한 뒤 재개해 주세요" 류의 보고. 실제로 이 오판이 워크플로를 세웠다. 도구가 반환한 `output` 에는 `aborted after {N}ms` 로 **종료됐다는 사실**이 적혀 있었고 "승인을 기다리라" 는 지시는 한 글자도 없었다 (GitHub issue #12). 응답의 `awaiting_user_approval: false` / `session_aborted: true` 가 그 점을 못 박는다.
+
+읽어야 할 필드는 셋이다:
+
+| 필드 | 뜻 |
+|---|---|
+| `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`** — 서브에이전트가 워크스페이스 밖 경로를 요청했다. 방어는 이미 세 번 돌았다: ① 첫 프롬프트에 경로 범위 하드룰이 실려 있었고 ② 스코프 밖 요청은 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` 실행을 안내한다.
+
+세 경우 모두 `next_action` 을 그대로 따른다 (하드룰 4). 이 실패는 `hang_history` 에 `reason: "permission_stall:<사유>"` 로 기록되므로, 반복 호출하면 `stall_escalate_threshold` 에서 차단된다.
+
 ## verdict 는 셋이다 — REJECTED 와 ERROR 를 절대 섞지 말 것 (hardrule)
 
 `dispatch_verifier` 의 `verdict` 는 `VERIFIED` / `REJECTED` / `ERROR` 세 값이다.
@@ -320,6 +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>, 세션 내 교정=<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 패치를 남기지 못해도 서브에이전트가
@@ -622,7 +625,11 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
     // 같이 남겨 어느 사본이 몇 개를 읽었는지 바로 대응시킨다.
     logger.debug(`[permission] plugin-own allows: ${pluginOwnPatterns.length}개 ` +
         `(${pluginOwnPatterns.join(", ")}) directory=${directory}`);
+    // 두 줄의 개수가 다른 것은 정상이다 — 아래가 위를 **포함**한다. 내역을
+    // (plugin-own N + opencode.json M) 로 분해해 두지 않으면 "5개 / 7개" 두 줄이
+    // 같은 목록의 불일치처럼 읽힌다 (GitHub #12 부수 관찰).
     logger.debug(`[permission] configured external_directory allows: ${configuredAllowPatterns.length}개` +
+        ` (= plugin-own ${pluginOwnPatterns.length} + opencode.json ${configuredAllowPatterns.length - pluginOwnPatterns.length})` +
         (configuredAllowPatterns.length ? ` (${configuredAllowPatterns.slice(0, 3).join(", ")}…)` : "") +
         ` directory=${directory}`);
     // 툴 실행 신호는 레지스트리(`registry.activeToolCalls` / `lastToolExecuteAt`)에
@@ -788,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;
         },
     });
@@ -799,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,
@@ -1882,6 +1923,11 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                     const lastVerdictStreak = lastVerdictStreakR.exitCode === 0
                         ? (parseInt(lastVerdictStreakR.stdout?.toString().trim() || "0", 10) || 0)
                         : 0;
+                    // 직전 attempt 가 워크스페이스 밖 경로 요청으로 자동 거부·abort 된 경우,
+                    // 새 세션 프롬프트에 "무엇이 막혔고 어디까지가 허용인지" 를 주입한다.
+                    // 이것이 없으면 재디스패치는 같은 경로를 다시 요청해 같은 지점에서 죽는다
+                    // — 서브세션은 이전 세션의 대화 이력을 이어받지 못하기 때문이다 (GitHub #12).
+                    let permissionBlockNote = null;
                     const buildPromptText = (attemptNum, priorSessionIds) => {
                         const base = [
                             `Working directory (ABSOLUTE): ${effectiveWorktree}`,
@@ -1891,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 를 쓰거나 고치지 않는다. 선언과 실제 작업이 맞지 않으면 임의로 면제·추가하지 말고 최종 출력에 적어 보고한다.`);
@@ -1901,6 +1951,9 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                         if (lastVerdictReason) {
                             base.push(`\n=== 이전 검증 실패 사유 (재작업 시 참고) ===`, `직전 attempt 가 makdoong2-verifier 에 의해 REJECTED 되었다. 같은 사유로 다시 실패하면 무한 루프로 판정된다 (동일 사유 ${lastVerdictStreak}회 연속 감지 중, 5회 도달 시 자동 중단).`, `아래 verifier 판정 원문을 읽고 지적된 규칙 위반·마커 누락·검증 실패 항목을 최우선으로 해결하시오. 동일한 접근을 반복하지 말고 finding 에 지적된 대안 (파일 재분할·마커 재기록·형식 수정 등) 을 시도하시오.`, `--- verifier 판정 원문 (앞 4000자) ---`, lastVerdictReason, `--- 원문 끝 ---`);
                         }
+                        if (permissionBlockNote) {
+                            base.push(`\n=== 경로 접근 차단 — 직전 세션이 이 사유로 즉시 중단됐다 (반복 금지) ===`, permissionBlockNote);
+                        }
                         if (args.context)
                             base.push(args.context);
                         return base.join("\n");
@@ -2207,6 +2260,103 @@ export const Makdoong2TeamPlugin = async ({ $, client, directory, worktree }) =>
                                 });
                                 continue;
                             }
+                            // ── permission_stall: 하드 실패가 아니라 회복 가능한 차단이다 ──────────
+                            //
+                            // 종전에는 여기서 곧장 최종 결과로 떨어졌다. `attempts` 가 1에서 늘지
+                            // 않았고, `next_action` 도 비어 있었다 — 그 공백을 team-leader 가
+                            // "사용자 승인 대기" 로 채워 넣어, 헤드리스 서브세션에는 존재하지도 않는
+                            // 승인 행위를 사용자에게 요구하며 워크플로가 멈췄다 (GitHub #12).
+                            //
+                            // `outside_allowed_roots` 만 재디스패치한다. 이 사유는 "경로를 좁히면
+                            // 끝날 일" 이라 새 세션에 허용 범위를 알려주면 진행할 수 있다. 나머지
+                            // 둘은 경로 문제가 아니다 — `non_external_permission` 은 에이전트
+                            // frontmatter 설정, `tool_call_stall` 은 설치 상태의 문제라 같은 조건의
+                            // 재시도가 결과를 바꾸지 못한다.
+                            if (outcome.kind === "permission_stall") {
+                                const blockedPatterns = outcome.permissionPatterns ?? [];
+                                const recoverable = outcome.permissionReason === "outside_allowed_roots";
+                                const currentMaxAttempts = maxAttemptsForCurrentModel();
+                                promptPromise.catch(() => { });
+                                if (recoverable && attempt < currentMaxAttempts) {
+                                    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 기준 상대 패턴을 쓰는 것이 가장 안전하다.`,
+                                        `  - 저장소 밖을 훑어야만 하는 작업이라면 수행하지 말고, 그 사실과 이유를 최종 출력에 적어 보고하라.`,
+                                        `  - 임시 파일은 /tmp 가 아니라 ${effectiveWorktree}/.makdoong2-team/${args.issue}/tmp/ 에 만든다.`,
+                                    ].join("\n");
+                                    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"} ` +
+                                        `corrections=${corrections} — redispatching with allowed-scope guidance injected`);
+                                    continue;
+                                }
+                                // 예산 소진(또는 회복 불가 사유). hang_history 는 dispatch_stage 호출
+                                // 사이를 넘어 살아남는 유일한 카운터다 — 여기에 남기지 않으면 리더가
+                                // 같은 조건으로 무한히 재호출해도 cross-call 상한에 영영 닿지 않는다.
+                                const stallEntry = JSON.stringify({
+                                    attempt,
+                                    at: new Date().toISOString(),
+                                    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,
+                                    model: activeModelFull,
+                                    fallback_depth: activeFallbackDepth,
+                                    final: true,
+                                });
+                                const stallJqPath = stageJqPath(args.target_stage) + ".hang_history";
+                                const stallAppend = await $ `bash ${SCRIPTS_DIR}/state.sh append ${args.issue} ${stallJqPath} ${stallEntry}`
+                                    .cwd(effectiveWorktree).quiet().nothrow();
+                                logger.error(`[dispatch_stage] PERMISSION_STALL_FINAL session=${subSessionID} stage=${args.target_stage} ` +
+                                    `attempts=${attempt} reason=${outcome.permissionReason} recoverable=${recoverable} ` +
+                                    `patterns=${JSON.stringify(blockedPatterns)} scope=${outcome.permissionScope ?? "unknown"} ` +
+                                    `hang_history append exit=${stallAppend.exitCode}`);
+                                finalResultJson = JSON.stringify({
+                                    ok: false,
+                                    stage: args.target_stage,
+                                    agent: spec.id,
+                                    model: activeModelFull,
+                                    session_id: subSessionID,
+                                    previous_session_ids: attemptSessionIds.slice(0, -1),
+                                    attempts: attempt,
+                                    fallback_depth: activeFallbackDepth,
+                                    output: finalLegacy.text.slice(0, 8000),
+                                    outcome_kind: "permission_stall",
+                                    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,
+                                    // 승인 대기가 아니라 "이미 종료됨" 이다. 이 두 필드를 읽고 보고한다.
+                                    awaiting_user_approval: false,
+                                    session_aborted: true,
+                                    stage_done: null,
+                                    completion: "incomplete",
+                                    polls: outcome.polls,
+                                    elapsed_ms: outcome.elapsedMs,
+                                    next_action: finalLegacy.nextAction,
+                                    reason: finalLegacy.text,
+                                });
+                                continue;
+                            }
                             if (outcome.kind === "empty") {
                                 const isPreambleOnly = outcome.reason === "preamble_only";
                                 logger.debug(`[dispatch_stage] empty output detected — sending one-time ${isPreambleOnly ? "action" : "summary"} re-prompt: ` +

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";
@@ -99,6 +114,8 @@ export type PollOutcome = {
     permissionType?: string;
     permissionPatterns?: string[];
     permissionReason?: PermissionStallReason;
+    permissionScope?: string;
+    permissionCorrections?: number;
 } | {
     kind: "session_gone";
     polls: number;
@@ -112,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;
@@ -128,6 +147,44 @@ export interface PollOptions {
     nudgeAtFraction?: number;
     onNudge?: (sessionId: string, elapsedMs: number) => Promise<void>;
 }
+/**
+ * 자동 승인 범위의 루트 = worktree 의 **직계 부모 한 단계**.
+ *
+ * 형제(메인 저장소·다른 worktree)까지는 열고 그 위는 닫는다. 조부모를 열면
+ * `/root/IdeaProjects/*` 하나가 모든 프로젝트 그룹을, 극단적으로 `/` 가 파일시스템
+ * 전체를 자동 승인 대상으로 만든다 — 이 함수의 반환값은 사람의 확인 없이 `allow`
+ * 로 응답되므로 그 확장은 승인 게이트 자체를 무력화한다 (GitHub #12 의 제안 1을
+ * 채택하지 않은 이유). 조부모 요청은 **차단이 정답**이고, 회복은 범위를 넓히는 것이
+ * 아니라 서브에이전트에게 허용 범위를 알려주고 재시도시키는 쪽(dispatch_stage 의
+ * 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;
 /**
@@ -148,6 +205,14 @@ export declare function isMatchedByConfiguredRules(patterns: string[], allowedGl
  * distinction so `dispatch_stage` can return `ok:false` on empty output.
  */
 export declare function pollSubSession(client: PollClientLike, sessionId: string, options?: PollOptions): Promise<PollOutcome>;
+/**
+ * `permission_stall` 보고 시 team-leader 가 그대로 따라야 하는 지시.
+ *
+ * dispatch_stage 응답의 `next_action` 으로 실린다. 하드룰 4("next_action 을 그대로
+ * 따른다")가 적용되는 자리이며, 문구를 바꿀 때는 agents/makdoong2-team-leader.md 의
+ * permission_stall 하드룰과 함께 고친다 (test/poll-permission-scope.test.ts 가 강제).
+ */
+export declare const PERMISSION_STALL_NEXT_ACTION: string;
 /**
  * Convert a {@link PollOutcome} into a display string plus a boolean success
  * flag. Used by callers that need a single string for downstream serialization
@@ -157,4 +222,5 @@ export declare function pollSubSession(client: PollClientLike, sessionId: string
 export declare function pollOutcomeToLegacy(outcome: PollOutcome): {
     text: string;
     success: boolean;
+    nextAction?: string;
 };

package/dist/poll-sub-session.js

@@ -87,6 +87,71 @@ function posixDirname(p) {
     const idx = trimmed.lastIndexOf("/");
     return idx <= 0 ? "/" : trimmed.slice(0, idx);
 }
+/**
+ * 자동 승인 범위의 루트 = worktree 의 **직계 부모 한 단계**.
+ *
+ * 형제(메인 저장소·다른 worktree)까지는 열고 그 위는 닫는다. 조부모를 열면
+ * `/root/IdeaProjects/*` 하나가 모든 프로젝트 그룹을, 극단적으로 `/` 가 파일시스템
+ * 전체를 자동 승인 대상으로 만든다 — 이 함수의 반환값은 사람의 확인 없이 `allow`
+ * 로 응답되므로 그 확장은 승인 게이트 자체를 무력화한다 (GitHub #12 의 제안 1을
+ * 채택하지 않은 이유). 조부모 요청은 **차단이 정답**이고, 회복은 범위를 넓히는 것이
+ * 아니라 서브에이전트에게 허용 범위를 알려주고 재시도시키는 쪽(dispatch_stage 의
+ * permission-block 재디스패치)이 맡는다.
+ */
+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).
@@ -94,7 +159,7 @@ function posixDirname(p) {
 export function isWithinWorktreeScope(patterns, worktree) {
     if (!worktree || patterns.length === 0)
         return false;
-    const scope = posixDirname(worktree);
+    const scope = worktreeAllowedScope(worktree);
     return patterns.every(pat => {
         const base = pat.replace(/\/?(\*+\/?)+$/, "");
         return base === scope || base.startsWith(scope + "/");
@@ -144,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);
@@ -156,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;
@@ -335,42 +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,
-                    };
+            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 — "툴 호출이 떠 있는데 아무 진전이 없다".
@@ -621,6 +744,21 @@ export async function pollSubSession(client, sessionId, options = {}) {
         transientFailures,
     };
 }
+/**
+ * `permission_stall` 보고 시 team-leader 가 그대로 따라야 하는 지시.
+ *
+ * dispatch_stage 응답의 `next_action` 으로 실린다. 하드룰 4("next_action 을 그대로
+ * 따른다")가 적용되는 자리이며, 문구를 바꿀 때는 agents/makdoong2-team-leader.md 의
+ * permission_stall 하드룰과 함께 고친다 (test/poll-permission-scope.test.ts 가 강제).
+ */
+export const PERMISSION_STALL_NEXT_ACTION = "이 실패는 사용자 승인으로 해소되지 않는다 — 권한 요청은 이미 자동 거부됐고 서브세션도 abort 된 뒤다. " +
+    "헤드리스 서브세션에는 승인을 받을 채널 자체가 없으므로, 사용자에게 '권한을 승인한 뒤 재개해 달라' 고 " +
+    "요청하는 것은 실행 불가능한 지시다. 절대 그렇게 보고하지 말 것. " +
+    "output 원문과 permission_patterns / permission_scope 를 그대로 인용해 '차단되어 종료됨' 으로 보고하고, " +
+    "permission_reason 별 처방을 따르라: outside_allowed_roots → 자동 재디스패치(허용 범위 안내 주입)가 이미 " +
+    "소진된 상태다. 같은 인자로 재호출하지 말고 차단된 경로와 허용 범위를 보고한 뒤 사용자 지시를 기다린다. " +
+    "non_external_permission → 해당 에이전트 frontmatter 의 permission 블록 문제다 (정식 키는 `edit`). " +
+    "tool_call_stall → `npx makdoong2-team doctor` 로 설치 상태를 점검한다.";
 /**
  * Convert a {@link PollOutcome} into a display string plus a boolean success
  * flag. Used by callers that need a single string for downstream serialization
@@ -654,11 +792,33 @@ export function pollOutcomeToLegacy(outcome) {
                 : "an unidentified permission request";
             const remedy = (() => {
                 switch (outcome.permissionReason) {
-                    case "outside_allowed_roots":
-                        return "워크스페이스 밖 경로 접근이라 차단됐다. " +
-                            "임시 파일이 필요하면 `/tmp` 이 아니라 worktree 안의 " +
+                    case "outside_allowed_roots": {
+                        // 종전에는 처방이 "임시 파일은 worktree 안에 써라" 하나뿐이었다. 정작
+                        // 실제로 막힌 것은 read-only `glob` 이었고(GitHub #12), 그 안내는 상황과
+                        // 무관해 아무 조치도 유도하지 못했다. 무엇이 막혔는지(patterns)와
+                        // **어디까지가 허용인지**(scope)를 먼저 못 박고, 조회/쓰기 두 갈래로 나눈다.
+                        const blocked = outcome.permissionPatterns?.length
+                            ? JSON.stringify(outcome.permissionPatterns)
+                            : "(패턴 미상)";
+                        const scope = outcome.permissionScope
+                            ? `\`${outcome.permissionScope}/\` 이하 (worktree 와 그 형제 디렉토리)`
+                            : "worktree 와 그 형제 디렉토리";
+                        // in-place 교정이 있었다면 abort 는 "안내를 받고도 같은 범위를 다시
+                        // 요청했다" 는 뜻이다. 그 횟수를 보고에 싣지 않으면 리더는 첫 차단과
+                        // 구분할 수 없어 같은 안내를 한 번 더 주입하는 데 그친다.
+                        const corrections = outcome.permissionCorrections ?? 0;
+                        const correctionNote = corrections > 0
+                            ? `세션 안에서 ${corrections}회 경로 교정 안내(피드백 거부)를 받고도 같은 범위를 다시 요청해 abort 됐다. `
+                            : "";
+                        return `워크스페이스 밖 경로 접근이라 차단됐다 — 요청 ${blocked}, 자동 승인 범위 ${scope}. ${correctionNote}` +
+                            "그 위(조부모 이상)는 설계상 열지 않는다: 한 번 열면 형제 프로젝트 전체가 사람의 확인 없이 승인 대상이 된다. " +
+                            "조치는 둘 중 하나다. " +
+                            "(1) 조회(glob/grep/read/list)라면 경로 인자를 허용 범위 안으로 좁혀라 — 경로 인자 없이 cwd 기준 상대 패턴을 쓰는 것이 가장 안전하다. " +
+                            "저장소 밖을 훑어야만 하는 작업이면 수행하지 말고 그 사실을 최종 출력에 적어 보고하라. " +
+                            "(2) 임시 파일이 필요하면 `/tmp` 이 아니라 worktree 안의 " +
                             "`.makdoong2-team/<이슈키>/tmp/` 에 만들어라 — 그 경로는 cwd 안이라 승인이 필요 없고, " +
                             "git exclude 와 worktree 동기화 대상이다. `/tmp` 에 쓴 것은 동기화도 커밋도 되지 않아 조용히 사라진다.";
+                    }
                     case "non_external_permission":
                         return "external_directory 가 아닌 권한 요청이 서브에이전트에 도달했다 — 경로 문제가 아니라 " +
                             "에이전트 permission 설정 문제다. 해당 에이전트의 frontmatter `permission:` 블록을 점검하라 " +
@@ -675,6 +835,11 @@ export function pollOutcomeToLegacy(outcome) {
                     `aborted after ${outcome.stalledMs}ms. reason=${outcome.permissionReason ?? "unknown"})\n` +
                     `→ ${remedy}`,
                 success: false,
+                // 이 한 줄이 없어서 team-leader 가 "이미 abort 됨" 을 "승인 대기 중" 으로
+                // 재해석해, 존재하지 않는 승인 행위를 사용자에게 요구하며 워크플로를
+                // 세웠다 (GitHub #12). 헤드리스 서브세션에는 승인 채널이 없다 — 그래서
+                // 훅이 대신 거부한 것이고, 사용자가 할 수 있는 일은 애초에 없다.
+                nextAction: PERMISSION_STALL_NEXT_ACTION,
             };
         }
         case "session_gone":

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.2",
+  "version": "3.0.4",
   "publishConfig": {
     "access": "public"
   },