@kaydash9999/banker-plugins 0.16.2 → 0.17.0

package/hooks/progress.mjs

@@ -9,11 +9,22 @@
  * 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). Opening the pane offers the model one of its own
+ * (`mcp__banker__todo`, TodoWrite's shape) where it has none, and the list it sends is the steps.
+ * Above them the pane shows the plan file the session touched last (progress-plan.mjs reads it):
+ * the whole plan as a tree that folds like a toggle list, its sections folded at first.
+ * 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,14 +33,64 @@ const HINT = '단계나 하위 항목을 누르면 설명이 여기에 나옵니
 const MAX_STEPS = 50;
 const MAX_KEPT_CALLS = 200;
 const MAX_SHOWN_CALLS = 30;
+// Rows of the plan's tree shown at most, and the characters they hold: the engine draws 100,000
+// characters a drawing and blanks the rest, so a long plan must leave room for the steps and the
+// description below it. One line past them says how many more rows there are.
+const MAX_TREE_ROWS = 300;
+const MAX_TREE_TEXT = 40000;
+// 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';
+// The pane's own to-do tool. The model calls it as `mcp__<plugin>__todo`; it sends the whole list
+// each time, as TodoWrite does. Claude Code's own list tools, where the model has one, take its place.
+const TODO = 'todo';
+export const TODO_TOOL = `mcp__banker__${TODO}`;
+const LIST_TOOLS = new Set(['TodoWrite', 'TaskCreate']);
+const TODO_STATUS = new Set(['pending', 'in_progress', 'completed']);
+const TODO_SPEC = {
+  name: TODO,
+  description: '진행 상황 패널(/progress)이 켜져 있고, 사람이 이 패널로 지금 하는 일과 남은 일을 본다. '
+    + '다음 경우에는 일을 시작하기 전에 이 도구로 할 일 목록 전체를 보낸다: 3단계 이상인 작업, 파일 여러 개를 '
+    + '만들거나 고치는 작업, 사용자가 여러 가지를 한꺼번에 시킨 경우. 항목을 시작할 때 in_progress 로, 끝나면 '
+    + '바로 completed 로 바꿔 목록 전체를 다시 보낸다. 상태가 바뀔 때만 보내고 같은 목록을 다시 보내지 않는다. '
+    + 'in_progress 는 하나만 둔다. 한 단계로 끝나는 일, 질문에 답하기, 대화에는 쓰지 않는다. '
+    + '패널이 꺼져 있다고 답하면 다시 부르지 않는다.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      todos: {
+        type: 'array',
+        description: '할 일 목록 전체, 하는 순서대로',
+        items: {
+          type: 'object',
+          properties: {
+            content: { type: 'string', description: '할 일 한 줄' },
+            status: { type: 'string', enum: [...TODO_STATUS] },
+            activeForm: { type: 'string', description: '진행 중일 때 보일 문구(선택)' },
+          },
+          required: ['content', 'status'],
+          additionalProperties: false,
+        },
+      },
+    },
+    required: ['todos'],
+    additionalProperties: false,
+  },
+};
 // Bookkeeping calls: they become steps, not calls under a step.
-const TASK_TOOLS = new Set(['TaskCreate', 'TaskUpdate', 'TaskGet', 'TaskList', 'TodoWrite']);
+const TASK_TOOLS = new Set(['TaskCreate', 'TaskUpdate', 'TaskGet', 'TaskList', 'TodoWrite', TODO_TOOL]);
 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 +109,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 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.
+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, planOpen: new Set(), 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 +130,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 +180,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 +209,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 +340,89 @@ export function noteTaskTool(s, e, r, now, since) {
   if (CHANGES.has(e.tool)) s.rev += 1;
 }
 
+// The list a to-do call sent, each item's words cleaned, or what is wrong with it.
+export function readTodos(todos) {
+  if (!Array.isArray(todos)) return 'todos 는 할 일의 배열이어야 합니다.';
+  if (todos.length > MAX_STEPS) return `할 일은 ${MAX_STEPS}개까지 보낼 수 있습니다.`;
+  const out = [];
+  for (const t of todos) {
+    const content = typeof t?.content === 'string' ? clip(t.content, 200) : '';
+    if (!content || !TODO_STATUS.has(t.status)) return '항목마다 content(할 일)와 status(pending, in_progress, completed 중 하나)가 있어야 합니다.';
+    out.push({ content, status: t.status, activeForm: typeof t.activeForm === 'string' ? clip(t.activeForm, 80) : undefined });
+  }
+  return out;
+}
+
+// What the to-do tool answers, in words that say what happened. The list goes to the pane as
+// TodoWrite's would, kept while the pane is closed too, so it shows when the pane opens again; the
+// model is told it need not send more meanwhile. A subagent's list is its own, as with TodoWrite, and
+// leaves the session's as it is. A list that is not one is refused, so the model reads why.
+export function answerTodo(s, e, now, paneOpen = true) {
+  const todos = readTodos(e.todos);
+  if (typeof todos === 'string') return { deny: todos };
+  if (e.agentId) return { result: '하위 에이전트의 할 일 목록은 진행 상황 패널에 보이지 않습니다. 이 도구를 부르지 않아도 됩니다.' };
+  writeTodos(s, { todos }, now);
+  if (!paneOpen) return { result: '진행 상황 패널이 꺼져 있습니다. 목록은 받아 두었고, 패널이 다시 켜질 때까지 이 도구를 부르지 않아도 됩니다.' };
+  const going = todos.filter((t) => t.status === 'in_progress').length;
+  return { result: `진행 상황 패널에 할 일 ${todos.length}개를 보였습니다(진행 중 ${going}개).` };
+}
+
+// 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).
+// `own` is a write by the session itself.
+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, own: !e.agentId && e.tool !== 'Read' };
+}
+
+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;
+}
+
+// Whether what was read stays off the pane: no plan, or a file with no steps in place of a plan that
+// has some, unless the session wrote it itself (an agent's review written beside a plan, or a note the
+// session only read, does not push the plan away; a plan the session writes is the plan, steps or not).
+const keepsOff = (s, path, plan, read) => !plan || (path !== s.planPath && !plan.total && Boolean(s.plan?.total) && !read.own);
+
+// The ids in a tree, to keep the unfolded ones that are still there when a plan is read again.
+function treeIds(nodes, out = new Set()) {
+  for (const n of nodes) {
+    out.add(n.id);
+    treeIds(n.children, out);
+  }
+  return out;
+}
+
+// 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.
+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) s.taken = read.touch;
+  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 };
+}
+
 // ── what the pane shows ──────────────────────────────────────────────────────
 
 // Nothing seen yet: one step that says so, with no state word beside it.
@@ -257,7 +431,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 +447,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 +461,155 @@ 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 done = plan.hasStates ? `, 완료 ${plan.done}개` : '';
+  const count = plan.total ? ` 단계 ${plan.total}개${done}.` : '';
+  const cut = plan.cut ? ' 파일이 길어 앞부분만 읽었습니다.' : '';
+  const many = plan.treeCut ? ' 항목이 많아 앞부분만 보입니다.' : '';
+  return `${where}.${count}${cut}${many}`;
+}
+
+// What the person pressed last, while it is still on the pane: the plan, a step, or a call under one.
+// A plan's sections fold where they are pressed, and say nothing more below.
 function pressed(s) {
+  if (s.plan && s.selected === 'plan') return { key: 'plan', isPlan: true };
   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);
+  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 pane's tree. `ui` is the surface's element table; `act` holds what a press does.
+// The plan's row: its title in bold (a Button draws its Text children in place of its label) and,
+// where its steps say, 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.tree.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] })] }),
+    ...(count ? [Text({ children: [count], dimColor: true })] : []),
+  ] });
+}
+
+// A node's state on the pane: its checkbox's word, or how many of the checkboxes under it are done.
+const nodeState = (n) => n.count ?? PLAN_STATUS[n.status] ?? '';
+const NODE_STYLE = { head: { bold: true }, story: { bold: true }, 'code-line': { dimColor: true } };
+// A part of a row that keeps its width while the words beside it wrap.
+const fixed = (ui, children) => ui.Box({ flexShrink: 0, children });
+
+// A node's row: an arrow where it holds nodes, its number or dash, its words (wrapping on the pane's
+// width; a press on them folds it too) and its state.
+function nodeRow(ui, s, n, depth, act) {
+  const { Box, Text, Button } = ui;
+  const holds = n.children.length > 0;
+  const fold = () => act.foldNode(n.id);
+  const words = Text({ children: [n.text], wrap: 'wrap', ...(pick(NODE_STYLE, n.kind) ?? {}) });
+  const state = nodeState(n);
+  return Box({ key: `row-${n.id}`, flexDirection: 'row', columnGap: 1, paddingLeft: depth * 2, children: [
+    holds ? Button({ key: `arrow-${n.id}`, label: s.planOpen.has(n.id) ? '▾' : '▸', plain: true, onPress: fold }) : Text({ children: [' '] }),
+    ...(n.marker ? [fixed(ui, [Text({ children: [n.marker] })])] : []),
+    holds ? Button({ key: n.id, label: n.text, plain: true, onPress: fold, children: [words] }) : words,
+    ...(state ? [fixed(ui, stateWord(ui, state, n.status === 'in_progress'))] : []),
+  ] });
+}
+
+// The plan's nodes as rows, what a folded node holds left out: rows while they stay within
+// MAX_TREE_ROWS and MAX_TREE_TEXT characters, then how many more would show.
+function treeRows(ui, s, act) {
+  const rows = [];
+  let more = 0;
+  let used = 0;
+  const visit = (nodes, depth) => {
+    for (const n of nodes) {
+      used += n.text.length + (n.marker?.length ?? 0);
+      if (!more && rows.length < MAX_TREE_ROWS && used <= MAX_TREE_TEXT) rows.push(nodeRow(ui, s, n, depth, act));
+      else more += 1;
+      if (n.children.length && s.planOpen.has(n.id)) visit(n.children, depth + 1);
+    }
+  };
+  visit(s.plan.tree, 1);
+  return { rows, more };
+}
+
+// The plan's rows: its title, then its tree unless folded, then a line for the rows past the first 300.
+function planRows(ui, s, act) {
+  const { Box, Text } = ui;
+  if (!s.plan) return [];
+  const rows = [planHead(ui, s, act)];
+  if (!s.planShut) {
+    const tree = treeRows(ui, s, act);
+    rows.push(...tree.rows);
+    if (tree.more) rows.push(Box({ key: 'plan-more', paddingLeft: 2, children: [Text({ children: [`외 ${tree.more}줄`], dimColor: true })] }));
+    if (s.plan.cut || s.plan.treeCut) rows.push(Box({ key: 'plan-cut', paddingLeft: 2, children: [Text({ children: ['계획이 길어 앞부분만 보입니다'], 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));
@@ -350,14 +627,36 @@ async function showPane($, pane) {
   else if (!pane.isShown) await $.ui.open({ id: PANE, title: TITLE, focus: true });
 }
 
+// Offers the model the to-do tool where it has no task list tool of Claude Code's and the tool is not
+// there yet. An engine without a tool list offers nothing; a registration the engine refuses (`--bare`,
+// a user MCP server of the same name) is said in one line, and the pane goes on with prompts as steps.
+async function offerTodo($) {
+  let tools;
+  try {
+    tools = await $.tool.list();
+  } catch {
+    return;
+  }
+  if (tools.some((t) => LIST_TOOLS.has(t.name) || t.name === TODO_TOOL)) return;
+  try {
+    await $.tool.register(TODO_SPEC);
+  } catch (e) {
+    $.ui.log(`할 일 도구를 등록하지 못했습니다(${clip(e?.message ?? e, 120)}). 진행 상황 패널은 요청을 단계로 보입니다.`);
+  }
+}
+
 // `show` (the default) toggles what the person sees; `on` and `off` set the pane whatever it was.
+// Opening it offers the to-do tool, from the next prompt on.
 export async function runProgress($, args) {
   const want = String(args ?? '').trim().toLowerCase() || 'show';
   if (!['show', 'on', 'off'].includes(want)) return { text: USAGE };
   const pane = (await $.ui.panes()).find((p) => p.id === PANE);
   if (want === 'off' || (want === 'show' && pane?.isShown)) {
     if (pane) await $.ui.close({ id: PANE });
-  } else await showPane($, pane);
+    return {};
+  }
+  await showPane($, pane);
+  await offerTodo($);
   return {};
 }
 
@@ -385,10 +684,27 @@ 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, own: touched.own });
     $.ui.invalidate('ui.render');
   }
 }
 
+// A file's text, or null where it cannot be read (missing, over the engine's 4 MiB, refused) or is no
+// plain file: a plan path that leads to a pipe or a device would hold the read, and the hooks worker.
+async function readText($, path) {
+  try {
+    if ((await $.fs.stat(path)).kind !== 'file') return null;
+  } catch {
+    /* an engine without stat, or nothing there: the read below tells */
+  }
+  try {
+    return await $.fs.read(path);
+  } catch {
+    return null;
+  }
+}
+
 // The session's progress, one per loaded module.
 const ref = { s: freshState() };
 
@@ -402,12 +718,30 @@ export function registerProgress(on) {
   on('command.run', { command: 'banker:progress' }, async ($, e) => runProgress($, e.args)).catch(commandFailed);
   // Every tool call passes here: a fault in this hook leaves the call as if the hook were absent.
   on('tool.call', async ($, e, next) => watchCall($, e, next)).catch(() => undefined);
+  // The to-do tool: this hook answers it, and its schema is listed up front rather than behind
+  // ToolSearch, so the model sees it without asking.
+  on('tool.call', { tool: TODO_TOOL }, async ($, e) => {
+    let open = true;
+    try {
+      open = (await $.ui.panes()).some((p) => p.id === PANE);
+    } catch {
+      /* the pane list failed: take the list as for an open pane rather than refuse it */
+    }
+    const answer = answerTodo(ref.s, e, Date.now(), open);
+    $.ui.invalidate('ui.render');
+    return answer;
+  }).catch(() => ({ deny: '진행 상황 패널이 할 일 목록을 받지 못했습니다.' }));
+  on('tool.describe', { tool: TODO_TOOL }, async (_$, e, next) => ({ ...(await next(e)), isDeferred: false })).catch(() => undefined);
   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(); },
+      foldNode: (id) => { if (!ref.s.planOpen.delete(id)) ref.s.planOpen.add(id); redraw(); },
     };
     return draw($.ui.resolve(e), ref.s, Date.now(), act);
   });
@@ -425,3 +759,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,26 @@ 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, and a path that
+// now leads to no plain file (a pipe would hold the read) is not read.
+async function rereadPlan($) {
+  const target = progressPlanTarget();
+  if (!target) return;
+  try {
+    if ((await $.fs.stat(target.path)).kind !== 'file') return;
+  } catch {
+    /* an engine without stat, or nothing there: the read below tells */
+  }
+  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 +96,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 +105,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.17.0",
   "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"

package/skills/3d-intro-build/references/assemble.mjs

@@ -280,8 +280,16 @@ export function assemble({ projectDir, outDir, manifestPath } = {}) {
 // ---- CLI --------------------------------------------------------------------
 
 // Run only when invoked directly (not when imported by a test/other module).
-const invokedDirectly = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
-if (invokedDirectly) {
+// Node resolves links for import.meta.url but not for process.argv[1], so both go through realpath:
+// compared as given, a run through a linked folder would exit 0 without doing anything.
+const invokedDirectly = () => {
+  try {
+    return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+};
+if (invokedDirectly()) {
   const argv = process.argv.slice(2);
   let projectDir = null, outDir = null, manifestPath = null;
   for (let i = 0; i < argv.length; i++) {