@kaydash9999/banker-plugins 0.18.0 → 0.19.1

package/hooks/progress.mjs

@@ -7,23 +7,29 @@
  * step for the work at hand. Under each step are the tool calls made while it was the step in
  * progress (a subagent's or a background agent's included), one level deep. A press on a step or
  * a call shows a short description under the list; a press on a step's arrow folds or unfolds its
- * calls.
+ * calls. Of two calls on the task list that overlap, the one begun later stands, and a list or a
+ * read begun before a change keeps what changed after it began; the engine's own order of
+ * overlapping calls is not something this module can see.
  *
- * 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.
+ * Claude 5 models get no task list tool in Claude Code 2.1.296 and 2.1.300 unless
+ * CLAUDE_CODE_ENABLE_TODO_TOOLS is set; older models and a background job get one. (Seen in a
+ * live 2.1.300 session with Haiku 5.5: with the variable TaskCreate, TaskUpdate, TaskList and
+ * TaskGet came and the pane showed their list; without it, none.) 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.
+ * `/progress` and `/progress show` toggle the pane, `on` and `off` set it. From Claude Code 2.1.289
+ * on the command is registered `immediate`, so it answers while a turn runs; an older engine gets it
+ * as a plain command. 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';
+import { cells, clip, fit, parsePlan, pick, planKind, readPrompt } from './progress-plan.mjs';
 
 const COMMAND = 'progress';
 const PANE = 'banker-progress';
@@ -91,6 +97,8 @@ const NOTICE = {
   completed: '백그라운드 작업 끝남', failed: '백그라운드 작업 실패', stopped: '백그라운드 작업 중지됨',
   killed: '백그라운드 작업 중지됨', message: '팀원 메시지',
 };
+// How a notice's turn ended other than with an answer, as the row under its step says it.
+const NOTICE_END = { aborted: '알림 처리 중단됨', refusal: '알림 처리 거절됨', error: '알림 처리 오류로 끝남' };
 // 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.
@@ -108,12 +116,17 @@ const tally = () => ({ calls: [], count: 0, failed: 0 });
 // The calls made while the task list has no task in progress.
 const looseStep = () => ({ key: 'loose', title: '작업 목록 밖의 작업', ...tally() });
 
-// `rev` counts the task changes (TaskCreate, TaskUpdate) taken in, to tell a stale TaskList or TaskGet.
+// `rev` counts the task changes (TaskCreate, TaskUpdate) taken in, and `order` the calls begun: a TaskList or
+// TaskGet begun before a change keeps what changed after it began, and of two calls that overlap the one begun later
+// stands. `marks` holds, per task id, the orders that decide it (markOf). `listAt` is the order of the TaskList the
+// 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.
+// `taken` is the touch the plan came from, to tell a read that a newer one overtook. `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,
-  plan: null, planPath: null, planShut: false, planOpen: new Set(), touch: 0, taken: 0 });
+  order: 0, marks: new Map(), listAt: 0, plan: null, planPath: null, planShut: false, planOpen: new Set(), touch: 0, taken: 0,
+  followed: null });
 
 const tail = (path) => String(path).split(/[\\/]/).filter(Boolean).slice(-2).join('/');
 const seconds = (ms) => {
@@ -179,7 +192,10 @@ function dropFinished(s) {
   s.loose = looseStep();
 }
 
+// A main turn's start. A subagent's, a fork's or a teammate's run (it carries an agentId; Claude Code 2.1.300
+// raises turn.start for them too) makes no step: its calls go under the step in progress.
 export function startTurn(s, e, now) {
+  if (e.agentId) return;
   const said = readPrompt(e.text);
   if (said.kind === 'notice') return noticeTurn(s, e, said, now);
   dropFinished(s);
@@ -187,13 +203,16 @@ export function startTurn(s, e, now) {
 }
 
 // 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.
+// step's own end as it was. A notice's turn that did not end with an answer (stopped, refused, an
+// error) adds a row saying so under the step. 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);
+    const how = pick(NOTICE_END, e.reason);
+    if (how) note(s, host, how, false, now);
     return;
   }
   const t = s.turns.find((x) => x.id === e.turnId) ?? s.turns.find((x) => x.id === AT_HAND && x.status === 'running');
@@ -275,17 +294,48 @@ function putTask(s, t, now) {
   while (s.tasks.size > MAX_STEPS) s.tasks.delete(overflow([...s.tasks.values()]).id);
 }
 
-function createTask(s, e, r, 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.
+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.
+function stale(s, id, since, order) {
+  if (order < s.listAt) return true;
+  const m = s.marks.get(id);
+  return Boolean(m) && ((m.changedRev ?? 0) > since || order < (m.seenAt ?? 0));
+}
+
+// An update begun after the create may end first (the ids are predictable): its status stands, and a delete wins.
+function createTask(s, e, r, now, { order }) {
   const id = r?.result?.task?.id;
   if (id === undefined) return;
-  putTask(s, { id: String(id), subject: e.subject, description: e.description, activeForm: e.activeForm, status: 'pending' }, now);
+  const m = s.marks.get(String(id));
+  const status = m && order < (m.statusAt ?? 0) ? m.status : 'pending';
+  if (status === 'deleted') return;
+  putTask(s, { id: String(id), subject: e.subject, description: e.description, activeForm: e.activeForm, status }, now);
 }
 
-// A task this module never saw (a list from before it loaded, or one another session shares) joins
-// the list while it is not done.
-function updateTask(s, e, r, now) {
+// The status a TaskUpdate left: the change it answers with, else the one it asked for.
+const updatedStatus = (e, r) => r?.result?.statusChange?.to ?? e.status;
+
+// A task this module never saw (a list from before it loaded, or one another session shares) joins the list while
+// it is not done. Of two status updates to one task, the one begun later stands; an update without a status (an
+// owner, a description) brings its words only.
+function updateTask(s, e, r, now, { order }) {
   const id = String(e.taskId);
-  const status = r?.result?.statusChange?.to ?? e.status;
+  const status = updatedStatus(e, r);
+  if (status !== undefined) {
+    const m = markOf(s, id);
+    if (order < (m.statusAt ?? 0)) return;
+    Object.assign(m, { statusAt: order, status });
+  }
   if (status === 'deleted') {
     s.tasks.delete(id);
     return;
@@ -294,28 +344,61 @@ function updateTask(s, e, r, now) {
   putTask(s, { id, subject: e.subject, description: e.description, activeForm: e.activeForm, status }, now);
 }
 
-// TaskList names the whole list, in its order: a task it leaves out is gone. A list whose every task
-// is completed is over, and only brings up to date the tasks still on the pane.
-function listTasks(s, _e, r, now, since) {
+// The status a list or a read begun at order shows for a task: a status update begun after it stands, also for a
+// task the pane did not hold then.
+const readStatus = (s, id, order, status) => {
+  const m = s.marks.get(id);
+  return m && order < (m.statusAt ?? 0) ? m.status : status;
+};
+
+// One task a TaskList names: as the pane holds it where it changed since the list began or a later-begun read
+// brought it, else as listed.
+function takeListed(s, before, t, { over, since, order, now }) {
+  const id = String(t.id);
+  const held = before.get(id);
+  if (held) s.tasks.set(id, held);
+  if (stale(s, id, since, order)) return;
+  const status = readStatus(s, id, order, t.status);
+  if (status === 'deleted') return;
+  if (held || !over) putTask(s, { id, subject: t.subject, status }, now);
+  markOf(s, id).seenAt = order;
+}
+
+// TaskList names the whole list, in its order: a task it leaves out is gone, unless it changed after the list
+// began. A list whose every task is completed is over, and only brings up to date the tasks still on the pane. A
+// list begun before one already taken in changes nothing.
+function listTasks(s, _e, r, now, { since, order }) {
   const listed = r?.result?.tasks;
-  if (since !== s.rev || !Array.isArray(listed)) return;
+  if (!Array.isArray(listed) || order < s.listAt) return;
+  s.listAt = order;
   const over = listed.every((t) => t.status === 'completed');
   const before = s.tasks;
+  const named = new Set(listed.map((t) => String(t.id)));
   s.tasks = new Map();
-  for (const t of listed) {
-    const id = String(t.id);
-    if (before.has(id)) s.tasks.set(id, before.get(id));
-    if (before.has(id) || !over) putTask(s, { id, subject: t.subject, status: t.status }, now);
+  for (const t of listed) takeListed(s, before, t, { over, since, order, now });
+  for (const [id, held] of before) {
+    if (named.has(id)) continue;
+    if (stale(s, id, since, order)) s.tasks.set(id, held);
+    else markOf(s, id).seenAt = order;
   }
 }
 
-// TaskGet reads one task: one it cannot find is gone, and a completed one off the pane stays off.
-function getTask(s, e, r, now, since) {
-  if (since !== s.rev) return;
+// TaskGet reads one task: one it cannot find, or finds deleted, is gone, and a completed one off the pane stays off. A
+// read older than what the pane holds of the task changes nothing. A read taken in makes an earlier-begun read of the
+// task stale, one that leaves the task off the pane too.
+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));
-  if (!t || (t.status === 'completed' && !s.tasks.has(String(t.id)))) return;
-  putTask(s, { id: String(t.id), subject: t.subject, description: t.description, status: t.status }, now);
+  if (t === null) {
+    s.tasks.delete(String(e.taskId));
+    markOf(s, String(e.taskId)).seenAt = order;
+  }
+  if (!t) return;
+  const id = String(t.id);
+  const status = readStatus(s, id, order, t.status);
+  if (status === 'deleted') s.tasks.delete(id);
+  else if (status !== 'completed' || s.tasks.has(id)) putTask(s, { id, subject: t.subject, description: t.description, status }, now);
+  markOf(s, id).seenAt = order;
 }
 
 const TASK_NOTES = {
@@ -329,15 +412,22 @@ const TASK_NOTES = {
 // A refused or failed call changes nothing: the task list stays as Claude Code holds it. A TaskUpdate
 // that changed nothing (an id it cannot find, a TaskCompleted hook that blocks) answers
 // `success: false` without isError.
-// TaskList and TaskGet run beside other calls: one that read the list before a change landed (`since`,
-// the count when it started, is behind) is stale and changes nothing.
+// TaskList and TaskGet run beside other calls (`since` is the count of changes when one began, `order` its place
+// among the calls begun): what changed after it began, or what a later-begun call already brought, stays.
 const refused = (r) => Boolean(r?.deny || r?.isError || r?.result?.success === false);
 const CHANGES = new Set(['TaskCreate', 'TaskUpdate']);
+// The task a TaskCreate or TaskUpdate changed, or undefined where the answer names none.
+const changedId = (e, r) => (e.tool === 'TaskCreate' ? r?.result?.task?.id : e.taskId);
 
-export function noteTaskTool(s, e, r, now, since) {
+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 ?? s.rev);
-  if (CHANGES.has(e.tool)) s.rev += 1;
+  TASK_NOTES[e.tool]?.(s, e, r, now, { since, order });
+  if (!CHANGES.has(e.tool)) return;
+  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;
 }
 
 // The list a to-do call sent, each item's words cleaned, or what is wrong with it.
@@ -369,12 +459,13 @@ export function answerTodo(s, e, now, paneOpen = true) {
 
 // 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.
+// `own` is a write by the session itself; `weak` a review round or open questions beside a 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;
+  const kind = planKind(path);
+  if (!call?.ok || !PLAN_TOUCH.has(e.tool) || !kind || (e.tool === 'Read' && e.agentId)) return null;
   s.touch += 1;
-  return { path, touch: s.touch, own: !e.agentId && e.tool !== 'Read' };
+  return { path, touch: s.touch, own: !e.agentId && e.tool !== 'Read', weak: kind === 'weak' };
 }
 
 function parsed(path, text) {
@@ -393,10 +484,17 @@ function current(s, path, { touch, since }) {
   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);
+// 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
+// such place, since any plan replaces it.
+const stepless = (s, path, plan, read) => path !== s.planPath && !plan.total && Boolean(s.plan?.total) && !read.own && planKind(s.planPath) !== 'weak';
+
+// Whether what was read stays off the pane: no plan; a review round or open questions while the pane shows another
+// 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 && Boolean(s.plan) && read.weak === true)
+  || stepless(s, path, plan, read);
 
 // 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()) {
@@ -415,7 +513,7 @@ export function takePlan(s, path, text, read = {}) {
   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 (read.touch !== undefined && !read.weak) s.taken = read.touch; // a weak plan does not make an older touch late
   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)));
@@ -442,6 +540,9 @@ export function steps(s) {
   return s.loose.calls.length ? [...items, { ...s.loose, status: looseStatus(s, items) }] : items;
 }
 
+// The key of the step in progress (a task or a to-do item in progress, or the prompt that runs), or null.
+const runningKey = (s) => [...steps(s)].reverse().find((t) => ['in_progress', 'running'].includes(statusOf(t)))?.key ?? null;
+
 function callCount(step) {
   return `도구 호출 ${step.count}회${step.failed ? `(실패 ${step.failed}회)` : ''}`;
 }
@@ -655,6 +756,7 @@ export async function runProgress($, args) {
     if (pane) await $.ui.close({ id: PANE });
     return {};
   }
+  ref.s.followed = null; // before the open: the engine may draw the pane before the open answers
   await showPane($, pane);
   await offerTodo($);
   return {};
@@ -676,6 +778,7 @@ export const SPEC = { name: COMMAND, description: '진행 상황 패널을 켜
 async function watchCall($, e, next) {
   const s = ref.s;
   const since = s.rev;
+  const order = ++s.order;
   const call = startCall(s, e, Date.now());
   let r = { isError: true };
   try {
@@ -683,9 +786,9 @@ async function watchCall($, e, next) {
     return r;
   } finally {
     endCall(call, r, Date.now());
-    if (TASK_TOOLS.has(e.tool)) noteTaskTool(s, e, r, Date.now(), since);
+    if (TASK_TOOLS.has(e.tool)) noteTaskTool(s, e, r, Date.now(), since, order);
     const touched = planTouched(s, e, call);
-    if (touched) takePlan(s, touched.path, await readText($, touched.path), { touch: touched.touch, own: touched.own });
+    if (touched) takePlan(s, touched.path, await readText($, touched.path), { touch: touched.touch, own: touched.own, weak: touched.weak });
     $.ui.invalidate('ui.render');
   }
 }
@@ -708,6 +811,41 @@ async function readText($, path) {
 // The session's progress, one per loaded module.
 const ref = { s: freshState() };
 
+// How long a move waits, and how many times it asks. The row a change brings is drawn after the invalidate that came
+// with it; a move asked before that is refused ("no element of its own is drawn under that key" in 2.1.300).
+const FOLLOW_WAIT_MS = 100;
+const FOLLOW_TRIES = 4;
+
+// Brings the step in progress into the pane's window as the pane draws, when that step changed (a task started, a
+// new prompt) or the pane was opened again: in a long list it can sit below the window. Only a drawn pane asks, so a
+// closed one or a tab behind another asks nothing. `nearest` moves nothing while its row shows, and the person's own
+// scrolling stands until the next change. An engine without the move changes nothing.
+function follow($) {
+  const key = runningKey(ref.s);
+  if (!key || key === ref.s.followed) return;
+  ref.s.followed = key;
+  followSoon($, key, FOLLOW_TRIES);
+}
+
+// Asks for the move after a wait, and again while the row is not drawn yet. A later change of the step in progress,
+// or any other refusal (no surface, the person moved the window meanwhile), ends it.
+function followSoon($, key, tries) {
+  try {
+    $.clock.after(FOLLOW_WAIT_MS, async () => {
+      if (ref.s.followed !== key) return;
+      let answer;
+      try {
+        answer = await $.ui.scroll({ to: { key: `row-${key}` }, in: PANE, block: 'nearest' });
+      } catch {
+        return; /* an engine without $.ui.scroll */
+      }
+      if (tries > 1 && /\bdrawn\b/.test(answer?.deny ?? '')) followSoon($, key, tries - 1);
+    });
+  } catch {
+    /* an engine without $.clock */
+  }
+}
+
 // The command and the events only this feature hooks. register.mjs hooks the events every banker
 // feature shares (the engine takes one hook per event from the module) and calls the functions
 // below for them. The fallback's name is hooked too: where mods run, `/banker:progress` toggles
@@ -735,6 +873,7 @@ 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');
+    follow($);
     const cols = Number.isFinite(e.props?.bodyColumns) ? e.props.bodyColumns : Infinity;
     const act = {
       cols,

package/hooks/register.mjs

@@ -5,9 +5,11 @@
  *
  * The engine reads the module's source before it runs it: each `on("<event>", hook)` names its
  * event as a string literal, an event without a matcher is hooked once in the whole module (its
- * imported files included), and `$` goes only to functions declared in the file that holds it.
- * So each feature (graceful-pause.mjs, progress.mjs) hooks the events only it needs, and this
- * file hooks the four they share: it calls the features' plain functions for them and makes the
+ * imported files included), and `$` goes only to functions declared in the file that holds it
+ * (2.1.300 also takes a function imported from the module's own files; an older engine refuses
+ * the whole module, so this file keeps to the older rule, and a test holds it). So each feature
+ * (graceful-pause.mjs, progress.mjs) hooks the events only it needs, and this file hooks the
+ * four they share: it calls the features' plain functions for them and makes the
  * engine calls itself, the module's command registrations among them. The engine shows a
  * `$.ui.log` line under the plugin's name, so the lines here do not repeat it.
  */
@@ -37,13 +39,18 @@ async function registerOne($, spec) {
   }
 }
 
-// /graceful-pause from 2.1.289 on (an older engine gets one line saying why), /progress wherever
-// mods run. A name the engine refuses is logged and the other still registers.
+// A command spec without `immediate`, for an engine where answering at once was not seen to work.
+const withoutImmediate = ({ immediate: _immediate, ...spec }) => spec;
+
+// /graceful-pause from 2.1.289 on (an older engine gets one line saying why). /progress wherever mods run, as a
+// command that answers at once (immediate) only from 2.1.289 on, where that was seen to work; below it, or with no
+// version, it answers when the turn ends. A name the engine refuses is logged and the other still registers.
 async function registerCommands($) {
   const version = await engineVersion($);
-  if (atLeast(version, MIN_ENGINE)) await registerOne($, PAUSE_SPEC);
+  const recent = atLeast(version, MIN_ENGINE);
+  if (recent) await registerOne($, PAUSE_SPEC);
   else $.ui.log(`/${PAUSE} 는 Claude Code ${MIN_ENGINE.join('.')} 이상에서만 켭니다 (이 엔진: ${version || '버전 미상'})`);
-  await registerOne($, PROGRESS_SPEC);
+  await registerOne($, recent ? PROGRESS_SPEC : withoutImmediate(PROGRESS_SPEC));
 }
 
 // /progress's plan file, read again at a turn's start and end: a ralph PRD or a plan's checkboxes
@@ -90,6 +97,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
     return next(e);
   });
 

package/hooks/telemetry-count-skill.mjs

@@ -22,11 +22,7 @@
  */
 import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
 
-import { configDir, countingActive, recordUsedSkill, USAGE_LOG_PATH, LOG_MAX_LINES } from '../bin/lib/telemetry-config.mjs';
-
-// banker:<name> 전체 일치 - 이름 문자열 자체를 검증한다(TAB/개행 등 이질 문자가 섞여
-// usage-log 의 `name\thour` 형식을 깨는 것을 막는다). i 플래그는 매칭만 관대하게(실제 이름은 소문자).
-const NAME_RE = /^banker:[a-z0-9_-]+$/i;
+import { configDir, countingActive, recordUsedSkill, USAGE_LOG_PATH, LOG_MAX_LINES, SKILL_NAME_RE } from '../bin/lib/telemetry-config.mjs';
 
 function readStdin() {
   return new Promise((resolvePromise, rejectPromise) => {
@@ -39,11 +35,13 @@ function readStdin() {
 }
 
 // PostToolUse(Skill) payload 에서 모델이 자동 호출한 banker:<name> 스킬 이름을 추출한다.
+// 이름은 telemetry-config 의 SKILL_NAME_RE 전체 일치로 검증한다(TAB, 개행 같은 글자가 usage-log 의
+// `name\thour` 형식을 깨지 않게).
 // 주 소스는 tool_input.skill, 없거나 미매치면 보조로 tool_response.commandName 을 시도한다.
 function extractName(payload) {
   const candidates = [payload?.tool_input?.skill, payload?.tool_response?.commandName];
   for (const c of candidates) {
-    if (typeof c === 'string' && NAME_RE.test(c)) return c;
+    if (typeof c === 'string' && SKILL_NAME_RE.test(c)) return c;
   }
   return null;
 }

package/hooks/telemetry-count.mjs

@@ -22,11 +22,7 @@
  */
 import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
 
-import { configDir, countingActive, recordUsedSkill, USAGE_LOG_PATH, LOG_MAX_LINES } from '../bin/lib/telemetry-config.mjs';
-
-// banker:<name> 전체 일치 - 이름 문자열 자체를 검증한다(TAB/개행 등 이질 문자가 섞여
-// usage-log 의 `name\thour` 형식을 깨는 것을 막는다). i 플래그는 매칭만 관대하게(실제 이름은 소문자).
-const NAME_RE = /^banker:[a-z0-9_-]+$/i;
+import { configDir, countingActive, recordUsedSkill, USAGE_LOG_PATH, LOG_MAX_LINES, SKILL_NAME_RE } from '../bin/lib/telemetry-config.mjs';
 
 function readStdin() {
   return new Promise((resolvePromise, rejectPromise) => {
@@ -39,11 +35,13 @@ function readStdin() {
 }
 
 // UserPromptExpansion payload 에서 사용자가 직접 호출한 banker:<name> 이름을 추출한다.
+// 이름은 telemetry-config 의 SKILL_NAME_RE 전체 일치로 검증한다(TAB, 개행 같은 글자가 usage-log 의
+// `name\thour` 형식을 깨지 않게).
 // command_source 가 'plugin' 이고 command_name 이 banker:<name> 형식일 때만 반환, 그 외 null.
 function extractName(payload) {
   if (payload?.command_source !== 'plugin') return null;
   const name = payload?.command_name;
-  return (typeof name === 'string' && NAME_RE.test(name)) ? name : null;
+  return (typeof name === 'string' && SKILL_NAME_RE.test(name)) ? name : null;
 }
 
 // 파일의 개행 개수 = 줄 수(각 append 가 끝에 개행을 붙이므로). 없거나 읽기 실패면 0.