@kaydash9999/banker-plugins 0.16.2 → 0.16.3

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Claude Code skills + commands — QA, audit, docs, architecture, dependency setup, and wiki; the banker plugin marketplace.",
-    "version": "0.16.2"
+    "version": "0.16.3"
   },
   "plugins": [
     {

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "banker",
-  "version": "0.16.2",
+  "version": "0.16.3",
   "description": "Claude Code plugin: QA/audit/docs/architecture skills + commands, a /banker:setup installer for OS dependencies (playwright, etc.), and wiki compaction.",
   "author": {
     "name": "smallOpenSource",

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.16.3] - 2026-10-12
+
+### Fixed
+- **`/progress` 패널에 계획이 보인다.** Claude Code 2.1.296 은 Claude 5 모델에 작업 목록 도구(TaskCreate, TaskUpdate, TodoWrite)를 주지 않아, 패널은 요청 단위 단계만 보였다.\
+  이제 세션이 쓰거나 읽은 마지막 계획 파일의 단계를 맨 위에 보인다. 읽는 파일은 `.omc/plans/*.md`, `docs/superpowers/plans/*.md`, `~/.claude/plans/*.md`, ralph `prd.json`, ultragoal `goals.json` 이다. PRD 의 `passes`, goals 의 `status`, 계획의 체크박스가 있으면 완료와 진행 중을 표시한다. 파일은 그 파일을 고친 도구 호출이 끝날 때와 턴의 시작과 끝에 다시 읽는다. 세션이 만지지 않은 파일은 보이지 않는다.
+- 계획 문서의 단계는 다음 순서로 고른다. superpowers 의 `### Task N:` 제목, 같은 수준의 `Phase N` 이나 `N단계` 제목 묶음, 맨 위 수준의 체크박스, 이름이 단계인 구역(작업 순서, 구현 단계, Implementation Steps 등)의 번호 목록이나 하위 제목. 코드 블록 안의 줄과 수용 기준 구역의 체크박스는 단계가 아니다.
+- 계획 폴더의 검토 문서(이름이 `-critic.md`, `-architect-r2.md`, `-review.md`, `-verdict.md` 처럼 끝나는 파일)와 `open-questions.md` 는 계획으로 보지 않는다. 하위 에이전트가 계획을 읽기만 하면 패널의 계획이 바뀌지 않는다. 단계가 없는 문서는 단계가 있는 계획을 대신하지 않는다.
+- 슬래시 명령의 단계 제목이 `<command-message>` 태그 원문이 아니라 `/명령 인자` 로 보인다. 그 밖의 하네스 태그(`<system-reminder>` 등)도 제목과 설명에서 지운다.
+- 백그라운드 작업이 끝났다는 알림(`<task-notification>`)과 팀원 메시지가 단계를 새로 만들지 않는다. 직전 요청의 단계 아래에 한 줄로 붙고, 그동안 그 단계를 진행 중으로 보이되 원래 결과와 걸린 시간은 그대로 둔다. 실패한 작업은 실패 행으로 보인다. 다른 세션에서 온 메시지는 `[다른 세션]` 단계가 된다.
+- 긴 제목은 패널 폭에 맞춰 자른다(한글과 기본이 이모지인 문자는 2칸). 상태 글자가 다음 줄로 넘어가지 않는다.
+
 ## [0.16.2] - 2026-10-11
 
 ### Security

package/README.md

@@ -59,7 +59,7 @@ Claude Code는 `/banker:<이름>`, Codex는 `banker-<이름>` 으로 호출합
 | `cleansing-memory` | 프로젝트가 장기화될 때 | 메모리 최적화 |
 | `ready-compact` | 컨텍스트를 compact 하거나 새 세션을 대비할 때 | 이어갈 프롬프트만 출력(`/copy` 한 번이면 복사), `--hand-off` = 새 세션에서 이어가기 |
 | `/graceful-pause` | 작업 도중 방향을 바꾸거나 끼어들고 싶을 때 | 작업 중에 입력해도 바로 전달. 실행 중인 도구 호출이 끝나면 그 단계까지만 마무리하고 멈춘 뒤 지시를 기다림 (Claude Code) |
-| `/progress` | 지금 작업이 어디까지 왔는지 보고 싶을 때 | 진행 단계 목록 패널을 켜고 끔. 단계를 누르면 설명, 화살표를 누르면 그 단계가 진행 중일 때 한 도구 호출이 펼쳐짐 (Claude Code) |
+| `/progress` | 지금 작업이 어디까지 왔는지 보고 싶을 때 | 진행 상황 패널을 켜고 끔. 세션이 쓰거나 읽은 계획 파일의 단계가 위에, 요청과 그 도구 호출이 아래에 보임. 단계를 누르면 설명, 화살표를 누르면 펼쳐짐 (Claude Code) |
 | `tone-compact` | 답변을 짧은 한글 개조식으로 받고 싶을 때 | 문체 규칙을 켜 두면 끌 때까지 모든 세션에 적용 |
 | `omc-patch` | OMC 자동 업데이트 뒤 훅이 느려지거나 훅 프로세스가 쌓일 때 | 사라진 훅 패치를 다시 적용하고 OMC 자동 업데이트를 고정 |
 | `remains` | 작업 뒤에 남은 버그, 하자, 미검증 항목을 한눈에 보고 싶을 때 | 남은 항목을 표로 정리하고, 등록한 테스트박스에서 시험까지 돌림 |
@@ -74,7 +74,9 @@ Claude Code는 `/banker:<이름>`, Codex는 `banker-<이름>` 으로 호출합
 | `/banker:front-qa` | 스펙(note) 기반 프론트엔드 구현 + parity QA |
 | `/banker:setup` | 구성요소·의존성 설치 오케스트레이터 (multi-select) |
 | `/graceful-pause` | 작업 중에도 바로 실행되는 정지 요청. 지금 단계만 끝내고 멈춘 뒤 보고하고 지시를 기다림 (Claude Code 2.1.289 이상, mod. Codex 미지원) |
-| `/progress` | 진행 상황 패널을 켜고 끔(`show` 기본 토글, `on`, `off`). 단계는 Claude 의 작업 목록, 없으면 이 세션의 요청이고, 하위 목록은 그 단계가 진행 중일 때 한 도구 호출 한 단계까지. 작업 중에도 바로 실행됨(2.1.289 이상에서 확인) (mod. Codex 미지원) |
+| `/progress` | 진행 상황 패널을 켜고 끔(`show` 기본 토글, `on`, `off`). 맨 위는 이 세션이 쓰거나 읽은 마지막 계획 파일(`.omc/plans/*.md`, `docs/superpowers/plans/*.md`, `~/.claude/plans/*.md`, ralph `prd.json`, ultragoal `goals.json`)의 단계. 그 아래 단계는 Claude 의 작업 목록, 없으면 이 세션의 요청이고, 하위 목록은 그 단계가 진행 중일 때 한 도구 호출 한 단계까지. 작업 중에도 바로 실행됨(2.1.289 이상에서 확인) (mod. Codex 미지원) |
+
+Claude Code 2.1.296 은 Claude 5 모델(Opus 5.5 등)에 작업 목록 도구(TaskCreate, TodoWrite)를 주지 않습니다. 그래서 `/progress` 의 단계는 보통 요청 단위이고, 계획은 계획 파일로 보입니다. 작업 목록을 쓰려면 `CLAUDE_CODE_ENABLE_TODO_TOOLS=1` 을 설정합니다.
 
 `/graceful-pause` 와 `/progress` 는 Claude Code 의 mod(Claude Mods, 얼리 액세스 이름 function hooks, `hooks/register.mjs`)로 등록되는 명령이라 구성요소 수에 넣지 않습니다. `commands/progress.md` 도 넣지 않습니다. 이 파일은 mod 가 없는 Claude Code 에서 `/progress` 를 받아 "mod 를 지원하지않는 claude code 버전입니다" 만 보여 주는 대체 명령이고, mod 가 있으면 mod 가 대신 처리합니다.
 

package/hooks/progress-plan.mjs

@@ -0,0 +1,328 @@
+/**
+ * What banker's /progress pane (progress.mjs) reads from text: a prompt as the person wrote it, and
+ * a plan file as steps. Plain functions of strings; the pane reads the files itself.
+ *
+ * A turn's text comes with the harness's tags: a slash command arrives as `<command-name>` and
+ * `<command-args>`, a background task's end as `<task-notification>`, a shell command as
+ * `<bash-input>`. Claude 5 models get no task list tool in Claude Code 2.1.296, so the plan a
+ * session writes (ralplan's, superpowers', ralph's PRD, ultragoal's goals) is what shows the work
+ * ahead.
+ *
+ * Every mod shares the engine's one hooks worker, and a plan may come from a cloned repository, so
+ * no step here takes more than linear time: a markdown plan is read to its first 256 Ki characters
+ * and each line to its first 1 Ki, a JSON plan's fields and a prompt's text are cut before they are
+ * cleaned, tags are found with indexOf, and no pattern backtracks over a line.
+ */
+
+// ── text on the pane ─────────────────────────────────────────────────────────
+
+// Characters a terminal draws two cells wide: Hangul, CJK, fullwidth forms, and emoji shown as
+// emoji by default. Combining marks, joiners and variation selectors take none.
+const WIDE = /[\u1100-\u115F\u2E80-\u303E\u3041-\u33FF\u3400-\u4DBF\u4E00-\u9FFF\uA000-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6\u{20000}-\u{3FFFD}]|\p{Emoji_Presentation}/u;
+const NONE = /[\p{Mn}\p{Me}\u200B-\u200D\uFE0E\uFE0F]/u;
+const width = (c) => (NONE.test(c) ? 0 : WIDE.test(c) ? 2 : 1);
+
+// The cells a line of text takes on a terminal.
+export const cells = (text) => [...String(text)].reduce((n, c) => n + width(c), 0);
+
+// A line cut to `n` cells, its end an ellipsis where it was cut.
+export function fit(text, n) {
+  if (cells(text) <= n) return text;
+  if (n <= 0) return '';
+  let out = '';
+  let used = 0;
+  for (const c of text) {
+    if (used + width(c) > n - 1) break;
+    out += c;
+    used += width(c);
+  }
+  return `${out}…`;
+}
+
+// One line of plain text, cut to `n` characters. Control characters and lone surrogates go too: the
+// engine refuses a drawing that holds either. A long text is cut first, so cleaning it stays cheap.
+export const clip = (text, n) => {
+  const raw = String(text ?? '').slice(0, n * 4 + 1024);
+  const s = (raw.toWellFormed?.() ?? raw).replace(/\p{Cc}+/gu, ' ').replace(/\s+/g, ' ').trim();
+  const chars = [];
+  for (const c of s) {
+    chars.push(c);
+    if (chars.length > n) break;
+  }
+  return chars.length > n ? `${chars.slice(0, n - 1).join('')}…` : s;
+};
+
+// ── a prompt's text ──────────────────────────────────────────────────────────
+
+// Past this a prompt, its tags taken out, has nothing more for a title or a description.
+const PROMPT_CAP = 65536;
+
+// Tags the harness wraps around what it adds to a prompt: they go with what they hold.
+const HARNESS = ['system-reminder', 'local-command-caveat', 'local-command-stdout', 'local-command-stderr',
+  'bash-stdout', 'bash-stderr', 'command-message', 'command-name', 'command-args', 'bash-input'];
+
+// Messages the harness wraps in a tag with attributes: another session's, a teammate's.
+const WRAPPER = /^\s*<(cross-session-message|teammate-message)\b[^>]*>/;
+
+// The first `open … close` pair from `from` on, or null where there is none.
+function pair(text, open, close, from = 0) {
+  const start = text.indexOf(open, from);
+  if (start < 0) return null;
+  const stop = text.indexOf(close, start + open.length);
+  return stop < 0 ? null : { start, inner: text.slice(start + open.length, stop), end: stop + close.length };
+}
+
+const inner = (text, tag) => pair(text, `<${tag}>`, `</${tag}>`)?.inner.trim() ?? '';
+
+// The text with each pair of a harness tag taken out, with what it holds; an unclosed tag stays.
+function strip(text) {
+  let s = text;
+  for (const tag of HARNESS) {
+    let out = '';
+    let at = 0;
+    let m = pair(s, `<${tag}>`, `</${tag}>`);
+    while (m) {
+      out += `${s.slice(at, m.start)} `;
+      at = m.end;
+      m = pair(s, `<${tag}>`, `</${tag}>`, at);
+    }
+    s = out + s.slice(at);
+  }
+  return s;
+}
+
+// Another session's message is a prompt from there; a teammate's joins the work at hand.
+function message(text, m) {
+  const rest = text.slice(m[0].length);
+  const stop = rest.indexOf(`</${m[1]}>`);
+  const body = (stop < 0 ? rest : rest.slice(0, stop)).replace(/\s+/g, ' ').trim();
+  if (m[1] === 'teammate-message') return { kind: 'notice', text: clip(body, 200), status: 'message' };
+  return { kind: 'prompt', text: `[다른 세션] ${body}`.trim() };
+}
+
+// What a turn's text says: a notice (a background task's end, with its summary and status, or a
+// teammate's message), or a prompt, a slash command as `/name args` and a shell command as `! command`.
+export function readPrompt(raw) {
+  const text = String(raw ?? '');
+  if (/^\s*<task-notification>/.test(text)) {
+    return { kind: 'notice', text: clip(inner(text, 'summary'), 200), status: inner(text, 'status') };
+  }
+  const wrapped = WRAPPER.exec(text);
+  if (wrapped) return message(text, wrapped);
+  const command = inner(text, 'command-name');
+  const shell = inner(text, 'bash-input');
+  const lead = command ? `${command} ${inner(text, 'command-args')}` : shell ? `! ${shell}` : '';
+  return { kind: 'prompt', text: `${lead} ${strip(text)}`.slice(0, PROMPT_CAP).replace(/\s+/g, ' ').trim() };
+}
+
+// ── which files are plans ────────────────────────────────────────────────────
+
+const PLAN_PATHS = [
+  /\/\.omc\/plans\/[^/]+\.md$/,
+  /\/docs\/superpowers\/plans\/[^/]+\.md$/,
+  /\/\.claude\/plans\/[^/]+\.md$/,
+  /\/\.omc\/(?:state\/(?:[^/]+\/)*)?prd\.json$/,
+  /\/\.omc\/ultragoal\/goals\.json$/,
+];
+// Plan folders keep a plan's review rounds beside it (ralplan's `<plan>-critic-r2.md`,
+// `architect-review-r1.md`) and OMC's open questions: a name that ends so is no plan.
+const NOT_A_PLAN = [/(?:^|[-_])(?:critic|architect|review|verdict|feedback)(?:-r\d+)?\.md$/i, /^open-questions\.md$/i];
+
+export const isPlanPath = (path) => {
+  const p = String(path ?? '').replaceAll('\\', '/');
+  const name = p.split('/').at(-1);
+  return PLAN_PATHS.some((re) => re.test(p)) && !NOT_A_PLAN.some((re) => re.test(name));
+};
+
+// ── a plan file ──────────────────────────────────────────────────────────────
+
+const PLAN_CAP = 256 * 1024;
+const LINE_CAP = 1024;
+const MAX_PLAN_STEPS = 50;
+const BOM = /^\uFEFF/;
+const fileName = (path) => String(path).split(/[\\/]/).filter(Boolean).at(-1) ?? '';
+// Markdown's marks off a line: a link to its text, code spans' backticks, bold's asterisks.
+const plain = (line) => line.replace(/\[([^[\]]*)\]\([^()]*\)/g, '$1').replace(/\*\*|`/g, '');
+const step = (title, text, status) => ({
+  title: clip(plain(clip(title, 400)), 60), text: clip(plain(clip(text || title, 400)), 200), status,
+});
+
+const str = (v) => (typeof v === 'string' ? v : typeof v === 'number' ? String(v) : '');
+// A map's own entry: a key like `constructor` finds nothing.
+export const pick = (map, key) => (Object.hasOwn(map, key) ? map[key] : undefined);
+const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+// ultragoal's states, and the ones like them; one it does not know shows no state.
+const GOAL_STATUS = { complete: 'completed', completed: 'completed', in_progress: 'in_progress', active: 'in_progress',
+  pending: 'pending', failed: 'failed', review_blocked: 'blocked', blocked: 'blocked' };
+
+const storyStep = (st) => {
+  const id = str(st.id);
+  return { title: str(st.title) || id, text: [id, str(st.description)].filter(Boolean).join(': '), status: st.passes === true ? 'completed' : 'pending' };
+};
+const goalStep = (g) => ({ title: str(g.title) || str(g.id), text: str(g.objective), status: pick(GOAL_STATUS, str(g.status)) ?? null });
+
+// A ralph PRD (`stories` or `userStories`, done where they pass) or ultragoal's goals; items that
+// are not objects are passed over.
+function jsonPlan(path, text) {
+  let d;
+  try {
+    d = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!isObject(d)) return null;
+  const stories = d.stories ?? d.userStories;
+  if (Array.isArray(stories)) return { title: str(d.title) || str(d.project) || fileName(path), records: stories.filter(isObject).map(storyStep) };
+  if (Array.isArray(d.goals)) return { title: 'ultragoal', records: d.goals.filter(isObject).map(goalStep) };
+  return null;
+}
+
+// The fence a line opens or closes (``` or ~~~), or ''. A run of backticks with a backtick after it
+// opens inline code, not a fence (CommonMark).
+function fenceMark(line) {
+  const m = /^ {0,3}(`{3,}|~{3,})/.exec(line);
+  if (!m) return '';
+  return m[1][0] === '`' && line.slice(m[0].length).includes('`') ? '' : m[1];
+}
+
+// The plan's lines as a reader sees them: a fenced code block's lines (to the fence that closes it,
+// or the end) are blank, so they are no heading or item.
+function proseLines(text) {
+  let fence = '';
+  return text.slice(0, PLAN_CAP).split(/\r?\n/).map((raw) => {
+    const line = raw.slice(0, LINE_CAP);
+    const mark = fenceMark(line);
+    if (!fence) {
+      fence = mark;
+      return mark ? '' : line;
+    }
+    if (mark[0] === fence[0] && mark.length >= fence.length && !line.slice(line.indexOf(mark) + mark.length).trim()) fence = '';
+    return '';
+  });
+}
+
+// The headings, each with where its section ends (the next heading of its level or above) and the
+// headings right under it: one pass, with a stack of the sections still open.
+function outline(lines) {
+  const heads = [];
+  const open = [];
+  lines.forEach((line, i) => {
+    const m = /^(#{1,6})[ \t]+([^\r\n]*)/.exec(line);
+    if (!m) return;
+    const h = { i, level: m[1].length, text: m[2].trim(), end: lines.length, subs: [] };
+    while (open.length && open.at(-1).level >= h.level) open.pop().end = i;
+    open.at(-1)?.subs.push(h);
+    open.push(h);
+    heads.push(h);
+  });
+  return heads;
+}
+
+// How far along a section's checkboxes say it is; null where it has none.
+function boxStatus(lines, h) {
+  let all = 0;
+  let done = 0;
+  for (let i = h.i + 1; i < h.end; i++) {
+    const m = /^\s*[-*+][ \t]+\[([ xX])\]/.exec(lines[i]);
+    if (!m) continue;
+    all += 1;
+    if (m[1] !== ' ') done += 1;
+  }
+  if (!all) return null;
+  return done === 0 ? 'pending' : done === all ? 'completed' : 'in_progress';
+}
+
+const TASK_HEAD = /^Task\s+\d+\s*[:.]\s*/i;
+const STEP_HEAD = /^(?:(?:phase|step|stage|milestone|sprint)\s*[\d.]+|단계\s*\d+|\d+(?:\.\d+)?\s*단계)/i;
+
+// Two or more headings of one level named as steps (Phase 1, Step 2, 3단계): the shallowest such level.
+function stepHeadings(heads) {
+  const byLevel = new Map();
+  for (const h of heads) {
+    if (!STEP_HEAD.test(h.text)) continue;
+    if (!byLevel.has(h.level)) byLevel.set(h.level, []);
+    byLevel.get(h.level).push(h);
+  }
+  const level = [...byLevel.keys()].sort((a, b) => a - b).find((l) => byLevel.get(l).length >= 2);
+  return byLevel.get(level) ?? [];
+}
+
+// Rules 1 and 2: superpowers' `Task N:` headings, else headings named as steps; each as far along
+// as the checkboxes in its section.
+function headedSteps(lines, heads) {
+  const tasks = heads.filter((h) => TASK_HEAD.test(h.text));
+  return (tasks.length ? tasks : stepHeadings(heads))
+    .map((h) => ({ title: h.text.replace(TASK_HEAD, ''), text: h.text, status: boxStatus(lines, h) }));
+}
+
+// Sections whose checkboxes test the work rather than lay out its steps.
+const CRITERIA = /수용\s*기준|인수\s*기준|완료\s*(?:기준|조건|판정)|검증\s*기준|acceptance|definition of done|criteria/i;
+
+// Rule 3: checkboxes at the top level of the text, outside the criteria sections.
+function boxSteps(lines, heads) {
+  const marks = new Int32Array(lines.length + 1);
+  for (const h of heads) {
+    if (!CRITERIA.test(h.text)) continue;
+    marks[h.i] += 1;
+    marks[h.end] -= 1;
+  }
+  const out = [];
+  let depth = 0;
+  lines.forEach((line, i) => {
+    depth += marks[i];
+    const m = depth > 0 ? null : /^[-*+][ \t]+\[([ xX])\][ \t]+([^\r\n]*)/.exec(line);
+    if (m) out.push({ title: m[2], text: m[2], status: m[1] === ' ' ? 'pending' : 'completed' });
+  });
+  return out;
+}
+
+const STEPS_SECTION = /단계|(?:작업|집행|실행|구현|진행)\s*(?:순서|흐름|계획)|\bsteps?\b|implementation|phases?|\btasks?\b|milestones?|로드맵|road ?map/i;
+
+// The numbered items of a section, up to `stop`.
+function numbered(lines, h, stop) {
+  const out = [];
+  for (let i = h.i + 1; i < stop; i++) {
+    const m = /^\d+[.)][ \t]+([^\r\n]*)/.exec(lines[i]);
+    if (m) out.push({ title: m[1], text: m[1], status: null });
+  }
+  return out;
+}
+
+// Rule 4: the first section named for the steps: its own numbered items (those before its first
+// sub-heading), else its sub-headings.
+function sectionSteps(lines, heads) {
+  for (const h of heads) {
+    if (h.level === 1 || STEP_HEAD.test(h.text) || !STEPS_SECTION.test(h.text)) continue;
+    const items = numbered(lines, h, h.subs[0]?.i ?? h.end);
+    if (items.length) return items;
+    if (h.subs.length) return h.subs.map((x) => ({ title: x.text, text: x.text, status: boxStatus(lines, x) }));
+  }
+  return [];
+}
+
+function markdownPlan(path, text) {
+  const lines = proseLines(text);
+  const heads = outline(lines);
+  let records = headedSteps(lines, heads);
+  if (!records.length) records = boxSteps(lines, heads);
+  if (!records.length) records = sectionSteps(lines, heads);
+  return { title: heads.find((h) => h.level === 1)?.text || fileName(path), records, cut: text.length > PLAN_CAP };
+}
+
+// A plan file as `{ title, steps, total, done, hasStates, cut }`: its first 50 steps, each
+// `{ title, text, status }` (status null where the file says none), how many it has and how many
+// are done, and whether the file was longer than what was read. Null for a JSON file that is no plan.
+export function parsePlan(path, text) {
+  const body = String(text).replace(BOM, '');
+  const plan = /\.json$/i.test(String(path)) ? jsonPlan(path, body) : markdownPlan(path, body);
+  if (!plan) return null;
+  const { records } = plan;
+  return {
+    title: clip(plain(clip(plan.title, 400)), 60),
+    steps: records.slice(0, MAX_PLAN_STEPS).map((r) => step(r.title, r.text, r.status)),
+    total: records.length,
+    done: records.filter((r) => r.status === 'completed').length,
+    hasStates: records.some((r) => r.status),
+    cut: Boolean(plan.cut),
+  };
+}

package/hooks/progress.mjs

@@ -9,11 +9,20 @@
  * a call shows a short description under the list; a press on a step's arrow folds or unfolds its
  * calls.
  *
+ * Claude 5 models get no task list tool in Claude Code 2.1.296 (only older models, a background
+ * job, or CLAUDE_CODE_ENABLE_TODO_TOOLS do), so there prompts are the steps. Above them the pane
+ * shows the plan file the session touched last (progress-plan.mjs reads it), as steps of its own.
+ * A prompt's harness tags leave its title, and a background task's notice (or a teammate's message)
+ * goes on with the last prompt's step instead of becoming one: the step runs again while it does,
+ * and keeps its own end and time.
+ *
  * `/progress` and `/progress show` toggle the pane, `on` and `off` set it. The command is
  * registered `immediate`, so it answers while a turn runs. An engine without mods never loads
  * this file: commands/progress.md and hooks/progress-fallback.mjs answer there instead.
  */
 
+import { cells, clip, fit, isPlanPath, parsePlan, pick, readPrompt } from './progress-plan.mjs';
+
 const COMMAND = 'progress';
 const PANE = 'banker-progress';
 const TITLE = '진행 상황';
@@ -22,6 +31,9 @@ const HINT = '단계나 하위 항목을 누르면 설명이 여기에 나옵니
 const MAX_STEPS = 50;
 const MAX_KEPT_CALLS = 200;
 const MAX_SHOWN_CALLS = 30;
+const MAX_SHOWN_PLAN = 20;
+// The calls whose file, when it is a plan file, becomes the plan the pane shows.
+const PLAN_TOUCH = new Set(['Write', 'Edit', 'MultiEdit', 'Read', 'NotebookEdit']);
 // The id of the step made for work already under way when the module loaded mid-turn.
 const AT_HAND = 'now';
 // Bookkeeping calls: they become steps, not calls under a step.
@@ -30,6 +42,13 @@ const STATUS = {
   running: '진행 중', in_progress: '진행 중', pending: '대기', done: '완료', completed: '완료',
   stopped: '중단됨', refused: '거절됨', failed: '오류로 끝남',
 };
+// A plan step's state, as progress-plan.mjs names it.
+const PLAN_STATUS = { completed: '완료', in_progress: '진행 중', pending: '대기', failed: '실패', blocked: '막힘' };
+// A notice's row, by the status it came with.
+const NOTICE = {
+  completed: '백그라운드 작업 끝남', failed: '백그라운드 작업 실패', stopped: '백그라운드 작업 중지됨',
+  killed: '백그라운드 작업 중지됨', message: '팀원 메시지',
+};
 // How a prompt's turn ended (turn.complete's reason), as its step's state.
 const ENDED = { answer: 'done', aborted: 'stopped', refusal: 'refused', error: 'failed' };
 // Why a hook failed (the kind of the engine's HookFailure), for a failure that brings no message.
@@ -48,15 +67,12 @@ const tally = () => ({ calls: [], count: 0, failed: 0 });
 const looseStep = () => ({ key: 'loose', title: '작업 목록 밖의 작업', ...tally() });
 
 // `rev` counts the task changes (TaskCreate, TaskUpdate) taken in, to tell a stale TaskList or TaskGet.
-export const freshState = () => ({ turns: [], tasks: new Map(), todos: null, loose: looseStep(), open: new Set(), selected: null, seq: 0, rev: 0 });
-
-// One line of plain text, cut to `n` characters. Control characters go too: a pasted escape
-// sequence is not text to show.
-const clip = (text, n) => {
-  const s = String(text ?? '').replace(/\p{Cc}+/gu, ' ').replace(/\s+/g, ' ').trim();
-  const chars = [...s];
-  return chars.length > n ? `${chars.slice(0, n - 1).join('')}…` : s;
-};
+// `plan` is the plan last read from `planPath`, `planShut` whether its steps are folded. `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.
+export const freshState = () => ({ turns: [], tasks: new Map(), todos: null, loose: looseStep(), open: new Set(), selected: null, seq: 0, rev: 0,
+  plan: null, planPath: null, planShut: false, touch: 0, taken: 0 });
+
 const tail = (path) => String(path).split(/[\\/]/).filter(Boolean).slice(-2).join('/');
 const seconds = (ms) => {
   const all = Math.max(0, Math.round(ms / 1000));
@@ -72,14 +88,39 @@ export function callLabel(e) {
 
 // ── what the module learns from the session ──────────────────────────────────
 
-// A prompt as a step. A prompt whose end never came is done where the next one starts.
-function addTurn(s, e, now) {
-  for (const t of s.turns) if (t.status === 'running') Object.assign(t, { status: 'done', endedAt: now });
-  s.turns.push({ key: `t-${e.turnId}`, id: e.turnId, title: clip(e.text, 60) || '(이어서 진행)', text: String(e.text ?? ''),
-    startedAt: now, endedAt: null, status: 'running', ...tally() });
+// A prompt as a step. A prompt whose end never came is done where the next one starts, and so are
+// the notices still running on a step. `notices` holds the turns of the notices running on it.
+function addTurn(s, turnId, text, now, title) {
+  for (const t of s.turns) {
+    if (t.status === 'running') Object.assign(t, { status: 'done', endedAt: now });
+    t.notices.clear();
+  }
+  s.turns.push({ key: `t-${turnId}`, id: turnId, title: title ?? (clip(text, 60) || '(이어서 진행)'), text,
+    startedAt: now, endedAt: null, status: 'running', notices: new Set(), ...tally() });
   if (s.turns.length > MAX_STEPS) s.turns.shift();
 }
 
+// A step's state on the pane: a prompt's step runs again while a notice runs on it.
+const statusOf = (step) => (step.notices?.size ? 'running' : step.status);
+
+// A row under a step that is no tool call: it counts as none. `ok` false shows it failed.
+function note(s, step, label, ok, now) {
+  step.calls.push({ key: `c-${++s.seq}`, tool: '', label: clip(label, 60), detail: clip(label, 240), isNote: true,
+    startedAt: now, endedAt: now, ok, steps: [step] });
+  if (step.calls.length > MAX_KEPT_CALLS) step.calls.shift();
+}
+
+// A background task's end (or a teammate's message) opens a turn of its own: it runs on the last
+// prompt's step, under which a row says so, and the list stays as it is. Before any prompt it is a
+// step of its own.
+function noticeTurn(s, e, said, now) {
+  const word = pick(NOTICE, said.status) ?? '백그라운드 작업 알림';
+  if (!s.turns.length) addTurn(s, e.turnId, '', now, said.status === 'message' ? word : '백그라운드 작업 알림');
+  const t = s.turns.at(-1);
+  if (t.id !== e.turnId) t.notices.add(e.turnId);
+  if (said.text) note(s, t, `${word}: ${said.text}`, said.status !== 'failed', now);
+}
+
 // The task list's items, which are the steps while there are any: TodoWrite's, else the Tasks list's.
 function listItems(s) {
   return s.todos?.length ? s.todos : [...s.tasks.values()];
@@ -97,14 +138,22 @@ function dropFinished(s) {
 }
 
 export function startTurn(s, e, now) {
+  const said = readPrompt(e.text);
+  if (said.kind === 'notice') return noticeTurn(s, e, said, now);
   dropFinished(s);
-  addTurn(s, e, now);
+  addTurn(s, e.turnId, said.text, now);
 }
 
-// A main turn's end; a subagent's (it carries an agentId) ends no step. A turn the module never
-// saw start (it loaded mid-turn) ends the step for the work at hand.
+// A main turn's end; a subagent's (it carries an agentId) ends no step, and a notice's leaves its
+// step's own end as it was. A turn the module never saw start (it loaded mid-turn) ends the step for
+// the work at hand.
 export function endTurn(s, e, now) {
   if (e.agentId) return;
+  const host = s.turns.find((x) => x.notices.has(e.turnId));
+  if (host) {
+    host.notices.delete(e.turnId);
+    return;
+  }
   const t = s.turns.find((x) => x.id === e.turnId) ?? s.turns.find((x) => x.id === AT_HAND && x.status === 'running');
   if (!t) return;
   t.status = ENDED[e.reason] ?? 'failed';
@@ -118,7 +167,7 @@ function owners(s, now) {
   const items = listItems(s);
   const task = [...items].reverse().find((t) => t.status === 'in_progress');
   const first = task ?? (items.length ? s.loose : null);
-  if (!s.turns.length) addTurn(s, { turnId: AT_HAND, text: '지금 하는 작업' }, now);
+  if (!s.turns.length) addTurn(s, AT_HAND, '지금 하는 작업', now);
   return first ? [first, s.turns.at(-1)] : [s.turns.at(-1)];
 }
 
@@ -249,6 +298,50 @@ export function noteTaskTool(s, e, r, now, since) {
   if (CHANGES.has(e.tool)) s.rev += 1;
 }
 
+// The plan file a call touched, with the touch's count, when it is one and the call went through:
+// a write by anyone, a read by the session itself (an agent reviewing a plan does not make it the plan).
+export function planTouched(s, e, call) {
+  const path = e.file_path ?? e.notebook_path;
+  if (!call?.ok || !PLAN_TOUCH.has(e.tool) || !isPlanPath(path) || (e.tool === 'Read' && e.agentId)) return null;
+  s.touch += 1;
+  return { path, touch: s.touch };
+}
+
+function parsed(path, text) {
+  try {
+    return typeof text === 'string' ? parsePlan(path, text) : null;
+  } catch {
+    return null; /* a plan the parser trips on leaves the pane as it was */
+  }
+}
+
+// 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 }) {
+  if (touch !== undefined) return touch > s.taken;
+  return path === s.planPath && s.taken <= since;
+}
+
+const isPlanKey = (key) => key === 'plan' || /^p-\d+$/.test(key ?? '');
+
+// Whether what was read stays off the pane: no plan, or a file with no steps in place of a plan that
+// has some (a review written beside it).
+const keepsOff = (s, path, plan) => !plan || (path !== s.planPath && !plan.total && Boolean(s.plan?.total));
+
+// 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.
+export function takePlan(s, path, text, read = {}) {
+  if (!current(s, path, read)) return;
+  const plan = parsed(path, text);
+  if (keepsOff(s, path, plan)) return;
+  const moving = path !== s.planPath;
+  if (read.touch !== undefined) s.taken = read.touch;
+  if (moving && isPlanKey(s.selected)) s.selected = null;
+  s.planPath = path;
+  s.plan = { ...plan, path, steps: plan.steps.map((st, i) => ({ ...st, key: `p-${i}`, planStep: true })) };
+}
+
 // ── what the pane shows ──────────────────────────────────────────────────────
 
 // Nothing seen yet: one step that says so, with no state word beside it.
@@ -257,7 +350,8 @@ const IDLE = { key: 'idle', title: '진행 중인 작업 없음', status: null,
 // The calls outside the list are in progress while calls still go there: no task is in progress
 // and the prompt runs.
 function looseStatus(s, items) {
-  const going = !items.some((t) => t.status === 'in_progress') && s.turns.at(-1)?.status === 'running';
+  const last = s.turns.at(-1);
+  const going = !items.some((t) => t.status === 'in_progress') && last !== undefined && statusOf(last) === 'running';
   return going ? 'running' : 'done';
 }
 
@@ -272,9 +366,10 @@ function callCount(step) {
 }
 
 function stepState(step, now) {
-  const doing = step.status === 'in_progress' && step.activeForm ? `(${clip(step.activeForm, 40)})` : '';
+  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[step.status] ?? step.status}${doing}${time}`;
+  return `${STATUS[status] ?? status}${doing}${time}`;
 }
 
 function stepWords(step, now) {
@@ -285,54 +380,127 @@ function stepWords(step, now) {
 }
 
 function callWords(call, now) {
+  if (call.isNote) return `${call.detail.replace(/[.!?。]+$/, '')}.`;
   const state = call.ok === null ? '실행 중' : call.ok ? '성공' : '실패';
   const who = call.isAgent ? '하위 에이전트의 ' : '';
   return `${who}${call.tool}${call.detail ? `: ${call.detail}` : ''}. ${state}, ${seconds((call.endedAt ?? now) - call.startedAt)}.`;
 }
 
-// What the person pressed last, while it is still on the pane: a step, or a call under one.
+function planWords(plan) {
+  const where = `계획 파일: ${clip(plan.path.split(/[\\/]/).filter(Boolean).slice(-3).join('/'), 120)}`;
+  const cut = plan.cut ? ' 파일이 길어 앞부분만 읽었습니다.' : '';
+  if (!plan.total) return `${where}. 단계를 찾지 못했습니다.${cut}`;
+  const done = plan.hasStates ? `, 완료 ${plan.done}개` : '';
+  return `${where}. 단계 ${plan.total}개${done}.${cut}`;
+}
+
+function planStepWords(st) {
+  const what = st.text.replace(/[.!?。]+$/, '');
+  return st.status ? `${what}. ${PLAN_STATUS[st.status]}.` : `${what}.`;
+}
+
+// What the person pressed last, while it is still on the pane: the plan or one of its steps, a
+// step, or a call under one.
 function pressed(s) {
+  if (s.plan && s.selected === 'plan') return { key: 'plan', isPlan: true };
+  const plan = s.plan?.steps.find((st) => st.key === s.selected);
+  if (plan) return plan;
   const all = steps(s);
   return all.find((x) => x.key === s.selected) ?? all.flatMap((x) => x.calls).find((c) => c.key === s.selected);
 }
 
+function itemWords(s, item, now) {
+  if (item.isPlan) return planWords(s.plan);
+  if (item.planStep) return planStepWords(item);
+  return item.tool !== undefined ? callWords(item, now) : stepWords(item, now);
+}
+
 // The description under the list: the pressed step's or call's, or how to get one.
 export function describe(s, now) {
   const item = pressed(s);
-  if (item) return item.tool ? callWords(item, now) : stepWords(item, now);
+  if (item) return itemWords(s, item, now);
   const all = steps(s);
   return all.length === 1 && all[0].key === 'idle' ? stepWords(IDLE, now) : HINT;
 }
 
+// A label cut so that it, the cells before it and the words after it fit on one row of the pane.
+const room = (label, act, before, after) => fit(label, (act.cols ?? Infinity) - before - (after ? cells(after) + 1 : 0));
+
 function callRows(ui, step, act) {
   const { Box, Text, Button } = ui;
   const shown = step.calls.slice(-MAX_SHOWN_CALLS);
-  const rows = shown.map((c) => Box({ key: `row-${c.key}`, flexDirection: 'row', columnGap: 1, paddingLeft: 4, children: [
-    Button({ key: c.key, label: c.label, plain: true, dimColor: c.ok !== false, onPress: () => act.select(c.key) }),
-    Text({ children: [c.ok === null ? '실행 중' : c.ok ? '' : '실패'], dimColor: true }),
-  ] }));
+  const rows = shown.map((c) => {
+    const state = c.ok === null ? '실행 중' : c.ok ? '' : '실패';
+    return Box({ key: `row-${c.key}`, flexDirection: 'row', columnGap: 1, paddingLeft: 4, children: [
+      Button({ key: c.key, label: room(c.label, act, 4, state), plain: true, dimColor: c.ok !== false, onPress: () => act.select(c.key) }),
+      ...stateWord(ui, state, false),
+    ] });
+  });
   const hidden = step.calls.length - shown.length;
   return hidden ? [Box({ paddingLeft: 4, children: [Text({ children: [`앞의 ${hidden}개는 줄였습니다`], dimColor: true })] }), ...rows] : rows;
 }
 
+// A row's state word, bold while it runs; none where the state is empty, so no gap is kept for it.
+function stateWord(ui, state, running) {
+  return state ? [ui.Text({ children: [state], dimColor: !running, bold: running })] : [];
+}
+
 function stepRow(ui, s, step, act) {
   const { Box, Text, Button } = ui;
   const isOpen = s.open.has(step.key);
   const arrow = step.calls.length
     ? Button({ key: `arrow-${step.key}`, label: isOpen ? '▾' : '▸', plain: true, onPress: () => act.fold(step.key) })
     : Text({ children: [' '] });
-  const running = step.status === 'running' || step.status === 'in_progress';
+  const status = statusOf(step);
+  const state = STATUS[status] ?? status ?? '';
   return Box({ key: `row-${step.key}`, flexDirection: 'row', columnGap: 1, children: [
     arrow,
-    Button({ key: step.key, label: step.title, plain: true, onPress: () => act.select(step.key) }),
-    Text({ children: [STATUS[step.status] ?? step.status ?? ''], dimColor: !running, bold: running }),
+    Button({ key: step.key, label: room(step.title, act, 2, state), plain: true, onPress: () => act.select(step.key) }),
+    ...stateWord(ui, state, status === 'running' || status === 'in_progress'),
+  ] });
+}
+
+// The plan's row: its title in bold (a Button draws its Text children in place of its label) and
+// how far along it is.
+function planHead(ui, s, act) {
+  const { Box, Text, Button } = ui;
+  const { plan } = s;
+  const count = !plan.total ? '단계 없음' : plan.hasStates ? `${plan.done}/${plan.total} 완료` : `${plan.total}단계`;
+  const arrow = plan.steps.length
+    ? Button({ key: 'arrow-plan', label: s.planShut ? '▸' : '▾', plain: true, onPress: () => act.foldPlan() })
+    : Text({ children: [' '] });
+  const label = room(`계획: ${plan.title}`, act, 2, count);
+  return Box({ key: 'row-plan', flexDirection: 'row', columnGap: 1, children: [
+    arrow,
+    Button({ key: 'plan', label, plain: true, onPress: () => act.select('plan'), children: [Text({ bold: true, children: [label] })] }),
+    Text({ children: [count], dimColor: true }),
   ] });
 }
 
-// The pane's tree. `ui` is the surface's element table; `act` holds what a press does.
+// The plan's rows: its title, then its first steps unless folded, then a line for the plan's rest.
+function planRows(ui, s, act) {
+  const { Box, Text, Button } = ui;
+  if (!s.plan) return [];
+  const rows = [planHead(ui, s, act)];
+  if (s.planShut) return [...rows, Box({ key: 'plan-gap', marginBottom: 1 })];
+  const shown = s.plan.steps.slice(0, MAX_SHOWN_PLAN);
+  for (const st of shown) {
+    const state = PLAN_STATUS[st.status] ?? '';
+    rows.push(Box({ key: `row-${st.key}`, flexDirection: 'row', columnGap: 1, paddingLeft: 2, children: [
+      Button({ key: st.key, label: room(st.title, act, 2, state), plain: true, onPress: () => act.select(st.key) }),
+      ...stateWord(ui, state, st.status === 'in_progress'),
+    ] }));
+  }
+  const rest = s.plan.total - shown.length;
+  if (rest > 0) rows.push(Box({ key: 'plan-more', paddingLeft: 2, children: [Text({ children: [`외 ${rest}개`], dimColor: true })] }));
+  return [...rows, Box({ key: 'plan-gap', marginBottom: 1 })];
+}
+
+// The pane's tree. `ui` is the surface's element table; `act` holds what a press does and `cols`,
+// the cells across the pane's body (Infinity where the engine gives none).
 export function draw(ui, s, now, act) {
   const { Box, Text } = ui;
-  const rows = [];
+  const rows = planRows(ui, s, act);
   for (const step of steps(s)) {
     rows.push(stepRow(ui, s, step, act));
     if (s.open.has(step.key)) rows.push(...callRows(ui, step, act));
@@ -385,10 +553,21 @@ async function watchCall($, e, next) {
   } finally {
     endCall(call, r, Date.now());
     if (TASK_TOOLS.has(e.tool)) noteTaskTool(s, e, r, Date.now(), since);
+    const touched = planTouched(s, e, call);
+    if (touched) takePlan(s, touched.path, await readText($, touched.path), { touch: touched.touch });
     $.ui.invalidate('ui.render');
   }
 }
 
+// A file's text, or null where it cannot be read (missing, over the engine's 4 MiB, refused).
+async function readText($, path) {
+  try {
+    return await $.fs.read(path);
+  } catch {
+    return null;
+  }
+}
+
 // The session's progress, one per loaded module.
 const ref = { s: freshState() };
 
@@ -405,9 +584,12 @@ export function registerProgress(on) {
   on('ui.render', { component: 'Pane' }, async ($, e, next) => {
     if (e.requestId !== PANE) return next(e);
     const redraw = () => $.ui.invalidate('ui.render');
+    const cols = Number.isFinite(e.props?.bodyColumns) ? e.props.bodyColumns : Infinity;
     const act = {
+      cols,
       select: (key) => { ref.s.selected = ref.s.selected === key ? null : key; redraw(); },
       fold: (key) => { if (!ref.s.open.delete(key)) ref.s.open.add(key); redraw(); },
+      foldPlan: () => { ref.s.planShut = !ref.s.planShut; redraw(); },
     };
     return draw($.ui.resolve(e), ref.s, Date.now(), act);
   });
@@ -425,3 +607,13 @@ export function progressTurnStarted(e) {
 export function progressTurnCompleted(e) {
   endTurn(ref.s, e, Date.now());
 }
+
+// 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.
+export function progressPlanTarget() {
+  return ref.s.planPath ? { path: ref.s.planPath, since: ref.s.touch } : null;
+}
+
+export function progressPlanRead(target, text) {
+  takePlan(ref.s, target.path, text, { since: target.since });
+}

package/hooks/register.mjs

@@ -16,7 +16,8 @@ import {
   registerGracefulPause,
 } from './graceful-pause.mjs';
 import {
-  SPEC as PROGRESS_SPEC, progressReset, progressTurnCompleted, progressTurnStarted, registerProgress,
+  SPEC as PROGRESS_SPEC, progressPlanRead, progressPlanTarget, progressReset, progressTurnCompleted, progressTurnStarted,
+  registerProgress,
 } from './progress.mjs';
 
 async function engineVersion($) {
@@ -45,6 +46,20 @@ async function registerCommands($) {
   await registerOne($, PROGRESS_SPEC);
 }
 
+// /progress's plan file, read again at a turn's start and end: a ralph PRD or a plan's checkboxes
+// change without a call this module sees. A read that fails keeps the plan as it was.
+async function rereadPlan($) {
+  const target = progressPlanTarget();
+  if (!target) return;
+  let text = null;
+  try {
+    text = await $.fs.read(target.path);
+  } catch {
+    /* missing or refused: the pane keeps the plan it read last */
+  }
+  progressPlanRead(target, text);
+}
+
 // A /graceful-pause request that came after its turn's last model request: a note voids it.
 async function voidLateRequest($, late) {
   try {
@@ -75,6 +90,7 @@ export const register = (on) => {
   on('turn.start', async ($, e, next) => {
     pauseTurnStarted(e);
     progressTurnStarted(e);
+    await rereadPlan($);
     $.ui.invalidate('ui.render');
     return next(e);
   });
@@ -83,6 +99,7 @@ export const register = (on) => {
     const late = pauseTurnCompleted(e);
     if (late) await voidLateRequest($, late);
     progressTurnCompleted(e);
+    await rereadPlan($);
     $.ui.invalidate('ui.render');
     return next(e);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaydash9999/banker-plugins",
-  "version": "0.16.2",
+  "version": "0.16.3",
   "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"