@kaydash9999/banker-plugins 0.17.1 → 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.17.1",
+  "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/3d-intro-build/SKILL.md

@@ -296,7 +296,7 @@ node references/verify-intro.mjs http://localhost:<port>/ --out <projectDir>/ver
 
 - 백업을 먼저 한다. 백업은 프로젝트의 `backup/` 아래에 둔다. `/tmp` 는 쓰지 않는다.
 - `site/` 의 파일을 사이트의 정적 폴더로 옮긴다. `#world` 를 본문 위에 두고, `stepNav.end` 는 본문 시작 요소를 가리킨다.
-- 사이트 CSP 에 `connect-src 'self'`, `media-src 'self' blob:`, `style-src` 의 `styleHash` 를 더한다. 인라인을 허용하지 않아도 된다. `scrub-engine.LICENSE.txt`(엔진의 MIT 고지)도 함께 옮긴다.
+- 사이트 CSP 에 `connect-src 'self'`, `media-src 'self' blob:`, `style-src` 의 `styleHash` 를 더한다. 인라인을 허용하지 않아도 된다. `scrub-engine.LICENSE.md`(엔진의 MIT 고지)도 함께 옮긴다.
 - 배포 뒤 운영 주소에 `verify-intro.mjs` 를 다시 돌려 결과를 대조해 보고한다.
 
 ---

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

@@ -8,7 +8,7 @@
  *     index.html            (head of index-template.html; no inline script or style)
  *     scrub-engine.js       (copied verbatim from references/)
  *     scrub-engine.css      (the CSS the engine injects, taken from scrub-engine.js unchanged)
- *     scrub-engine.LICENSE.txt (scroll-world's MIT notice, which ships with the engine files)
+ *     scrub-engine.LICENSE.md (scroll-world's MIT notice, which ships with the engine files)
  *     theme.css             (the template's --sw-* tokens, set from the manifest theme)
  *     intro-fixes.css       (layout, button text and overflow fixes for the engine, every page)
  *     intro.js              (the mountScrollWorld config and call)
@@ -231,12 +231,12 @@ const escAttr = (s) => String(s).replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<':
 
 // Heads the copied engine rules: they are scroll-world's (MIT), whose notice ships beside them.
 const ENGINE_NOTICE = '/* scroll-world (https://github.com/oso95/scroll-world), MIT License, (c) 2026 cyw.\n'
-  + '   The rules scrub-engine.js injects, copied unchanged. Notice: scrub-engine.LICENSE.txt */\n';
+  + '   The rules scrub-engine.js injects, copied unchanged. Notice: scrub-engine.LICENSE.md */\n';
 
 function writeStatic(out, manifest, template) {
   const engineSource = fs.readFileSync(path.join(HERE, 'scrub-engine.js'), 'utf8');
   fs.copyFileSync(path.join(HERE, 'scrub-engine.js'), path.join(out, 'scrub-engine.js'));
-  fs.copyFileSync(path.join(HERE, 'LICENSE'), path.join(out, 'scrub-engine.LICENSE.txt'));
+  fs.copyFileSync(path.join(HERE, 'LICENSE'), path.join(out, 'scrub-engine.LICENSE.md'));
   const css = engineCss(engineSource);
   fs.writeFileSync(path.join(out, 'scrub-engine.css'), ENGINE_NOTICE + css);
   const style = /<style>([\s\S]*?)<\/style>/.exec(template);

package/skills/3d-intro-setup/SKILL.md

@@ -152,7 +152,7 @@ AZURE_IMAGE_API_KEY=<Image 리소스 키>
 ### 모드 (b) — 콘솔 샘플 파일
 Azure AI Foundry/AI Hub 콘솔의 "Sample code"/"View code" 패널이 주는 curl 또는 Python 스니펫에는 원문 키가 들어 있다. 사람이 이것을 **채팅에 붙이지 않고** 비공개 파일에 저장한다:
 ```bash
-mkdir -p ~/.config/banker/3d-intro && (umask 077 && touch ~/.config/banker/3d-intro/sample.txt)   # 사람이 이 파일에 샘플을 붙여 저장
+mkdir -p ~/.config/banker/3d-intro && (umask 077 && touch ~/.config/banker/3d-intro/sample.md)   # 사람이 이 파일에 샘플을 붙여 저장
 ```
 에이전트는 그 파일을 읽어 키를 화면에 내지 않고 키 파일에 바로 합친 뒤 샘플 파일을 지운다. 리소스마다 마지막 인자를 `sora`, `image`, `wan:<n>` 중 하나로 준다:
 ```bash
@@ -178,8 +178,8 @@ node -e "
   const replaced = old && add[names.apiKey] && old !== add[names.apiKey] ? redact(old) : null;
   console.log(JSON.stringify({ file: target, endpoint: p.endpoint, deployment: p.deployment, apiVersion: p.apiVersion, apiKey: redact(p.apiKey), replaced }));
 })();
-" "$HOME/.config/banker/3d-intro/sample.txt" sora
-rm -f "$HOME/.config/banker/3d-intro/sample.txt"
+" "$HOME/.config/banker/3d-intro/sample.md" sora
+rm -f "$HOME/.config/banker/3d-intro/sample.md"
 ```
 파싱 결과(저장한 파일, 엔드포인트, 배포명, apiVersion, 길이만 보이는 key)를 사람에게 보여 주고 확인받는다.
 `replaced` 에 길이가 보이면 파일에 있던 다른 키를 이 샘플의 키로 바꾼 것이다. 교체(로테이션)가 아니었다면 사람이 키 파일의 키 줄을 다시 적는다.