@kaydash9999/banker-plugins 0.18.0 → 0.19.0

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,46 @@ 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: the task changed
+// after it began (a delete too), or a later-begun read already brought it.
+function stale(s, id, since, order) {
+  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 +342,55 @@ 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) {
+// Whether the pane changed a task (a delete too) after a list of it began.
+const changedAfter = (s, id, since) => (s.marks.get(id)?.changedRev ?? 0) > 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) && changedAfter(s, id, since)) s.tasks.set(id, held);
 }
 
-// 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 is gone, and a completed one off the pane stays off. A read older than
+// what the pane holds of the task changes nothing.
+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) return;
+  const id = String(t.id);
+  const status = readStatus(s, id, order, t.status);
+  if (status === 'deleted' || (status === 'completed' && !s.tasks.has(id))) return;
+  putTask(s, { id, subject: t.subject, description: t.description, status }, now);
+  markOf(s, id).seenAt = order;
 }
 
 const TASK_NOTES = {
@@ -329,15 +404,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 +451,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 +476,13 @@ 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);
+// 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)
+  || (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()) {
@@ -442,6 +528,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 +744,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 +766,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 +774,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 +799,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 +861,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

package/hooks/update-checkin.mjs

@@ -158,42 +158,44 @@ function fetchSkillChangesMap(url) {
   });
 }
 
-async function main() {
-  if (!countingActive()) return; // 미활성 - 무동작(로그 미변경).
-  const url = endpoint();
-  if (!url) return;              // 엔드포인트 없음 - 무동작(로그 미변경).
-
-  // 로그 없음도 유효한 체크인(설치 펄스 + 알림 fetch 겸함): 빈 counts 로 진행한다.
+// 보낼 본문. PII/IP/지속ID 없음: version + os(플랫폼 계열) + counts(스킬별 x 시간대)뿐.
+// 로그 없음도 유효한 체크인(설치 펄스 + 알림 fetch 겸함): 빈 counts 로 진행한다.
+function checkinBody() {
   let raw = '';
   try { raw = readFileSync(USAGE_LOG_PATH, 'utf8'); } catch { raw = ''; }
+  return JSON.stringify({ version: installedVersion() || 'unknown', os: process.platform, counts: aggregate(raw) });
+}
 
-  // PII/IP/지속ID 없음: version + os(플랫폼 계열) + counts(스킬별 x 시간대)뿐.
-  const payload = JSON.stringify({
-    version: installedVersion() || 'unknown',
-    os: process.platform,
-    counts: aggregate(raw),
-  });
-  const responseBody = await post(url, payload);
-
-  // 응답의 latest 로 공유 update-check 캐시를 갱신(알림 겸함). 없으면 캐시 미변경.
-  // update-fetch 처럼 notified:null 재무장을 하지 않아도 등가다: dedupe 판정이 notified===latest
-  // (update-notify)라 전진 버전에서 구 notified 는 항상 신 latest 와 달라 재고지가 정상 발화하고,
-  // count-default-on 은 이 훅만·npm 배포는 update-fetch 만 써 같은 캐시를 겹쳐 쓰지 않는다.
+// 응답의 latest 로 공유 update-check 캐시를 갱신(알림 겸함). 없으면 캐시 미변경.
+// update-fetch 처럼 notified:null 재무장을 하지 않아도 등가다: dedupe 판정이 notified===latest
+// (update-notify)라 전진 버전에서 구 notified 는 항상 신 latest 와 달라 재고지가 정상 발화하고,
+// count-default-on 은 이 훅만·npm 배포는 update-fetch 만 써 같은 캐시를 겹쳐 쓰지 않는다.
+async function refreshUpdateCache(responseBody) {
   const latest = extractLatest(responseBody);
-  if (latest) {
-    // 개인화용: 변경-스킬 매니페스트를 best-effort GET(실패 시 changedSkills 생략, 기존 값 보존).
-    const changesUrl = process.env.BANKER_SKILL_CHANGES_URL || SKILL_CHANGES_URL; // 테스트 주입용 override.
-    const map = await fetchSkillChangesMap(changesUrl);
-    const patch = { latest, checkedAt: Date.now() };
-    if (map) patch.changedSkills = changedSkillsBetween(map, installedVersion(), latest);
-    try { writeUpdateCache(patch); } catch { /* best-effort */ }
-  }
+  if (!latest) return;
+  // 개인화용: 변경-스킬 매니페스트를 best-effort GET(실패 시 changedSkills 생략, 기존 값 보존).
+  const changesUrl = process.env.BANKER_SKILL_CHANGES_URL || SKILL_CHANGES_URL; // 테스트 주입용 override.
+  const map = await fetchSkillChangesMap(changesUrl);
+  const patch = { latest, checkedAt: Date.now() };
+  if (map) patch.changedSkills = changedSkillsBetween(map, installedVersion(), latest);
+  try { writeUpdateCache(patch); } catch { /* best-effort */ }
+}
 
-  // 전송 시도 후(성공/실패 무관) 로그를 비워 24h 윈도우로 상한(배치 유실 허용).
+// 전송 시도 후(성공/실패 무관) 로그를 비워 24h 윈도우로 상한(배치 유실 허용).
+function resetLog() {
   try { writeFileSync(USAGE_LOG_PATH, ''); } catch { /* best-effort */ }
   try { writeFileSync(LAST_FLUSH_PATH, new Date().toISOString()); } catch { /* best-effort */ }
 }
 
+async function main() {
+  if (!countingActive()) return; // 미활성 - 무동작(로그 미변경).
+  const url = endpoint();
+  if (!url) return;              // 엔드포인트 없음 - 무동작(로그 미변경).
+  const responseBody = await post(url, checkinBody());
+  await refreshUpdateCache(responseBody);
+  resetLog();
+}
+
 main()
   .catch(() => {}) // 어떤 예외도 삼킨다.
   .finally(() => process.exit(0));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaydash9999/banker-plugins",
-  "version": "0.18.0",
+  "version": "0.19.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/anti-drm/SKILL.md

@@ -43,9 +43,9 @@ argument-hint: "on | off | status | config"
 
    | `- 설정:` 줄 | 다음 |
    |---|---|
-   | `없음` | 아래 "질문" 을 한 뒤 `on --runtime <런타임> --deny "<금지 목록>" --alt "<대체 목록>" --tsv <tab 또는 comma>` |
+   | `없음` | 아래 "질문" 을 한 뒤 "설정 넘기기" 대로 `on --runtime <런타임> --stdin` 실행 |
    | 파일 경로 | `on --runtime <런타임>` |
-   | `올바르지 않음` | 이유를 전하고 `config` 절차를 따름 |
+   | `올바르지 않음` | 이유를 전하고 "질문" 으로 설정을 다시 정한 뒤 `없음` 행과 같은 명령 실행 |
 
 3. 성공하면 출력의 `적용할 규칙:` 아래 규칙을 이 세션에 바로 적용. 다음 세션부터는 자동 적용
 
@@ -63,7 +63,7 @@ argument-hint: "on | off | status | config"
 
 1. `status` 로 지금 설정을 봄
 2. 지금 값을 함께 보이며 아래 "질문" 을 함
-3. `config --deny "<금지 목록>" --alt "<대체 목록>" --tsv <tab 또는 comma>` 실행
+3. "설정 넘기기" 대로 `config --stdin` 실행
 4. 이 런타임이 켜져 있으면 출력의 `적용할 규칙:` 아래 규칙을 이 세션에 바로 적용
 
 ## 질문
@@ -100,12 +100,31 @@ argument-hint: "on | off | status | config"
 2. 직접 입력은 쉼표나 공백으로 나눔
 3. 낱말마다 `^\.?[A-Za-z0-9]+$` 를 만족해야 함. 아니면 그 값을 보이고 다시 물음
 4. 금지와 대체에 같은 확장자가 있으면 다시 물음
-5. 셸에는 정규화한 확장자만 넘김
+5. 정규화한 확장자만 넘김
    - 소문자로 바꿈
    - 앞에 점이 없으면 붙임
-   - 쉼표로 이어 큰따옴표로 감쌈. 예: `--deny ".txt,.pdf"`
+   - 쉼표로 이어 "설정 넘기기" 의 `deny=`, `alt=` 줄에 씀
 6. 스크립트가 거부하면 그 메시지를 전하고 다시 물음
 
+### 설정 넘기기
+
+- 설정 값은 명령줄 인자가 아니라 표준 입력으로 넘김. 따옴표 친 heredoc 안의 글은 셸이 해석하지 않음
+
+  ```bash
+  node "<이 스킬 디렉터리 절대경로>/scripts/anti-drm.mjs" config --stdin <<'ANTI_DRM_SETTINGS'
+  deny=.txt,.pdf
+  alt=.md,.html,.tsv
+  tsv=tab
+  ANTI_DRM_SETTINGS
+  ```
+
+- `on` 은 `config` 자리에 `on --runtime <런타임>` 을 씀
+- PowerShell 은 `@'` 와 `'@` 사이에 같은 세 줄을 두고 `| node "<경로>/scripts/anti-drm.mjs" config --stdin` 으로 넘김
+- 넘기기 전에 heredoc 안의 줄마다 `^(deny|alt|tsv)=[a-z0-9., ]*$` 에 맞는지 확인. 하나라도 맞지 않으면 실행하지 않고 "질문" 으로 돌아감
+  - "답 처리" 의 단어 검사와 겹치는 두 번째 방벽. 끝 표시(`ANTI_DRM_SETTINGS`, PowerShell 의 `'@`)는 이 꼴에 맞을 수 없어 값이 heredoc 을 일찍 닫지 못함
+- 줄은 `deny=`, `alt=`, `tsv=` 를 하나씩. `tsv=` 는 대체 확장자에 `.tsv` 가 있을 때만 씀
+- `--stdin` 은 입력이 끝날 때까지 기다림. 늘 heredoc 이나 파이프로 넘김
+
 ## 종료 코드
 
 | 코드 | 뜻 | 처리 |
@@ -206,7 +225,7 @@ argument-hint: "on | off | status | config"
 - Codex 블록은 `USER:OMX:POLICY` 표시로 감쌈
   - 블록이 남음: `omx setup --merge-agents`, 기본 `omx setup`(team 모드 켜짐)
   - 블록이 사라짐: `omx setup --force`, 덮어쓰기 확인, team 모드를 끈 `omx setup`. 그 뒤 `on` 다시 실행
-- Codex 파일 변경 전 내용: `<파일>.anti-drm.bak` (이 계정만 읽기 가능)
+- Codex 파일 변경 전 내용: `<파일>.anti-drm.bak` (이 계정만 읽기 가능). `off` 결과에 그 경로를 알림
 - `tone-compact` 블록과 같은 파일에 있어도 서로 건드리지 않음
 - `on`, `off` 는 그 런타임만 바꿈
 - 설정 값을 준 `on` 과 `config` 는 규칙이 들어 있는 다른 런타임도 새 규칙으로 바꿈
@@ -217,14 +236,19 @@ argument-hint: "on | off | status | config"
 | 메시지 | 조치 |
 |---|---|
 | 설정이 없습니다 | "질문" 으로 설정을 정해 `on` 에 넘김 |
-| 설정 파일이 올바르지 않습니다 | `config` 로 다시 만듦. 다른 사용자 소유면 그 파일을 치운 뒤 실행 |
-| 일반 파일이 아니라 설정을 저장하지 않았습니다 | 설정 경로의 폴더나 특수 파일을 치움. 또는 `BANKER_ANTI_DRM_CONFIG` 값 확인 |
-| 64KiB 보다 큰 파일이라, 읽을 수 없는 파일이라 설정을 저장하지 않았습니다 | 그 자리의 파일이 설정 파일인지 확인. 권한을 고치거나 옮긴 뒤 다시 실행 |
+| 표준 입력에 설정 줄이 없습니다 | heredoc 이 비었음. "설정 넘기기" 대로 줄을 넣어 다시 실행 |
+| 표준 입력이 64KiB 보다 큽니다 | "답 처리" 대로 정규화한 값만 넘김 |
+| 설정 파일이 올바르지 않습니다 | 이유를 전하고 `config` 로 다시 만들지 물은 뒤 진행. 다른 사용자 소유 파일은 지우거나 옮기지 않음. 무엇인지 보이고 사용자가 정하게 함 |
+| 일반 파일이 아니라 설정을 저장하지 않았습니다 | 설정 경로의 폴더나 특수 파일은 지우지 않음. 무엇인지 보이고, 옮길지 다른 경로(`BANKER_ANTI_DRM_CONFIG`)를 쓸지 물은 뒤 다시 실행 |
+| 64KiB 보다 큰 파일이라, 읽을 수 없는 파일이라 설정을 저장하지 않았습니다 | 그 파일이 무엇인지 보이고, 권한을 고칠지 옮길지 물은 뒤 다시 실행 |
 | anti-drm 이 쓰는 형식이라 금지할 수 없습니다 | 금지 목록에서 `.md`, `.json` 을 뺌 |
-| 같은 이름의 다른 파일이 있음 | `rules/banker-anti-drm.md` 가 banker 파일이 아님. 이름 변경 또는 삭제 뒤 다시 실행 |
-| 표시의 짝이 맞지 않음 | 지침 파일에 anti-drm 표시 줄이 한쪽만 있거나 문장 속에 있음. 또는 블록 안에 다른 표시 줄이 있음. 짝을 새로 맞추지 말고 남은 표시 줄을 지운 뒤 다시 실행 |
+| 같은 이름의 다른 파일이 있음 | `rules/banker-anti-drm.md` 가 banker 파일이 아님. 지우거나 이름을 바꾸지 않음. 내용을 보이고 어떻게 할지 물은 뒤 다시 실행 |
+| 표시의 짝이 맞지 않음 | 지침 파일에 anti-drm 표시 줄이 한쪽만 있거나 문장 속에 있음. 또는 블록 안에 다른 표시 줄이 있음. 짝을 새로 맞추지 않음. 남은 표시 줄을 보이고 지울지 물은 뒤 다시 실행 |
 | 다른 banker 블록만 있어 Codex 가 AGENTS.md 를 읽지 않음 | 메시지가 말한 스킬에서 `on` 실행 |
 | 설정 폴더가 없음 | 해당 런타임 미설치. 또는 설정 폴더 환경 변수 값 확인 |
 | 규칙이 지금 설정이나 이 버전과 다름 | `on` 한 번 실행 |
-| UTF-8 이 아닌 파일 | 지침 파일을 UTF-8 로 바꾼 뒤 다시 실행 |
+| UTF-8 이 아닌 파일 | 지침 파일을 바꾸지 않음. 인코딩을 보이고, 백업을 만든 뒤 UTF-8 로 바꿀지 물은 뒤 다시 실행 |
+| 끊어진 링크라 그대로 두었습니다 | AGENTS.md 가 가리키는 파일이 없음. 링크를 지우거나 바꾸지 않음. 링크와 대상을 보이고 어떻게 할지 물은 뒤 다시 실행 |
+| 일반 파일이 아님 | 지침 파일 자리(AGENTS.md, AGENTS.override.md)의 폴더나 특수 파일은 지우지 않음. 무엇인지 사용자에게 보이고, 옮기거나 이름을 바꿀지 물은 뒤 다시 실행 |
+| 다른 banker 지침 작업이 끝나지 않아 그대로 두었습니다 | 다른 banker 스킬의 `on`, `off` 가 도는 중. 잠시 뒤 다시 실행. 끝나지 않은 작업이 남긴 잠금은 1분 뒤 저절로 넘어감. 1분이 지나도 같거나 잠금 자리가 폴더면 잠금 경로를 보이고 어떻게 할지 물은 뒤 다시 실행. 잠금을 임의로 지우지 않음 |
 | 쓸 권한이 없음 | 해당 파일과 폴더 권한 확인 |