@kaydash9999/banker-plugins 0.20.2 → 0.21.0

package/hooks/progress.mjs

@@ -122,11 +122,14 @@ const looseStep = () => ({ key: 'loose', title: '작업 목록 밖의 작업', .
 // 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. `followed` is the step in
+// `taken` is the newest touch whose read was taken in, to tell a read that a newer one overtook (a weak plan's touch does
+// not count). `shown` is the touch, or the read again's count of touches, that the words on the pane came from: a later
+// read of the file shown that began before them does not take their place; `shownOrder` is the order a read again of
+// theirs began in (0 for a touch's read), so of two begun after the same touches the later one stays. `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,
   order: 0, marks: new Map(), listAt: 0, plan: null, planPath: null, planShut: false, planOpen: new Set(), touch: 0, taken: 0,
-  followed: null });
+  shown: 0, shownOrder: 0, followed: null, reads: [], base: null, folded: 0 });
 
 const tail = (path) => String(path).split(/[\\/]/).filter(Boolean).slice(-2).join('/');
 const seconds = (ms) => {
@@ -262,33 +265,51 @@ function stamp(t, status, now) {
 
 // A list longer than the pane holds loses its oldest finished item first, else its oldest.
 const overflow = (items) => items.find((t) => t.status === 'completed') ?? items[0];
+// A list cut to `max` items as overflow would cut it one by one, in one pass: the oldest finished ones go first, then
+// the oldest.
+function trimList(items, max) {
+  let extra = items.length - max;
+  if (extra <= 0) return items;
+  const left = items.filter((t) => t.status !== 'completed' || extra-- <= 0);
+  return left.slice(left.length - max);
+}
 
 // One item of a TodoWrite list: while its text stays it is the same step (the first unused one of
 // that text), with its key, calls and times.
 function todoItem(s, before, d, now) {
-  const t = before.get(d.content)?.shift() ?? { key: `d-${++s.seq}`, description: d.content, ...tally() };
+  const words = kept(d.content);
+  const t = before.get(words)?.shift() ?? { key: `d-${++s.seq}`, description: words, ...tally() };
   t.title = clip(d.content, 60);
-  t.activeForm = d.activeForm;
+  t.activeForm = kept(d.activeForm);
   stamp(t, d.status, now);
   return t;
 }
 
+// A task's or an item's words as the state keeps them: a string cut to what any description reads of it (clip reads
+// 4n + 1024 characters), anything else as it came.
+const MAX_WORDS = 4096;
+const kept = (v) => (typeof v === 'string' ? v.slice(0, MAX_WORDS) : v);
+
 // TodoWrite sends the whole list each time. A subagent keeps a list of its own, not the session's.
 function writeTodos(s, e, now) {
   if (e.agentId || !Array.isArray(e.todos)) return;
   const before = new Map();
   for (const t of s.todos ?? []) before.set(t.description, [...(before.get(t.description) ?? []), t]);
-  s.todos = e.todos.map((d) => todoItem(s, before, d, now));
-  while (s.todos.length > MAX_STEPS) s.todos.splice(s.todos.indexOf(overflow(s.todos)), 1);
+  s.todos = trimList(e.todos.map((d) => todoItem(s, before, d, now)), MAX_STEPS);
 }
 
+// A task's key on the pane: `k-` and its id where the id is a plain one (the store hands out numbers), else its first
+// 1,024 characters as code points, so ids that differ there never share a key (longer ones alike that far do) and none
+// holds what the engine drops a Box key for (a control character, more than 10,000 characters).
+const taskKey = (id) => (/^[\w.-]{1,64}$/.test(id) ? `k-${id}` : `k~${[...id.slice(0, 1024)].map((c) => c.codePointAt(0).toString(36)).join('.')}`);
+
 // Adds a task or brings it up to date; a task keeps its key, calls and times. One known only by
 // its id is named by it until a TaskGet or a TaskList says more.
 function putTask(s, t, now) {
-  const held = s.tasks.get(t.id) ?? { key: `k-${t.id}`, id: t.id, title: `작업 #${t.id}`, description: '', ...tally() };
+  const held = s.tasks.get(t.id) ?? { key: taskKey(t.id), id: t.id, title: clip(`작업 #${t.id}`, 60), description: '', ...tally() };
   const title = clip(t.subject, 60);
   if (title) held.title = title;
-  for (const k of ['description', 'activeForm']) if (t[k] !== undefined) held[k] = t[k];
+  for (const k of ['description', 'activeForm']) if (t[k] !== undefined) held[k] = kept(t[k]);
   if (t.status !== undefined) stamp(held, t.status, now);
   s.tasks.set(t.id, held);
   while (s.tasks.size > MAX_STEPS) s.tasks.delete(overflow([...s.tasks.values()]).id);
@@ -297,15 +318,29 @@ function putTask(s, t, 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.
+// of the last read taken in. Past MAX_MARKS the oldest marks of tasks off the pane go (trimMarks), so reads of ids the
+// store does not have cannot grow them without end.
+const MAX_MARKS = 1000;
+// A task id longer than this is no id the store hands out: a read that misses it leaves no mark.
+const MAX_ID = 64;
 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.
+// Drops the oldest marks of tasks off the pane down to MAX_MARKS. It runs once a call is taken in, when every task the
+// pane holds is in place again: a TaskList fills a new list, and a task not moved yet must not count as off the pane.
+function trimMarks(s) {
+  for (const k of s.marks.keys()) {
+    if (s.marks.size <= MAX_MARKS) return;
+    if (!s.tasks.has(k)) s.marks.delete(k);
+  }
+}
+
+// Whether a list or a read begun at (since, order) is older than what the pane holds of a task: a list begun after this
+// one began was already 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 this one began (a delete too), or a later-begun read already brought it. The first
+// takes the order calls began in for the order they read the list in, which holds where a call reads soon after it begins.
 function stale(s, id, since, order) {
   if (order < s.listAt) return true;
   const m = s.marks.get(id);
@@ -389,10 +424,7 @@ function listTasks(s, _e, r, now, { since, order }) {
 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));
-    markOf(s, String(e.taskId)).seenAt = order;
-  }
+  if (t === null) noTask(s, String(e.taskId), order);
   if (!t) return;
   const id = String(t.id);
   const status = readStatus(s, id, order, t.status);
@@ -401,6 +433,13 @@ function getTask(s, e, r, now, { since, order }) {
   markOf(s, id).seenAt = order;
 }
 
+// The store has no such task: it leaves the pane and the read is marked, unless the id is longer than any the store
+// hands out.
+function noTask(s, id, order) {
+  s.tasks.delete(id);
+  if (id.length <= MAX_ID) markOf(s, id).seenAt = order;
+}
+
 const TASK_NOTES = {
   TaskCreate: createTask,
   TaskUpdate: updateTask,
@@ -422,10 +461,14 @@ const changedId = (e, r) => (e.tool === 'TaskCreate' ? r?.result?.task?.id : e.t
 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, order });
-  if (!CHANGES.has(e.tool)) return;
+  if (CHANGES.has(e.tool)) noteChange(s, e, r);
+  trimMarks(s);
+}
+
+// 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).
+function noteChange(s, e, r) {
   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;
 }
@@ -477,11 +520,25 @@ function parsed(path, text) {
 }
 
 // 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 }) {
+// read again of the plan's own file (begun when `since` touches were counted) begun after the words on the pane
+// came in (`shown`), so neither an older touch nor an older read again takes their place.
+function current(s, path, { touch, since, order = 0 }) {
   if (touch !== undefined) return touch > s.taken;
-  return path === s.planPath && s.taken <= since;
+  return path === s.planPath && (s.shown < since || (s.shown === since && order >= (s.shownOrder ?? 0)));
+}
+
+// What a read taken in leaves, and whether its words go on the pane. `taken` makes older touches late (a weak plan's
+// touch does not), `shown` is the touch or the read again's since the words came from: a touch's read of the file
+// shown, begun before the read whose words are shown, leaves them.
+function noteTouch(s, read, moving) {
+  if (read.touch === undefined) {
+    [s.shown, s.shownOrder] = [read.since, read.order ?? 0];
+    return true;
+  }
+  if (!read.weak) s.taken = read.touch;
+  if (!moving && read.touch <= s.shown) return false;
+  [s.shown, s.shownOrder] = [read.touch, 0];
+  return true;
 }
 
 // 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
@@ -505,20 +562,60 @@ function treeIds(nodes, out = new Set()) {
   return out;
 }
 
+// The plan as reads leave it: the plan, its path, `taken` and `shown` (see freshState), with nothing of the pane.
+const planOf = (s) => ({ plan: s.plan, planPath: s.planPath, taken: s.taken, shown: s.shown, shownOrder: s.shownOrder });
+
+// What one read leaves of a plan state, as takePlan always did when reads landed in the order their touches came.
+function applyRead(st, e) {
+  if (!current(st, e.path, e.read) || keepsOff(st, e.path, e.plan, e.read)) return st;
+  const next = { ...st };
+  if (!noteTouch(next, e.read, e.path !== st.planPath)) return next;
+  return { ...next, planPath: e.path, plan: { ...e.plan, path: e.path } };
+}
+
+// Where a read goes among the touches: a touch's read at its touch, a read again just after the touches counted when
+// it began.
+const placeOf = (read) => (read.touch !== undefined ? read.touch : read.since + 0.5);
+// Reads kept past this wait for a touch whose read never came: that touch then counts as a read of nothing. Each
+// kept read holds a parsed plan, so the bound keeps the worst at about 8 MB.
+const MAX_READS = 16;
+
+// Folds into the base the reads whose earlier touches have all landed, so the base is the plan of those touches in their
+// order; a read again goes in once the touches it began after are in.
+function foldReads(s) {
+  if (s.reads.length > MAX_READS) s.folded = Math.max(s.folded, Math.ceil(placeOf(s.reads[0].read)) - 1);
+  while (s.reads.length) {
+    const { read } = s.reads[0];
+    const ready = read.touch !== undefined ? read.touch === s.folded + 1 : read.since <= s.folded;
+    if (!ready) return;
+    s.base = applyRead(s.base, s.reads.shift());
+    if (read.touch !== undefined) s.folded = read.touch;
+  }
+}
+
 // 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.
+// again). Reads land in any order: each is kept in its touch's place, and the pane shows the plan the touches
+// would leave in their order, as far as their reads have landed. 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 && !read.weak) s.taken = read.touch; // a weak plan does not make an older touch late
+  s.base ??= planOf(s);
+  if (read.touch !== undefined && read.touch <= s.folded) return; // its place went by as a read of nothing (MAX_READS)
+  const entry = { path, plan: parsed(path, text), read };
+  const at = s.reads.findIndex((r) => placeOf(r.read) > placeOf(read));
+  s.reads.splice(at < 0 ? s.reads.length : at, 0, entry);
+  foldReads(s);
+  showPlan(s, s.reads.reduce(applyRead, s.base));
+}
+
+// Puts a plan state on the pane: another plan starts folded, and the same plan keeps the nodes unfolded that it holds.
+function showPlan(s, st) {
+  const moving = st.planPath !== s.planPath;
   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 };
+  if (st.plan && st.plan !== s.plan) {
+    const ids = treeIds(st.plan.tree);
+    s.planOpen = moving ? new Set() : new Set([...s.planOpen].filter((id) => ids.has(id)));
+  }
+  Object.assign(s, st);
 }
 
 // ── what the pane shows ──────────────────────────────────────────────────────
@@ -551,9 +648,12 @@ function stepState(step, now) {
   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[status] ?? status}${doing}${time}`;
+  return `${stateName(status)}${doing}${time}`;
 }
 
+// A state's word: the pane's own, else the state cleaned (a name such as `constructor` is no word of the table).
+const stateName = (status) => pick(STATUS, status) ?? clip(status, 20);
+
 function stepWords(step, now) {
   if (step.key === 'idle') return '아직 시작한 작업이 없습니다. 요청을 보내면 여기에 단계가 쌓입니다.';
   const words = step.text !== undefined ? `요청: ${clip(step.text, 160) || '(이어서 진행)'}` : clip(step.description || step.title, 160);
@@ -627,7 +727,7 @@ function stepRow(ui, s, step, act) {
     ? Button({ key: `arrow-${step.key}`, label: isOpen ? '▾' : '▸', plain: true, onPress: () => act.fold(step.key) })
     : Text({ children: [' '] });
   const status = statusOf(step);
-  const state = STATUS[status] ?? status ?? '';
+  const state = stateName(status);
   return Box({ key: `row-${step.key}`, flexDirection: 'row', columnGap: 1, children: [
     arrow,
     Button({ key: step.key, label: room(step.title, act, 2, state), plain: true, onPress: () => act.select(step.key) }),
@@ -901,10 +1001,15 @@ export function progressTurnCompleted(e) {
 
 // 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.
+// A read again begins with the touches counted and its place in the order reads begin, so of two begun after the same
+// touches the later one wins, whichever lands last (the file may change between them without a touch: a shell edit).
+export const planTarget = (s) => (s.planPath ? { path: s.planPath, since: s.touch, order: ++s.order } : null);
+export const planRead = (s, target, text) => takePlan(s, target.path, text, { since: target.since, order: target.order });
+
 export function progressPlanTarget() {
-  return ref.s.planPath ? { path: ref.s.planPath, since: ref.s.touch } : null;
+  return planTarget(ref.s);
 }
 
 export function progressPlanRead(target, text) {
-  takePlan(ref.s, target.path, text, { since: target.since });
+  planRead(ref.s, target, text);
 }

package/hooks/register.mjs

@@ -83,6 +83,16 @@ async function voidLateRequest($, late) {
   $.ui.log(late.log);
 }
 
+// Asks the engine to draw the pane again. The engine sends the call on and catches its own failure (2.1.305); an engine
+// that throws instead still runs the hooks beneath, so the session and the turn go on.
+function redraw($) {
+  try {
+    $.ui.invalidate('ui.render');
+  } catch {
+    /* nothing to redraw now; the next event draws the pane */
+  }
+}
+
 export const register = (on) => {
   registerGracefulPause(on);
   registerProgress(on);
@@ -97,7 +107,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
+    redraw($); // the pane shows at once what /clear emptied
     return next(e);
   });
 
@@ -105,7 +115,7 @@ export const register = (on) => {
     pauseTurnStarted(e);
     progressTurnStarted(e);
     await rereadPlan($);
-    $.ui.invalidate('ui.render');
+    redraw($);
     return next(e);
   });
 
@@ -114,7 +124,7 @@ export const register = (on) => {
     if (late) await voidLateRequest($, late);
     progressTurnCompleted(e);
     await rereadPlan($);
-    $.ui.invalidate('ui.render');
+    redraw($);
     return next(e);
   });
 };

package/hooks/telemetry-count-codex.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+/*
+ * banker 텔레메트리 count 훅 (Codex Stop) - Codex 세션이 banker 스킬을 쓴 턴이 끝날 때 로컬 usage-log 에
+ * `banker:<name>\t<hour>` 한 줄을 남긴다. Claude Code 의 telemetry-count(.mjs, -skill.mjs)에 해당한다.
+ *
+ * Codex 0.144.5 실측으로 스킬이 쓰이는 길은 둘이다.
+ *  - 모델이 고른 스킬: 도구 호출로 SKILL.md 를 읽는다(Bash `cat <CODEX_HOME>/skills/banker-<name>/SKILL.md`).
+ *  - 사용자가 $banker-<name> 으로 부른 스킬: Codex 가 도구 호출 없이 `<skill>\n<name>..</name>\n<path>..</path>` 로
+ *    시작하는 사용자 역할 메시지로 본문을 넣는다. 이때는 머리의 <path> 줄만 보고 본문은 보지 않는다.
+ * 도구 호출마다 도는 PreToolUse 대신 턴마다 한 번 도는 Stop 에서, 훅 입력의 transcript_path(rollout) 중
+ * 이번 턴(task_started 의 turn_id 뒤)의 두 기록에 `skills/banker-<name>/SKILL.md` 가 있으면 센다. 나눠 읽어도 한 번이고, Stop 이 한 턴에 두 번 와도
+ * 최근 턴 키(configDir 의 codex-count-turns)로 한 번만 센다. 기록은 끝에서부터 32 MB 까지만 읽는다.
+ *
+ * fail-closed 규약은 Claude 쪽과 같다(telemetry-count-codex.test.mjs 가 검증):
+ *  - countingActive() 가 아니면 로컬 쓰기조차 하지 않는다.
+ *  - 이름은 SKILL_NAME_RE 전체 일치이고 이 Codex 에 설치된 banker 스킬(<CODEX_HOME>/skills/banker-<name>/SKILL.md)만.
+ *    모델이 `echo skills/banker-<아무 글>/SKILL.md` 를 돌려 체크인의 이름 칸으로 글을 내보내지 못하게 한다. 턴 키 파일은 일반 파일만 읽고, 링크 자리에 쓰지 않는다.
+ *  - 어떤 오류도 삼키고 항상 exit 0. 도구 호출을 절대 막지 않는다. 표준 출력은 비운다.
+ */
+import { closeSync, constants, existsSync, fstatSync, lstatSync, openSync, readSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, isAbsolute, join } from 'node:path';
+
+import { appendUsageLog, CODEX_SHAPE_MISS_PATH, configDir, countingActive, readRegular, recordUsedSkill, SKILL_NAME_RE, writeByRename } from '../bin/lib/telemetry-config.mjs';
+
+const SKILL_PATH_RE = /skills[\\/]+banker-([a-z0-9_-]{1,64})[\\/]+SKILL\.md/gi;
+const KEEP_TURNS = 100;
+export const TURNS_FILE = () => join(configDir(), 'codex-count-turns');
+
+function readStdin() {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => resolvePromise(data));
+    process.stdin.on('error', rejectPromise);
+  });
+}
+
+const MAX_READ = 32 << 20;
+const FIRST_READ = 1 << 20;
+
+// 글에 나오는 banker 스킬 이름(banker:<name>), 중복 없이.
+export function namesIn(text, names = new Set()) {
+  for (const m of text.matchAll(SKILL_PATH_RE)) {
+    const name = `banker:${m[1]}`;
+    if (SKILL_NAME_RE.test(name)) names.add(name);
+  }
+  return names;
+}
+
+// rollout 끝에서 max 바이트의 줄과, 파일 전체를 읽었는지. 일반 파일만: 기다리지 않게 O_NONBLOCK 으로 열고 연 것을 fstat 으로 본다. 앞에서 잘린 첫 줄은 버린다.
+function tailLines(file, max) {
+  const fd = openSync(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+  try {
+    if (!fstatSync(fd).isFile()) return { lines: [], whole: true };
+    const size = fstatSync(fd).size;
+    const start = Math.max(0, size - max);
+    const buf = Buffer.alloc(size - start);
+    readSync(fd, buf, 0, buf.length, start);
+    const lines = buf.toString('utf8').split('\n');
+    if (start > 0) lines.shift();
+    return { lines, whole: start === 0 };
+  } finally {
+    closeSync(fd);
+  }
+}
+
+const isCall = (rec) => rec?.type === 'response_item' && /_call$/.test(String(rec?.payload?.type ?? ''));
+const SKILL_HEAD_RE = /^<skill>\n<name>[^\n<]{1,80}<\/name>\n<path>([^\n<]{1,4096})<\/path>\n/;
+
+// $banker-<name> 으로 부른 스킬을 Codex 가 넣은 메시지의 <path>. 그 밖의 기록은 ''.
+function injectedPath(rec) {
+  const p = rec?.payload;
+  if (rec?.type !== 'response_item' || p?.type !== 'message' || p.role !== 'user' || !Array.isArray(p.content)) return '';
+  const text = p.content[0]?.text;
+  return typeof text === 'string' ? (SKILL_HEAD_RE.exec(text)?.[1] ?? '') : '';
+}
+
+// 이번 턴(turn_id 의 task_started 뒤)의 도구 호출과 넣은 스킬 머리에서 읽은 banker 스킬 이름. 사용자 글과 모델 답은 세지 않는다.
+// 턴 시작은 대개 기록 끝 가까이에 있으므로 끝 1 MB 부터 읽고, 못 찾으면 두 배씩 max 까지 넓힌다.
+// 기록 전체를 읽고도 task_started 가 하나도 없으면 null: Codex 는 턴마다 task_started 를 쓰므로 기록 형식이 바뀐 것이다.
+// 이 턴의 것만 없을 때(시작이 기록되지 않는 턴)는 형식 변경으로 보지 않는다.
+export function turnSkills(file, turnId, max = MAX_READ) {
+  for (let size = Math.min(FIRST_READ, max); ; size = Math.min(size * 2, max)) {
+    const { lines, whole } = tailLines(file, size);
+    const start = turnStart(lines, turnId);
+    if (start >= 0) return skillsAfter(lines, start);
+    if (whole) return lines.some((l) => l.trim()) && !lines.some((l) => l.includes('"task_started"')) ? null : [];
+    if (size >= max) return [];
+  }
+}
+
+// rollout 첫 기록(session_meta)의 Codex 판. Codex 기록이 아니면 ''.
+export function codexVersionOf(file) {
+  try {
+    const fd = openSync(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
+    try {
+      if (!fstatSync(fd).isFile()) return '';
+      const buf = Buffer.alloc(Math.min(fstatSync(fd).size, 8 << 20)); // session_meta 는 지침을 품어 클 수 있다
+      readSync(fd, buf, 0, buf.length, 0);
+      const rec = JSON.parse(buf.toString('utf8').split('\n')[0]);
+      return rec?.type === 'session_meta' ? String(rec.payload?.cli_version ?? '?').slice(0, 40) : '';
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return '';
+  }
+}
+
+// 이 Codex 판의 기록을 읽지 못했음을 남긴다(같은 판은 한 번만). 다음 세션 시작 때 update-notify --codex 가 알린다.
+function noteShapeMiss(file) {
+  const version = codexVersionOf(file);
+  if (!version) return;
+  let prev = {};
+  try { prev = JSON.parse(readRegular(CODEX_SHAPE_MISS_PATH)); } catch { /* 없음 */ }
+  if (prev?.version !== version) writeByRename(CODEX_SHAPE_MISS_PATH, JSON.stringify({ version, notified: false }));
+}
+
+function turnStart(lines, turnId) {
+  let start = lines.length - 1;
+  while (start >= 0 && !(lines[start].includes('"task_started"') && lines[start].includes(turnId))) start--;
+  return start;
+}
+
+function skillsAfter(lines, start) {
+  const names = new Set();
+  for (const line of lines.slice(start + 1)) {
+    if (!line.includes('SKILL.md')) continue;
+    let rec;
+    try { rec = JSON.parse(line); } catch { continue; }
+    if (isCall(rec)) namesIn(JSON.stringify(rec.payload), names);
+    else namesIn(injectedPath(rec), names);
+  }
+  return [...names];
+}
+
+const ID_RE = /^[A-Za-z0-9._-]{1,80}$/;
+
+// 이 턴의 키. session_id 와 turn_id 가 모양이 맞을 때만(파일 한 줄 형식을 깨지 않게).
+export function turnKey(payload) {
+  const s = payload?.session_id;
+  const t = payload?.turn_id;
+  return typeof s === 'string' && typeof t === 'string' && ID_RE.test(s) && ID_RE.test(t) ? `${s}:${t}` : null;
+}
+
+function readTurns() {
+  try {
+    return readRegular(TURNS_FILE()).split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// 링크나 일반 파일이 아닌 자리에는 쓰지 않는다. 새 파일을 만들어 바꿔 넣는다.
+function writeTurns(lines) {
+  const file = TURNS_FILE();
+  try {
+    if (!lstatSync(file).isFile()) return;
+  } catch (e) {
+    if (e?.code !== 'ENOENT') return;
+  }
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(tmp, `${lines.slice(-KEEP_TURNS).join('\n')}\n`, { flag: 'wx', mode: 0o600 });
+    renameSync(tmp, file);
+  } catch {
+    rmSync(tmp, { force: true });
+  }
+}
+
+// 이 세션의 Codex 홈: rollout 이 <홈>/sessions/YYYY/MM/DD/ 에 있으면 그 홈(상대 경로 CODEX_HOME 도 Codex 가 푼 그대로),
+// 아니면 CODEX_HOME, 그것도 없으면 ~/.codex.
+export function codexHomeOf(transcript, env = process.env) {
+  const sessions = dirname(dirname(dirname(dirname(String(transcript)))));
+  if (isAbsolute(String(transcript)) && basename(sessions) === 'sessions') return dirname(sessions);
+  return env.CODEX_HOME || join(homedir(), '.codex');
+}
+
+// 이 Codex 에 설치된 banker 스킬인지.
+export const installed = (name, home) => existsSync(join(home, 'skills', `banker-${name.slice('banker:'.length)}`, 'SKILL.md'));
+
+// 이 턴에 아직 세지 않은 이름만 센다.
+export function countOnce(payload) {
+  const key = turnKey(payload);
+  const file = typeof payload?.transcript_path === 'string' ? payload.transcript_path : '';
+  const home = codexHomeOf(file);
+  const got = key && file ? turnSkills(file, payload.turn_id) : [];
+  if (got === null) {
+    noteShapeMiss(file);
+    return [];
+  }
+  const names = got.filter((n) => installed(n, home));
+  if (!names.length) return [];
+  const seen = readTurns();
+  const fresh = names.filter((n) => !seen.includes(`${key}\t${n}`));
+  if (!fresh.length) return [];
+  for (const n of fresh) {
+    appendUsageLog(n);
+    recordUsedSkill(n);
+  }
+  writeTurns([...seen, ...fresh.map((n) => `${key}\t${n}`)]);
+  return fresh;
+}
+
+async function main() {
+  let payload;
+  try {
+    payload = JSON.parse(await readStdin());
+  } catch {
+    return;
+  }
+  if (!countingActive()) return;
+  countOnce(payload);
+}
+
+if (process.argv[1] && /telemetry-count-codex\.mjs$/.test(process.argv[1])) {
+  main()
+    .catch(() => {})
+    .finally(() => process.exit(0));
+}

package/hooks/update-checkin.mjs

@@ -9,7 +9,10 @@
  *  - 미활성(countingActive) 또는 엔드포인트 없음이면 무동작(로그도 건드리지 않는다).
  *  - PII/IP/지속ID 절대 미포함. 페이로드는 {version, os, counts} 세 키뿐(os=플랫폼 계열,
  *    counts=스킬별 x 시간대별 호출수).
- *  - 자체 네트워크 timeout 으로 hang 방지. 어떤 오류도 삼키고 항상 exit 0. 어떤 경로도 reject 안 함.
+ *  - 무활동 10초 timeout 과 요청마다 30초 교환 전체 마감으로 hang 하지 않는다.
+ *  - 응답 본문은 256KiB 까지만 모은다. 넘으면 연결을 끊고 그 응답을 쓰지 않는다.
+ *  - 응답에서 latest 를 얻지 못하면(전송 실패, 차단, 없는 값) 시도 시각(triedAt)만 캐시에 써 하루를 쉰다.
+ *  - 어떤 오류도 삼키고 항상 exit 0. 어떤 경로도 reject 안 함.
  *  - 비-loopback 평문 http 는 전송하지 않는다(https-only). loopback http 만 로컬 테스트 mock 에 허용.
  *  - 함께 시작한 체크인은 같은 줄을 두 번 보내지 않는다(로그 이름 바꾸기는 하나만 성공한다).
  *  - 로그 자리가 FIFO 면 기다리지 않고, 로그나 last-flush 자리가 링크면 링크 너머 파일을 비우거나 덮지 않는다.
@@ -73,7 +76,8 @@ function isLoopback(hostname) {
 }
 
 // 엔드포인트로 JSON POST. 어떤 경로에서도 reject 하지 않고, 전송 시도가 끝나면 응답 본문(문자열)
-// 또는 null 로 resolve 한다. 자체 timeout(NET_TIMEOUT_MS)으로 무응답 엔드포인트에도 hang 하지 않는다.
+// 또는 null 로 resolve 한다. 무활동 timeout(NET_TIMEOUT_MS)과 교환 전체 마감(NET_DEADLINE_MS)으로 무응답
+// 엔드포인트에도 hang 하지 않고, 본문은 MAX_BODY_BYTES 까지만 모은다.
 function post(url, body) {
   return new Promise((resolvePromise) => {
     let done = false;
@@ -124,8 +128,9 @@ function extractLatest(responseBody) {
 
 // 변경-스킬 매니페스트(공개 GitHub raw JSON: {"x.y.z": ["banker:skill", ...]})를 GET 해 객체로 반환한다.
 // update-fetch 의 동일 함수와 self-contained 로 나란히 둔다(훅별 자기완결 관례·isLoopback 도 이미 각자 보유).
-// post() 와 동일한 안전 가드: 비-https 는 loopback 만 허용·3xx no-op·자체 timeout·malformed→null. 어떤
-// 실패에도 reject 하지 않고 null 로 resolve 한다(개인화는 best-effort). 비배열 객체만 반환.
+// post() 와 동일한 안전 가드: 비-https 는 loopback 만 허용·3xx no-op·무활동 timeout 과 교환 전체 마감·
+// 본문 256KiB 상한·malformed→null. 어떤 실패에도 reject 하지 않고 null 로 resolve 한다(개인화는 best-effort).
+// 비배열 객체만 반환.
 function fetchSkillChangesMap(url) {
   return new Promise((resolvePromise) => {
     let done = false;
@@ -228,17 +233,20 @@ function dropOldClaims(now = Date.now()) {
   }
 }
 
-// 응답의 latest 로 공유 update-check 캐시를 갱신(알림 겸함). 없으면 캐시 미변경.
+// 응답의 latest 로 공유 update-check 캐시를 갱신(알림 겸함). 없으면 시도 시각(triedAt)만 쓴다.
 // 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) return;
+  if (!latest) { // 시도 시각만 남겨 update-notify 가 하루 동안 다시 띄우지 않게 한다(네트워크 없는 곳의 세션마다 시도).
+    try { writeUpdateCache({ triedAt: Date.now() }); } catch { /* best-effort */ }
+    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() };
+  const patch = { latest, checkedAt: Date.now(), triedAt: null }; // 성공: 남은 실패 시도 시각은 비움
   if (map) patch.changedSkills = changedSkillsBetween(map, installedVersion(), latest);
   try { writeUpdateCache(patch); } catch { /* best-effort */ }
 }