@kaydash9999/banker-plugins 0.20.2 → 0.20.5

package/codex/transform-matrix.md

@@ -27,7 +27,7 @@ The generator (`banker setup --codex`) applies the rules below for `target: both
 - `visual-ralph` → OMX `$ralph`·`$imagegen`(+`omx imagegen continuation`)·Visual Verdict; Claude은 `ralph`+`visual-verdict`+Stitch/ccg imagegen.
 - `deep-init` → 서브에이전트 Claude=OMC explore/architect/writer, Codex=OMX worker/explore(부재 시 직접 수행). 순수 fs+doc.
 - `deep-research` → Claude 번들 워크플로/`WebSearch`, Codex OMX `autoresearch`/`best-practice-research`.
-- `ralph-qa` → 백본은 세션 모델로 띄운 검토 에이전트 3개 이상이다(Claude=Agent 의 `Plan` 을 `model` 없이, Codex=`spawn_agent` 를 역할 없이, 저자 대화를 넘기지 않고). 두 런타임 모두 Bash 가 있어 읽기 전용은 지시로 선다. 외부 좌석은 `--codex`·`--gemini`·`--opencode` 를 줄 때만 앉고, 저자 계열은 앉지 않는다(Codex 런타임의 `--codex` 는 자기 자신이라 부적격). Codex 의 `workspace-write` 샌드박스는 HOME 쓰기를 막아 gemini, opencode 가 시작부터 실패하고, Linux 에서는 페이로드 기준 폴더(`$XDG_RUNTIME_DIR`, `~/.cache`)도 막는다. 그래서 외부 좌석 전송의 명령 전부(폴더, 페이로드, 사본, 좌석, 정리)를 승인을 받아 샌드박스 밖에서 실행한다.
+- `ralph-qa` → 백본은 세션 모델로 띄운 검토 에이전트 3개 이상이다(Claude=Agent 의 `Plan` 을 `model` 없이, Codex=`spawn_agent` 를 역할 없이, 저자 대화를 넘기지 않고). 두 런타임 모두 Bash 가 있어 읽기 전용은 지시로 선다. 외부 좌석은 `--codex`·`--gemini`·`--opencode` 를 줄 때만 앉고, 저자 계열은 앉지 않는다(Codex 런타임의 `--codex` 는 자기 자신이라 부적격). Codex 의 `workspace-write` 샌드박스는 HOME 쓰기를 막아 gemini, opencode 가 시작부터 실패하고, Linux 에서는 페이로드 기준 폴더(`$XDG_RUNTIME_DIR`, `~/.cache`)도 막는다. 그래서 외부 좌석 전송의 실행기 명령 전부(`seat-run.mjs` 의 init, untracked, prepare, check, send, cleanup, put)를 승인을 받아 샌드박스 밖에서 실행한다.
 - `lineage` → 기본 흐름의 검토자는 세션 모델이다(Claude=Agent 의 `Plan` 을 `model` 없이, Codex=`spawn_agent` 를 역할 없이, 저자 대화를 넘기지 않고). 띄울 수 없으면 세션이 파트를 직접 검토한다. Codex 검토자에게는 파일 읽기 도구가 없어 파트 파일을 읽는 셸 명령만 쓰게 한다. `workspace-write` 샌드박스에서는 `~/.cache` 에 쓸 수 없어 이번 실행의 검토 결정을 캐시에 쓰지 못한다(WARN). 앞선 실행이 남긴 결정은 읽는다. 읽는 기록은 Claude Code 형식뿐이라 Codex 에서는 Claude Code 기록을 내보낼 때만 쓴다. `--rulebase` 는 모델 호출 없이 양쪽 같다.
 - `smart-compact` → Claude statusLine `context_window.used_percentage`+hook; Codex 신호 미확인 시 휴리스틱 폴백. TUI 3단(`/copy`·`/compact`·paste)은 유저.
 - `curation` → 런타임 무관(외부 의존 0, 양쪽 동일).

package/commands/setup.md

@@ -10,6 +10,29 @@ banker 플러그인이 제공하는 설치 스킬들을 **multi-select**로 골
 
 ## 절차
 
+0. **네트워크 확인**: 항목을 고르기 전에 원천에 닿는지 한 번 본다(curl 은 10초, npm 은 15초 안). 결과는 알림으로만 쓰고, 이것만으로 항목을 건너뛰지 않는다.
+   ```bash
+   [ "${CODEX_SANDBOX_NETWORK_DISABLED:-}" = 1 ] && echo "Codex sandbox 가 네트워크를 막음(아래 실패는 오프라인이 아님)"
+   in15() { "$@" & p=$!; ( sleep 15 && kill "$p" ) > /dev/null 2>&1 & k=$!; wait "$p" 2>/dev/null; r=$?; kill "$k" 2>/dev/null; wait "$k" 2>/dev/null; [ "$r" = 143 ] && echo "15초 안에 끝나지 않아 멈춤(패킷을 버리는 망일 수 있음)"; return "$r"; }
+   if command -v npm >/dev/null; then in15 sh -c 'cd ~ && exec npm ping --fetch-retries=0 --fetch-timeout=10000 --no-update-notifier'; else echo "npm 없음(확인하지 못함)"; fi
+   curl --ssl-no-revoke -sSI -o /dev/null --connect-timeout 5 --max-time 10 https://github.com
+   ```
+   - `curl -sSI` 는 머리만 받는다. 확인 줄은 `--ssl-no-revoke` 를 준다. Windows 의 Git Bash curl 도 Schannel 이라, 폐지 목록 서버에 닿지 못하는 망에서 폐지 확인이 실패하면 종료 60 이다(Windows 박스 실측). 다른 curl 은 이 깃발을 받고 무시한다(macOS curl 8.7.1, Rocky 8.10 curl 7.61.1 실측).
+   - 둘 다 실패하면 "네트워크가 없거나 막힌 것으로 보임. 항목마다 자기 원천을 다시 확인하고, 닿지 않는 원천에서 받는 단계는 하지 않음" 으로 먼저 알린다.
+   - 항목을 건너뛸지는 각 스킬의 0단계가 그 스킬의 원천으로 정한다. 사내 미러만 열린 망(`npm ping` 에 답하지 않는 npm 미러, PyPI 미러)에서도 그 원천을 쓰는 항목은 진행된다. 닿지 않는 원천에서 받는 단계만 "오프라인이라 설치하지 않음(필요한 것: <항목>)" 으로 보고된다.
+   - `npm` 이 아직 없으면(새 PC) npm 쪽은 오프라인이 아니라 확인하지 못한 것이다. `setup-node` 가 npm 을 깐 뒤 각 스킬의 0단계가 다시 확인한다.
+   - `npm ping` 은 홈 폴더에서 부른다. 지금 폴더에 있는 프로젝트의 `.npmrc` 가 정한 레지스트리와 토큰을 따르지 않게 하려는 것이다.
+   - `npm ping` 은 15초 감시(`in15`) 안에서 부른다. 패킷을 버리는 망에서 npm 은 연결에 시간 제한을 두지 않아(`--fetch-timeout` 은 받는 중의 쉼만 잰다) OS 의 연결 재시도가 끝날 때까지 기다린다(Rocky 8.10 실측 130초). 15초 안에 끝나지 않으면 `15초 안에 끝나지 않아 멈춤(패킷을 버리는 망일 수 있음)` 과 종료 143 이다. `--no-update-notifier` 는 npm 이 제 판을 묻는 요청을 하나 더 내지 않게 한다.
+   - OS 패키지 관리자(dnf, apt, brew, winget)만 쓰는 단계는 자기 설정의 미러를 쓰므로 이 확인과 관계없이 각 스킬의 규칙대로 시도한다.
+     - 패킷을 버리거나 답하지 않는 망에서 dnf 는 저장소마다 약 2분(SYN 을 버리는 망 실측 121초), apt 는 원천마다 약 4분(답하지 않는 원천 실측 247초) 기다린 뒤 실패로 끝난다. 시간 제한은 관리자 설정을 따르므로 이 스킬이 바꾸지 않는다.
+     - `apt-get update` 는 받지 못해도 종료 0 이다. 출력의 `W: Failed to fetch` 가 있으면 그 단계를 실패로 보고한다.
+   - 내려받기가 없는 항목(`setup-omc-hud`)과 이미 설치된 것의 확인은 그대로 진행한다.
+   - Windows PowerShell 에서는 `curl.exe --ssl-no-revoke -sSI -o NUL --connect-timeout 5 --max-time 10 https://github.com` 의 `$LASTEXITCODE` 로 본다. `curl.exe` 는 Windows 시스템 프록시를 따르지 않고 `HTTPS_PROXY` 만 따른다. `--ssl-no-revoke` 는 폐지 목록 서버에 닿지 못하는 망에서 Schannel 의 폐지 확인 실패를 오프라인으로 읽지 않게 한다. 닿는지만 보고 받은 내용은 쓰지 않으므로 이 확인에만 준다. `curl.exe` 가 없으면 `$LASTEXITCODE` 에 앞 명령의 값이 남으므로 `Get-Command curl.exe -ErrorAction SilentlyContinue` 로 먼저 보고, 없으면 확인하지 못한 것으로 적는다. `npm ping` 은 `Push-Location ~; npm ping --fetch-retries=0 --fetch-timeout=10000 --no-update-notifier; Pop-Location` 처럼 홈에서 부르고 돌아온다(돌아오지 않으면 뒤 단계가 프로젝트가 아니라 홈에서 돈다). PowerShell 에는 15초 감시를 두지 않는다(Windows 의 연결 시간 제한은 약 21초로 알려져 있다. 미실측).
+   - Codex sandbox 가 네트워크를 막는 모드(기본 `workspace-write`, `read-only`)에서는 `CODEX_SANDBOX_NETWORK_DISABLED=1` 이 서고 확인이 모두 실패한다(curl 종료 7, npm `EPERM`). 블록의 첫 줄이 그렇다고 알린다. 그때는 '오프라인' 이 아니라 'sandbox 가 네트워크를 막음' 으로 보고하고, 승인을 받아 sandbox 밖에서 확인부터 다시 한다. Claude Code sandbox 안(`SANDBOX_RUNTIME=1`)에서는 허용 목록 밖 주소를 sandbox 프록시가 막는다. Windows PowerShell 에서는 `$env:CODEX_SANDBOX_NETWORK_DISABLED -eq '1'` 로 본다.
+   - 확인이 실패하면 보고에 그 명령, 종료 코드, stderr 첫 줄을 붙인다(예: `npm error code ETIMEDOUT`, `curl: (28) ...`). 원인을 '오프라인' 하나로 짐작하지 않는다.
+   - curl 의 종료 60(인증서 검증 실패)도 오프라인이 아니다. 망은 열려 있고, TLS 를 가로채는 사내 프록시의 인증서를 OS 가 믿지 않는 것이다. '인증서 문제로 설치하지 않음' 으로 보고한다.
+   - curl 은 닿는데 npm 만 인증서 오류(`UNABLE_TO_VERIFY_LEAF_SIGNATURE`, `SELF_SIGNED_CERT_IN_CHAIN`, `UNABLE_TO_GET_ISSUER_CERT_LOCALLY`)로 실패하면 망은 열려 있고 npm 이 사내 인증서를 믿지 않는 것이다(npm 은 OS 인증서 저장소를 쓰지 않는다). '인증서 문제로 설치하지 않음' 으로 보고하고 `NODE_EXTRA_CA_CERTS=<사내 CA 파일>` 을 안내한다. Node 24 는 `NODE_OPTIONS=--use-system-ca` 도 된다.
+   - 이 실행에서 부르는 스킬의 0단계는 /banker:setup 0단계와 앞 스킬이 이미 돌린 같은 확인 줄(같은 명령과 같은 주소)의 결과를 쓰고 다시 돌리지 않는다. 처음 보는 원천만 새로 본다. 결과는 이 실행 안에서만 쓴다(그 사이 망이 바뀌면 옛 결과일 수 있다). 막힌 망에서 항목마다 같은 확인을 다시 기다리지 않게 하려는 것이다.
 1. **선택 받기**: `$ARGUMENTS` 에 컴포넌트명이 명시돼 있으면 그것만 실행(질문 생략).
    비어 있으면 아래를 `AskUserQuestion`(**multiSelect: true**)으로 제시한다(**Codex 런타임엔 AskUserQuestion 이 없으므로 목록을 제시하고 설치할 항목을 사용자에게 물어 받는다**). 항목은 **계층/의존 순서**로 묶여 있으니, 뒤 계층을 고르면 앞 계층 전제를 먼저 채운다:
    - 질문 하나에 선택지는 4개까지다. 5개 이상인 묶음은 두 질문으로 나눈다.

package/hooks/progress.mjs

@@ -122,11 +122,14 @@ const looseStep = () => ({ key: 'loose', title: '작업 목록 밖의 작업', .
 // list last came from.
 // `plan` is the plan last read from `planPath`, `planShut` whether the whole plan is folded and
 // `planOpen` the ids of its nodes unfolded. `touch` counts the calls that touched a plan file and
-// `taken` is the touch the plan came from, to tell a read that a newer one overtook. `followed` is the step in
+// `taken` is the newest touch whose read was taken in, to tell a read that a newer one overtook (a weak plan's touch does
+// not count). `shown` is the touch, or the read again's count of touches, that the words on the pane came from: a later
+// read of the file shown that began before them does not take their place; `shownOrder` is the order a read again of
+// theirs began in (0 for a touch's read), so of two begun after the same touches the later one stays. `followed` is the step in
 // progress the pane last asked to bring into view.
 export const freshState = () => ({ turns: [], tasks: new Map(), todos: null, loose: looseStep(), open: new Set(), selected: null, seq: 0, rev: 0,
   order: 0, marks: new Map(), listAt: 0, plan: null, planPath: null, planShut: false, planOpen: new Set(), touch: 0, taken: 0,
-  followed: null });
+  shown: 0, shownOrder: 0, followed: null, reads: [], base: null, folded: 0 });
 
 const tail = (path) => String(path).split(/[\\/]/).filter(Boolean).slice(-2).join('/');
 const seconds = (ms) => {
@@ -262,33 +265,51 @@ function stamp(t, status, now) {
 
 // A list longer than the pane holds loses its oldest finished item first, else its oldest.
 const overflow = (items) => items.find((t) => t.status === 'completed') ?? items[0];
+// A list cut to `max` items as overflow would cut it one by one, in one pass: the oldest finished ones go first, then
+// the oldest.
+function trimList(items, max) {
+  let extra = items.length - max;
+  if (extra <= 0) return items;
+  const left = items.filter((t) => t.status !== 'completed' || extra-- <= 0);
+  return left.slice(left.length - max);
+}
 
 // One item of a TodoWrite list: while its text stays it is the same step (the first unused one of
 // that text), with its key, calls and times.
 function todoItem(s, before, d, now) {
-  const t = before.get(d.content)?.shift() ?? { key: `d-${++s.seq}`, description: d.content, ...tally() };
+  const words = kept(d.content);
+  const t = before.get(words)?.shift() ?? { key: `d-${++s.seq}`, description: words, ...tally() };
   t.title = clip(d.content, 60);
-  t.activeForm = d.activeForm;
+  t.activeForm = kept(d.activeForm);
   stamp(t, d.status, now);
   return t;
 }
 
+// A task's or an item's words as the state keeps them: a string cut to what any description reads of it (clip reads
+// 4n + 1024 characters), anything else as it came.
+const MAX_WORDS = 4096;
+const kept = (v) => (typeof v === 'string' ? v.slice(0, MAX_WORDS) : v);
+
 // TodoWrite sends the whole list each time. A subagent keeps a list of its own, not the session's.
 function writeTodos(s, e, now) {
   if (e.agentId || !Array.isArray(e.todos)) return;
   const before = new Map();
   for (const t of s.todos ?? []) before.set(t.description, [...(before.get(t.description) ?? []), t]);
-  s.todos = e.todos.map((d) => todoItem(s, before, d, now));
-  while (s.todos.length > MAX_STEPS) s.todos.splice(s.todos.indexOf(overflow(s.todos)), 1);
+  s.todos = trimList(e.todos.map((d) => todoItem(s, before, d, now)), MAX_STEPS);
 }
 
+// A task's key on the pane: `k-` and its id where the id is a plain one (the store hands out numbers), else its first
+// 1,024 characters as code points, so ids that differ there never share a key (longer ones alike that far do) and none
+// holds what the engine drops a Box key for (a control character, more than 10,000 characters).
+const taskKey = (id) => (/^[\w.-]{1,64}$/.test(id) ? `k-${id}` : `k~${[...id.slice(0, 1024)].map((c) => c.codePointAt(0).toString(36)).join('.')}`);
+
 // Adds a task or brings it up to date; a task keeps its key, calls and times. One known only by
 // its id is named by it until a TaskGet or a TaskList says more.
 function putTask(s, t, now) {
-  const held = s.tasks.get(t.id) ?? { key: `k-${t.id}`, id: t.id, title: `작업 #${t.id}`, description: '', ...tally() };
+  const held = s.tasks.get(t.id) ?? { key: taskKey(t.id), id: t.id, title: clip(`작업 #${t.id}`, 60), description: '', ...tally() };
   const title = clip(t.subject, 60);
   if (title) held.title = title;
-  for (const k of ['description', 'activeForm']) if (t[k] !== undefined) held[k] = t[k];
+  for (const k of ['description', 'activeForm']) if (t[k] !== undefined) held[k] = kept(t[k]);
   if (t.status !== undefined) stamp(held, t.status, now);
   s.tasks.set(t.id, held);
   while (s.tasks.size > MAX_STEPS) s.tasks.delete(overflow([...s.tasks.values()]).id);
@@ -297,15 +318,29 @@ function putTask(s, t, now) {
 // The marks of a task id, made on first use. They live in the state, not on the task, so a task deleted, or not
 // created yet, keeps them: `changedRev` the change count after its last TaskCreate or TaskUpdate (a delete
 // included), `statusAt` and `status` the order and the status of the last status update begun, `seenAt` the order
-// of the last read taken in.
+// of the last read taken in. Past MAX_MARKS the oldest marks of tasks off the pane go (trimMarks), so reads of ids the
+// store does not have cannot grow them without end.
+const MAX_MARKS = 1000;
+// A task id longer than this is no id the store hands out: a read that misses it leaves no mark.
+const MAX_ID = 64;
 function markOf(s, id) {
   if (!s.marks.has(id)) s.marks.set(id, {});
   return s.marks.get(id);
 }
 
-// Whether a list or a read begun at (since, order) is older than what the pane holds of a task: a list begun after it
-// was taken in (a list names the whole list, so this holds for a task it left out that the pane never held, too), the
-// task changed after it began (a delete too), or a later-begun read already brought it.
+// Drops the oldest marks of tasks off the pane down to MAX_MARKS. It runs once a call is taken in, when every task the
+// pane holds is in place again: a TaskList fills a new list, and a task not moved yet must not count as off the pane.
+function trimMarks(s) {
+  for (const k of s.marks.keys()) {
+    if (s.marks.size <= MAX_MARKS) return;
+    if (!s.tasks.has(k)) s.marks.delete(k);
+  }
+}
+
+// Whether a list or a read begun at (since, order) is older than what the pane holds of a task: a list begun after this
+// one began was already taken in (a list names the whole list, so this holds for a task it left out that the pane never
+// held, too), the task changed after this one began (a delete too), or a later-begun read already brought it. The first
+// takes the order calls began in for the order they read the list in, which holds where a call reads soon after it begins.
 function stale(s, id, since, order) {
   if (order < s.listAt) return true;
   const m = s.marks.get(id);
@@ -389,10 +424,7 @@ function listTasks(s, _e, r, now, { since, order }) {
 function getTask(s, e, r, now, { since, order }) {
   if (stale(s, String(e.taskId), since, order)) return;
   const t = r?.result?.task;
-  if (t === null) {
-    s.tasks.delete(String(e.taskId));
-    markOf(s, String(e.taskId)).seenAt = order;
-  }
+  if (t === null) noTask(s, String(e.taskId), order);
   if (!t) return;
   const id = String(t.id);
   const status = readStatus(s, id, order, t.status);
@@ -401,6 +433,13 @@ function getTask(s, e, r, now, { since, order }) {
   markOf(s, id).seenAt = order;
 }
 
+// The store has no such task: it leaves the pane and the read is marked, unless the id is longer than any the store
+// hands out.
+function noTask(s, id, order) {
+  s.tasks.delete(id);
+  if (id.length <= MAX_ID) markOf(s, id).seenAt = order;
+}
+
 const TASK_NOTES = {
   TaskCreate: createTask,
   TaskUpdate: updateTask,
@@ -422,10 +461,14 @@ const changedId = (e, r) => (e.tool === 'TaskCreate' ? r?.result?.task?.id : e.t
 export function noteTaskTool(s, e, r, now, since = s.rev, order = ++s.order) {
   if (refused(r)) return;
   TASK_NOTES[e.tool]?.(s, e, r, now, { since, order });
-  if (!CHANGES.has(e.tool)) return;
+  if (CHANGES.has(e.tool)) noteChange(s, e, r);
+  trimMarks(s);
+}
+
+// Only a change the pane took in marks the task: one it holds after the change, or a delete. An update of a task the
+// pane does not hold leaves the lists alone (its status still counts, through readStatus).
+function noteChange(s, e, r) {
   s.rev += 1;
-  // Only a change the pane took in marks the task: one it holds after the change, or a delete. An update of a task the
-  // pane does not hold leaves the lists alone (its status still counts, through readStatus).
   const id = changedId(e, r);
   if (id !== undefined && (s.tasks.has(String(id)) || updatedStatus(e, r) === 'deleted')) markOf(s, String(id)).changedRev = s.rev;
 }
@@ -477,11 +520,25 @@ function parsed(path, text) {
 }
 
 // Whether a read may change the plan: a read for a touch newer than the one the plan came from, or a
-// read again of the plan's own file (begun when `since` touches were counted) that no touch taken
-// in the meantime overtook.
-function current(s, path, { touch, since }) {
+// read again of the plan's own file (begun when `since` touches were counted) begun after the words on the pane
+// came in (`shown`), so neither an older touch nor an older read again takes their place.
+function current(s, path, { touch, since, order = 0 }) {
   if (touch !== undefined) return touch > s.taken;
-  return path === s.planPath && s.taken <= since;
+  return path === s.planPath && (s.shown < since || (s.shown === since && order >= (s.shownOrder ?? 0)));
+}
+
+// What a read taken in leaves, and whether its words go on the pane. `taken` makes older touches late (a weak plan's
+// touch does not), `shown` is the touch or the read again's since the words came from: a touch's read of the file
+// shown, begun before the read whose words are shown, leaves them.
+function noteTouch(s, read, moving) {
+  if (read.touch === undefined) {
+    [s.shown, s.shownOrder] = [read.since, read.order ?? 0];
+    return true;
+  }
+  if (!read.weak) s.taken = read.touch;
+  if (!moving && read.touch <= s.shown) return false;
+  [s.shown, s.shownOrder] = [read.touch, 0];
+  return true;
 }
 
 // A file with no steps does not push out a plan that has some, unless the session wrote it itself; a weak plan holds no
@@ -505,20 +562,60 @@ function treeIds(nodes, out = new Set()) {
   return out;
 }
 
+// The plan as reads leave it: the plan, its path, `taken` and `shown` (see freshState), with nothing of the pane.
+const planOf = (s) => ({ plan: s.plan, planPath: s.planPath, taken: s.taken, shown: s.shown, shownOrder: s.shownOrder });
+
+// What one read leaves of a plan state, as takePlan always did when reads landed in the order their touches came.
+function applyRead(st, e) {
+  if (!current(st, e.path, e.read) || keepsOff(st, e.path, e.plan, e.read)) return st;
+  const next = { ...st };
+  if (!noteTouch(next, e.read, e.path !== st.planPath)) return next;
+  return { ...next, planPath: e.path, plan: { ...e.plan, path: e.path } };
+}
+
+// Where a read goes among the touches: a touch's read at its touch, a read again just after the touches counted when
+// it began.
+const placeOf = (read) => (read.touch !== undefined ? read.touch : read.since + 0.5);
+// Reads kept past this wait for a touch whose read never came: that touch then counts as a read of nothing. Each
+// kept read holds a parsed plan, so the bound keeps the worst at about 8 MB.
+const MAX_READS = 16;
+
+// Folds into the base the reads whose earlier touches have all landed, so the base is the plan of those touches in their
+// order; a read again goes in once the touches it began after are in.
+function foldReads(s) {
+  if (s.reads.length > MAX_READS) s.folded = Math.max(s.folded, Math.ceil(placeOf(s.reads[0].read)) - 1);
+  while (s.reads.length) {
+    const { read } = s.reads[0];
+    const ready = read.touch !== undefined ? read.touch === s.folded + 1 : read.since <= s.folded;
+    if (!ready) return;
+    s.base = applyRead(s.base, s.reads.shift());
+    if (read.touch !== undefined) s.folded = read.touch;
+  }
+}
+
 // What a read of a plan file found (`read` is `{ touch }` for a touch's read, `{ since }` for a read
-// again). A file that cannot be read or is no plan leaves the plan as it was. Another plan starts
-// folded; the same plan read again keeps the nodes unfolded that it still holds.
+// again). Reads land in any order: each is kept in its touch's place, and the pane shows the plan the touches
+// would leave in their order, as far as their reads have landed. A file that cannot be read or is no plan leaves
+// the plan as it was. Another plan starts folded; the same plan read again keeps the nodes unfolded that it still holds.
 export function takePlan(s, path, text, read = {}) {
-  if (!current(s, path, read)) return;
-  const plan = parsed(path, text);
-  if (keepsOff(s, path, plan, read)) return;
-  const moving = path !== s.planPath;
-  if (read.touch !== undefined && !read.weak) s.taken = read.touch; // a weak plan does not make an older touch late
+  s.base ??= planOf(s);
+  if (read.touch !== undefined && read.touch <= s.folded) return; // its place went by as a read of nothing (MAX_READS)
+  const entry = { path, plan: parsed(path, text), read };
+  const at = s.reads.findIndex((r) => placeOf(r.read) > placeOf(read));
+  s.reads.splice(at < 0 ? s.reads.length : at, 0, entry);
+  foldReads(s);
+  showPlan(s, s.reads.reduce(applyRead, s.base));
+}
+
+// Puts a plan state on the pane: another plan starts folded, and the same plan keeps the nodes unfolded that it holds.
+function showPlan(s, st) {
+  const moving = st.planPath !== s.planPath;
   if (moving && s.selected === 'plan') s.selected = null;
-  const ids = treeIds(plan.tree);
-  s.planOpen = moving ? new Set() : new Set([...s.planOpen].filter((id) => ids.has(id)));
-  s.planPath = path;
-  s.plan = { ...plan, path };
+  if (st.plan && st.plan !== s.plan) {
+    const ids = treeIds(st.plan.tree);
+    s.planOpen = moving ? new Set() : new Set([...s.planOpen].filter((id) => ids.has(id)));
+  }
+  Object.assign(s, st);
 }
 
 // ── what the pane shows ──────────────────────────────────────────────────────
@@ -551,9 +648,12 @@ function stepState(step, now) {
   const status = statusOf(step);
   const doing = status === 'in_progress' && step.activeForm ? `(${clip(step.activeForm, 40)})` : '';
   const time = Number.isFinite(step.startedAt) ? `, ${seconds((step.endedAt ?? now) - step.startedAt)}` : '';
-  return `${STATUS[status] ?? status}${doing}${time}`;
+  return `${stateName(status)}${doing}${time}`;
 }
 
+// A state's word: the pane's own, else the state cleaned (a name such as `constructor` is no word of the table).
+const stateName = (status) => pick(STATUS, status) ?? clip(status, 20);
+
 function stepWords(step, now) {
   if (step.key === 'idle') return '아직 시작한 작업이 없습니다. 요청을 보내면 여기에 단계가 쌓입니다.';
   const words = step.text !== undefined ? `요청: ${clip(step.text, 160) || '(이어서 진행)'}` : clip(step.description || step.title, 160);
@@ -627,7 +727,7 @@ function stepRow(ui, s, step, act) {
     ? Button({ key: `arrow-${step.key}`, label: isOpen ? '▾' : '▸', plain: true, onPress: () => act.fold(step.key) })
     : Text({ children: [' '] });
   const status = statusOf(step);
-  const state = STATUS[status] ?? status ?? '';
+  const state = stateName(status);
   return Box({ key: `row-${step.key}`, flexDirection: 'row', columnGap: 1, children: [
     arrow,
     Button({ key: step.key, label: room(step.title, act, 2, state), plain: true, onPress: () => act.select(step.key) }),
@@ -901,10 +1001,15 @@ export function progressTurnCompleted(e) {
 
 // The plan file to read again as a turn starts and ends (register.mjs reads it), with the touches
 // counted when the read begins; null without a plan.
+// A read again begins with the touches counted and its place in the order reads begin, so of two begun after the same
+// touches the later one wins, whichever lands last (the file may change between them without a touch: a shell edit).
+export const planTarget = (s) => (s.planPath ? { path: s.planPath, since: s.touch, order: ++s.order } : null);
+export const planRead = (s, target, text) => takePlan(s, target.path, text, { since: target.since, order: target.order });
+
 export function progressPlanTarget() {
-  return ref.s.planPath ? { path: ref.s.planPath, since: ref.s.touch } : null;
+  return planTarget(ref.s);
 }
 
 export function progressPlanRead(target, text) {
-  takePlan(ref.s, target.path, text, { since: target.since });
+  planRead(ref.s, target, text);
 }

package/hooks/register.mjs

@@ -83,6 +83,16 @@ async function voidLateRequest($, late) {
   $.ui.log(late.log);
 }
 
+// Asks the engine to draw the pane again. The engine sends the call on and catches its own failure (2.1.305); an engine
+// that throws instead still runs the hooks beneath, so the session and the turn go on.
+function redraw($) {
+  try {
+    $.ui.invalidate('ui.render');
+  } catch {
+    /* nothing to redraw now; the next event draws the pane */
+  }
+}
+
 export const register = (on) => {
   registerGracefulPause(on);
   registerProgress(on);
@@ -97,7 +107,7 @@ export const register = (on) => {
   on('session.end', async ($, e, next) => {
     pauseReset();
     progressReset();
-    $.ui.invalidate('ui.render'); // the pane shows at once what /clear emptied
+    redraw($); // the pane shows at once what /clear emptied
     return next(e);
   });
 
@@ -105,7 +115,7 @@ export const register = (on) => {
     pauseTurnStarted(e);
     progressTurnStarted(e);
     await rereadPlan($);
-    $.ui.invalidate('ui.render');
+    redraw($);
     return next(e);
   });
 
@@ -114,7 +124,7 @@ export const register = (on) => {
     if (late) await voidLateRequest($, late);
     progressTurnCompleted(e);
     await rereadPlan($);
-    $.ui.invalidate('ui.render');
+    redraw($);
     return next(e);
   });
 };

package/hooks/update-checkin.mjs

@@ -9,7 +9,10 @@
  *  - 미활성(countingActive) 또는 엔드포인트 없음이면 무동작(로그도 건드리지 않는다).
  *  - PII/IP/지속ID 절대 미포함. 페이로드는 {version, os, counts} 세 키뿐(os=플랫폼 계열,
  *    counts=스킬별 x 시간대별 호출수).
- *  - 자체 네트워크 timeout 으로 hang 방지. 어떤 오류도 삼키고 항상 exit 0. 어떤 경로도 reject 안 함.
+ *  - 무활동 10초 timeout 과 요청마다 30초 교환 전체 마감으로 hang 하지 않는다.
+ *  - 응답 본문은 256KiB 까지만 모은다. 넘으면 연결을 끊고 그 응답을 쓰지 않는다.
+ *  - 응답에서 latest 를 얻지 못하면(전송 실패, 차단, 없는 값) 시도 시각(triedAt)만 캐시에 써 하루를 쉰다.
+ *  - 어떤 오류도 삼키고 항상 exit 0. 어떤 경로도 reject 안 함.
  *  - 비-loopback 평문 http 는 전송하지 않는다(https-only). loopback http 만 로컬 테스트 mock 에 허용.
  *  - 함께 시작한 체크인은 같은 줄을 두 번 보내지 않는다(로그 이름 바꾸기는 하나만 성공한다).
  *  - 로그 자리가 FIFO 면 기다리지 않고, 로그나 last-flush 자리가 링크면 링크 너머 파일을 비우거나 덮지 않는다.
@@ -73,7 +76,8 @@ function isLoopback(hostname) {
 }
 
 // 엔드포인트로 JSON POST. 어떤 경로에서도 reject 하지 않고, 전송 시도가 끝나면 응답 본문(문자열)
-// 또는 null 로 resolve 한다. 자체 timeout(NET_TIMEOUT_MS)으로 무응답 엔드포인트에도 hang 하지 않는다.
+// 또는 null 로 resolve 한다. 무활동 timeout(NET_TIMEOUT_MS)과 교환 전체 마감(NET_DEADLINE_MS)으로 무응답
+// 엔드포인트에도 hang 하지 않고, 본문은 MAX_BODY_BYTES 까지만 모은다.
 function post(url, body) {
   return new Promise((resolvePromise) => {
     let done = false;
@@ -124,8 +128,9 @@ function extractLatest(responseBody) {
 
 // 변경-스킬 매니페스트(공개 GitHub raw JSON: {"x.y.z": ["banker:skill", ...]})를 GET 해 객체로 반환한다.
 // update-fetch 의 동일 함수와 self-contained 로 나란히 둔다(훅별 자기완결 관례·isLoopback 도 이미 각자 보유).
-// post() 와 동일한 안전 가드: 비-https 는 loopback 만 허용·3xx no-op·자체 timeout·malformed→null. 어떤
-// 실패에도 reject 하지 않고 null 로 resolve 한다(개인화는 best-effort). 비배열 객체만 반환.
+// post() 와 동일한 안전 가드: 비-https 는 loopback 만 허용·3xx no-op·무활동 timeout 과 교환 전체 마감·
+// 본문 256KiB 상한·malformed→null. 어떤 실패에도 reject 하지 않고 null 로 resolve 한다(개인화는 best-effort).
+// 비배열 객체만 반환.
 function fetchSkillChangesMap(url) {
   return new Promise((resolvePromise) => {
     let done = false;
@@ -228,17 +233,20 @@ function dropOldClaims(now = Date.now()) {
   }
 }
 
-// 응답의 latest 로 공유 update-check 캐시를 갱신(알림 겸함). 없으면 캐시 미변경.
+// 응답의 latest 로 공유 update-check 캐시를 갱신(알림 겸함). 없으면 시도 시각(triedAt)만 쓴다.
 // update-fetch 처럼 notified:null 재무장을 하지 않아도 등가다: dedupe 판정이 notified===latest
 // (update-notify)라 전진 버전에서 구 notified 는 항상 신 latest 와 달라 재고지가 정상 발화하고,
 // count-default-on 은 이 훅만·npm 배포는 update-fetch 만 써 같은 캐시를 겹쳐 쓰지 않는다.
 async function refreshUpdateCache(responseBody) {
   const latest = extractLatest(responseBody);
-  if (!latest) return;
+  if (!latest) { // 시도 시각만 남겨 update-notify 가 하루 동안 다시 띄우지 않게 한다(네트워크 없는 곳의 세션마다 시도).
+    try { writeUpdateCache({ triedAt: Date.now() }); } catch { /* best-effort */ }
+    return;
+  }
   // 개인화용: 변경-스킬 매니페스트를 best-effort GET(실패 시 changedSkills 생략, 기존 값 보존).
   const changesUrl = process.env.BANKER_SKILL_CHANGES_URL || SKILL_CHANGES_URL; // 테스트 주입용 override.
   const map = await fetchSkillChangesMap(changesUrl);
-  const patch = { latest, checkedAt: Date.now() };
+  const patch = { latest, checkedAt: Date.now(), triedAt: null }; // 성공: 남은 실패 시도 시각은 비움
   if (map) patch.changedSkills = changedSkillsBetween(map, installedVersion(), latest);
   try { writeUpdateCache(patch); } catch { /* best-effort */ }
 }

package/hooks/update-fetch.mjs

@@ -5,10 +5,13 @@
  * 자체는 캐시만 읽는 별도 훅이 담당한다(이 파일은 네트워크 조회만 - 화면 출력 없음).
  *
  * fail-closed 규약(각 항목은 update-fetch.test.mjs 가 검증한다):
- *  - throttle(UPDATE_THROTTLE_MS) 미경과면 무동작(캐시가 없으면 진행).
+ *  - 마지막 성공(checkedAt)이나 마지막 실패한 시도(triedAt)에서 하루가 지나지 않았으면 무동작(updateCheckDue).
  *  - 비-https 는 loopback(localhost/127.0.0.1/::1) 에서만 http 허용, 그 외 비-https 는 거부.
  *  - 3xx 리다이렉트는 따라가지 않고 no-op.
- *  - 응답 JSON 에서 version 문자열만 방어 추출 - 없거나 비문자열이면 무동작(캐시 미기록).
+ *  - 무활동 10초 timeout 과 요청마다 30초 교환 전체 마감으로 hang 하지 않는다.
+ *  - 응답 본문은 256KiB 까지만 모은다. 넘으면 연결을 끊고 그 응답을 쓰지 않는다.
+ *  - 응답 JSON 에서 version 문자열만 방어 추출. 버전을 얻지 못하면(조회 실패, 거부, 없거나 비문자열) 시도 시각
+ *    (triedAt)만 써서 하루를 쉰다. latest 와 checkedAt 은 쓰지 않는다.
  *  - 캐시는 writeUpdateCache 로 병합 기록: fetch 된 latest 가 기존 캐시와 다르면 notified 를 초기화
  *    (재무장)하고, 같으면 형제 필드(notified 등)를 patch 에서 생략해 그대로 보존한다.
  *  - 어떤 오류도 삼키고 항상 exit 0. GET 뿐이라 페이로드/식별자 전송이 없다.
@@ -19,7 +22,7 @@ import http from 'node:http';
 import https from 'node:https';
 
 import {
-  UPDATE_CHECK_PATH, UPDATE_THROTTLE_MS, NPM_LATEST_URL, writeUpdateCache, collectBody, netDeadlineMs, readRegular,
+  UPDATE_CHECK_PATH, NPM_LATEST_URL, writeUpdateCache, collectBody, netDeadlineMs, readRegular, updateCheckDue,
 } from '../bin/lib/telemetry-config.mjs';
 
 const NET_TIMEOUT_MS = 10_000;
@@ -45,7 +48,8 @@ function readCache() {
 }
 
 // url 에 GET 요청해 응답 JSON 의 version 문자열만 추출한다. 실패·거부·리다이렉트·malformed 는 전부
-// null. reject 하지 않고 항상 resolve 한다(hang 방지). GET 뿐이라 페이로드·식별자 헤더가 없다.
+// null. reject 하지 않고 항상 resolve 한다(무활동 timeout 과 교환 전체 마감, 본문 256KiB 상한). GET 뿐이라
+// 페이로드·식별자 헤더가 없다.
 function fetchLatestVersion(url) {
   return new Promise((resolvePromise) => {
     let done = false;
@@ -94,21 +98,23 @@ function fetchLatestVersion(url) {
 
 async function main() {
   const cache = readCache();
-  const checkedAt = typeof cache.checkedAt === 'number' ? cache.checkedAt : null;
-  if (checkedAt !== null && (Date.now() - checkedAt) < UPDATE_THROTTLE_MS) return; // throttle 미경과 - no-op.
+  if (!updateCheckDue(cache)) return; // 성공이나 실패한 시도에서 하루가 지나지 않음 - no-op.
 
   const url = process.env.BANKER_NPM_URL || NPM_LATEST_URL; // 테스트 주입용 override.
   const latest = await fetchLatestVersion(url);
-  if (!latest) return; // 조회 실패·거부·malformed - 캐시 미기록.
+  if (!latest) { // 조회 실패·거부·malformed - 버전은 쓰지 않고 시도 시각만 남겨 하루를 쉰다.
+    writeUpdateCache({ triedAt: Date.now() });
+    return;
+  }
 
   // 개인화 매니페스트는 여기서 조회하지 않는다: update-fetch 는 카운팅 opt-out(countingActive false) 경로의
   // fetcher 이고, 개인화 표시도 countingActive() 로 게이트되므로 이 경로에선 표시될 일이 없다. 매니페스트
   // 조회는 카운팅 활성 경로의 update-checkin 만 수행한다(중복·죽은 조회 제거).
   const cachedLatest = typeof cache.latest === 'string' ? cache.latest : null;
   if (cachedLatest !== latest) {
-    writeUpdateCache({ latest, checkedAt: Date.now(), notified: null }); // 신버전 - notified 재무장.
+    writeUpdateCache({ latest, checkedAt: Date.now(), notified: null, triedAt: null }); // 신버전 - notified 재무장. 남은 실패 시도 시각은 비움.
   } else {
-    writeUpdateCache({ latest, checkedAt: Date.now() }); // 동일 버전 - notified 등 형제 필드는 병합 보존.
+    writeUpdateCache({ latest, checkedAt: Date.now(), triedAt: null }); // 동일 버전 - notified 등 형제 필드는 병합 보존, 실패 시도 시각은 비움.
   }
 }
 

package/hooks/update-notify.mjs

@@ -19,7 +19,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import {
-  UPDATE_CHECK_PATH, UPDATE_THROTTLE_MS,
+  UPDATE_CHECK_PATH, updateCheckDue,
   noUpdateCheck, countingActive, endpoint,
   installedVersion, compareVersions, writeUpdateCache, readUsedSkills, readRegular,
 } from '../bin/lib/telemetry-config.mjs';
@@ -89,13 +89,6 @@ function maybeNotify(cached) {
   writeUpdateCache({ notified: cached.latest }); // 형제 필드(latest/checkedAt/changedSkills) 보존하며 notified 만 병합.
 }
 
-// checkedAt 기준 throttle 경과 여부. 캐시 없음·checkedAt 미기록/비수치 → 경과로 본다(첫 조회 유도).
-function throttleElapsed(cached) {
-  const checkedAt = cached?.checkedAt;
-  if (typeof checkedAt !== 'number') return true;
-  return (Date.now() - checkedAt) >= UPDATE_THROTTLE_MS;
-}
-
 // 갱신 fetcher 절대경로 결정: count-default-on 활성(countingActive) + 엔드포인트 설정 시
 // update-checkin.mjs(체크인이 알림 조회를 겸함), 그 외에는 update-fetch.mjs(공개 npm GET 폴백).
 // 경로는 이 파일 기준으로 resolve 한다. (형제 스토리가 생성 중 - 런타임에 존재하면 된다.)
@@ -121,7 +114,7 @@ async function main() {
 
   const cached = readCache(); // 포그라운드는 캐시 읽기만(네트워크 없음).
   maybeNotify(cached);
-  if (throttleElapsed(cached)) spawnFetcher(); // 갱신은 백그라운드로 위임.
+  if (updateCheckDue(cached)) spawnFetcher(); // 갱신은 백그라운드로 위임. 실패한 시도(triedAt)에서도 하루를 쉰다.
 }
 
 // 직접 실행(훅)일 때만 main() 을 돌린다. import(테스트)시엔 chooseFetcher 만 노출하고 main 은 미실행.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaydash9999/banker-plugins",
-  "version": "0.20.2",
+  "version": "0.20.5",
   "description": "banker — Claude Code + Codex CLI plugin (QA, audit, docs, architecture, wiki skills). Install via Claude Code marketplace, or `npm i -g @kaydash9999/banker-plugins` then `banker setup`.",
   "bin": {
     "banker": "bin/banker.js"