@diffin/cli 0.0.0-stage → 0.1.0

package/lib/ui.mjs

@@ -0,0 +1,220 @@
+// Every line the CLI prints goes through here, so it speaks with one voice: a section
+// per step, one aligned row per fact, a short closing line, and errors that say what
+// happened and what to do — never a JSON dump. Colour only on a TTY and never when
+// NO_COLOR is set; everything goes to stderr so stdout stays clean for pipes.
+//
+// The accent is the product's own (the graph view's `hsl(258 88% 66%)`), written as a
+// 24-bit escape where the terminal says it can show one and as plain magenta where it
+// does not. Everything else is ink on paper: bold, dim, and a verdict colour.
+const tty = Boolean(process.stderr.isTTY) && !process.env.NO_COLOR;
+const paint = (code) => (s) => (tty ? `\x1b[${code}m${s}\x1b[0m` : String(s));
+export const bold = paint(1), dim = paint(2), green = paint(32), yellow = paint(33), red = paint(31);
+const truecolor = /truecolor|24bit/i.test(process.env.COLORTERM ?? '');
+export const accent = paint(truecolor ? '38;2;143;92;246' : '35');
+
+export const out = (s = '') => console.error(s);
+
+/** the wordmark, once, at the top of a command that has several steps */
+export const brand = () => out(`${accent('◆')} ${bold('diffin')}`);
+
+/** a step header: `diffin  로그인` with an optional dimmed note */
+export function section(title, note) {
+  out(`${accent('diffin')}  ${bold(title)}${note ? dim(`  ${note}`) : ''}`);
+}
+
+// Korean glyphs are two columns wide; padEnd counts code units. Width-aware pad so
+// columns line up whether a cell says "Claude Code" or "최신". Escape sequences are
+// zero-width: a painted cell must still pad to what the eye sees, or every row after
+// the first coloured one is out by the length of an escape.
+const BARE = /\x1b\[[0-9;]*m/g;
+export const width = (s) => [...String(s).replace(BARE, '')]
+  .reduce((w, ch) => w + (/[ᄀ-ᇿ　-鿿가-힯＀-￯]/.test(ch) ? 2 : 1), 0);
+export const pad = (s, n) => String(s) + ' '.repeat(Math.max(0, n - width(s)));
+
+/** one aligned fact: label · value · trailing status */
+export function row(label, value = '', status = '') {
+  out(`  ${pad(label, 14)}${pad(value, 40)}${status}`.replace(/\s+$/, ''));
+}
+
+/** rewrite the current line (progress). Off a TTY there is no line to rewrite, and a progress bar written once per
+ *  file was 638 lines in a log for one upload — so it says nothing there, and the result line that follows is the record */
+export function live(text) { if (tty) process.stderr.write(`\r\x1b[2K${text}`); }
+/** take the progress line away, so what is printed next stands where it was */
+export const liveClear = () => { if (tty) process.stderr.write('\r\x1b[2K'); };
+
+// A bar is a shape, not a number: it says "this is moving and roughly how far in".
+// The exact count rides beside it, because a bar cannot be read aloud or grepped.
+const BLOCK = '█', TRACK = '░';
+export function bar(done, total, cells = 16) {
+  if (!(total > 0)) return dim(TRACK.repeat(cells));
+  const filled = Math.max(0, Math.min(cells, Math.round((done / total) * cells)));
+  return accent(BLOCK.repeat(filled)) + dim(TRACK.repeat(cells - filled));
+}
+
+// A spinner is the only thing that says "the wait is ours, not yours" while a request
+// is open. Off a TTY there is nothing to rewrite, so the label is printed once and the
+// ticker never starts — a log file must not collect 600 copies of one line.
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export function spin(render, ms = 90) {
+  const text = typeof render === 'function' ? render : () => String(render);
+  if (!tty) { process.stderr.write(`${text('·')}\n`); return () => {}; }
+  let i = 0;
+  const tick = () => live(text(accent(FRAMES[i++ % FRAMES.length])));
+  tick();
+  const timer = setInterval(tick, ms);
+  timer.unref?.();
+  // Stopping ERASES the line rather than ending it: a spinner is a statement about
+  // right now, and the result that follows belongs where the waiting was, not under a
+  // frozen frame of it.
+  return () => { clearInterval(timer); process.stderr.write('\r\x1b[2K'); };
+}
+
+/** a short duration a person reads without converting: 48초 · 3분 12초 */
+export function since(ms) {
+  const s = Math.max(0, Math.round(ms / 1000));
+  return s < 60 ? `${s}초` : `${Math.floor(s / 60)}분 ${String(s % 60).padStart(2, '0')}초`;
+}
+
+// One clock for everything a person reads: THEIR time. A transcript's stamp and the server's are UTC strings, and
+// slicing one printed a preview nine hours off the "next record" line under it, on the same screen. A date is
+// 「10월 4일」, a moment 「10월 4일 03:12」, a time inside a listed day 「03:12」.
+const two = (n) => String(n).padStart(2, '0');
+export const clock = (d) => { const t = new Date(d); return Number.isFinite(t.getTime()) ? `${two(t.getHours())}:${two(t.getMinutes())}` : ''; };
+export const dayOf = (d) => { const t = new Date(d); return Number.isFinite(t.getTime()) ? `${t.getMonth() + 1}월 ${t.getDate()}일` : ''; };
+export const when = (d) => `${dayOf(d)} ${clock(d)}`.trim();
+
+// ---- steps and the card ----------------------------------------------------------
+// A command with several stages reads as a short list: one line a stage, a mark in front that says where it stands
+// (done, running, could not finish), the one fact worth knowing beside it, anything else dimmed at the end. The first
+// onboarding printed sections of rows — a path, a version, a file name per line, all the same weight — and nothing in
+// it said which line was the result. A step line is what the eye runs down; the card under it is what it stops on.
+const STEP_TITLE = 18, STEP_VALUE = 44;
+// a value wider than its column still keeps two spaces before what follows it
+const stepLine = (mark, title, value = '', tail = '') => `  ${mark} ${pad(title, STEP_TITLE)}${tail ? pad(`${value}  `, STEP_VALUE) : value}${tail}`.replace(/\s+$/, '');
+export const stepDone = (title, value, tail) => out(stepLine(green('✓'), title, value, tail));
+export const stepSkip = (title, value, tail) => out(stepLine(dim('○'), title, value, tail));
+export const stepFail = (title, value, tail) => out(stepLine(red('✗'), title, value, tail));
+export const stepWarn = (title, value, tail) => out(stepLine(yellow('!'), title, value, tail));
+/** a fact with no verdict: no mark, the same columns */
+export const stepInfo = (title, value, tail) => out(stepLine(' ', title, value, tail));
+/** a sentence that is the whole answer of a command, with what follows from it dimmed underneath */
+export function say(mark, text, ...more) { out(`  ${mark} ${text}`); for (const m of more) out(dim(`    ${m}`)); }
+export const marks = { done: () => green('✓'), wait: () => dim('○'), warn: () => yellow('!'), now: () => accent('●') };
+/** the running form, for `live()` / `spin()`: the mark is the caller's (a spinner frame, or a dot) */
+export const stepLive = (mark, title, value) => stepLine(mark, title, value);
+export const dot = () => accent('●');
+
+/** the wordmark and the version, once, at the top of the onboarding */
+export const banner = (version) => { out(); out(`  ${accent('◆')} ${bold('diffin')}${version ? dim(`  v${version}`) : ''}`); out(); };
+
+/**
+ * A boxed card: the one place a person's eye should land when a command with several steps is over. `lines` are
+ * strings ('' is a blank line); the first is the title. Width follows the widest line, counted the way the eye
+ * counts (a Korean glyph is two columns, an escape none).
+ */
+export function card(lines) {
+  const inner = Math.max(...lines.map((l) => width(l))) + 4;
+  out(`  ${dim('╭' + '─'.repeat(inner) + '╮')}`);
+  lines.forEach((l, i) => out(`  ${dim('│')}  ${pad(i === 0 ? bold(l) : l, inner - 2)}${dim('│')}`));
+  out(`  ${dim('╰' + '─'.repeat(inner) + '╯')}`);
+}
+
+// ---- a list to choose from ---------------------------------------------------------
+// A tree, two levels deep on screen: a top folder and, when opened, every folder under it. Everything starts selected.
+// ↑↓ move · space switches the line under the cursor · →/← open and close a folder · a switches all · enter confirms ·
+// q or Ctrl-C cancels. Switching a folder off switches off everything under it — that is what excluding a folder
+// means — and switching one on switches its parents on, since a folder cannot be recorded inside one that is not.
+//
+// `items` are in display order: { label, tail, parent } with `parent` the index of the item it sits under (null for a
+// top folder). The state and the frame are plain functions (tested); `selectMany` only moves keys in and lines out.
+const kids = (items, i) => items.map((it, k) => k).filter((k) => { for (let p = items[k].parent; p != null; p = items[p].parent) if (p === i) return true; return false; });
+const topOf = (items, i) => { let t = i; while (items[t].parent != null) t = items[t].parent; return t; };
+export const selectVisible = (items, st) => items.map((_, i) => i).filter((i) => items[i].parent == null || st.open.includes(topOf(items, i)));
+export function selectStep(items, st, key) {
+  const vis = selectVisible(items, st);
+  const pos = Math.max(0, vis.indexOf(st.at));
+  const here = vis[pos];
+  if (key === 'up') return { ...st, at: vis[(pos - 1 + vis.length) % vis.length] };
+  if (key === 'down') return { ...st, at: vis[(pos + 1) % vis.length] };
+  if (key === 'open') { const t = topOf(items, here); return kids(items, t).length && !st.open.includes(t) ? { ...st, open: [...st.open, t] } : st; }
+  if (key === 'close') { const t = topOf(items, here); return st.open.includes(t) ? { ...st, open: st.open.filter((x) => x !== t), at: t } : st; }
+  if (key === 'space') {
+    const v = !st.on[here];
+    const on = [...st.on];
+    on[here] = v; for (const k of kids(items, here)) on[k] = v;
+    if (v) for (let p = items[here].parent; p != null; p = items[p].parent) on[p] = true;
+    return { ...st, on };
+  }
+  if (key === 'all') { const every = st.on.every(Boolean); return { ...st, on: st.on.map(() => !every) }; }
+  return st;
+}
+/** the lines that tie a folder to the one it sits under: ├─ / └─ for the item, │ carried down past its parents' later siblings */
+function branch(items, i) {
+  if (items[i].parent == null) return '';
+  const lastOf = (k) => !items.some((it, j) => j > k && it.parent === items[k].parent);
+  let lead = lastOf(i) ? '└─ ' : '├─ ';
+  for (let p = items[i].parent; items[p].parent != null; p = items[p].parent) lead = (lastOf(p) ? '   ' : '│  ') + lead;
+  return dim(lead);
+}
+export function selectFrame({ title, note, items, unit }, st) {
+  const vis = selectVisible(items, st);
+  const depth = (i) => { let d = 0; for (let p = items[i].parent; p != null; p = items[p].parent) d++; return d; };
+  const w = Math.max(...vis.map((i) => width(items[i].label) + depth(i) * 3)) + 3;
+  const lines = ['', `  ${bold(title)}${note ? dim(`  ${note}`) : ''}`, ''];
+  for (const i of vis) {
+    const under = kids(items, i);
+    const part = st.on[i] && under.some((k) => !st.on[k]);
+    // a checkbox, not a dot: three states have to read apart at a glance, in any font — a filled, half and empty
+    // circle did not (the owner's screenshot, 2026-10-03)
+    const box = !st.on[i] ? dim('[ ]') : part ? yellow('[-]') : green('[✓]');
+    const name = `${branch(items, i)}${st.on[i] ? items[i].label : dim(items[i].label)}`;
+    const fold = items[i].parent == null && under.length ? dim(st.open.includes(i) ? '  ← 접기' : `  → 하위 폴더 ${under.length}곳`) : '';
+    const state = !st.on[i] ? dim('  올리지 않음') : part ? dim('  일부만') : '';
+    lines.push(`  ${i === st.at ? accent('❯') : ' '} ${box} ${pad(name, w)}${dim(items[i].tail ?? '')}${state}${fold}`);
+  }
+  const any = st.on.some(Boolean);
+  lines.push('', `  ${dim('↑↓ 이동 · space 선택/해제 · → 하위 폴더 · a 전체 ·')} ${any ? bold(`enter ${unit ? unit(st.on) : '확인'}`) : dim('enter (선택한 폴더 없음)')} ${dim('· q 취소')}`);
+  return lines;
+}
+const KEYS = { '\x1b[A': 'up', '\x1b[B': 'down', '\x1b[C': 'open', '\x1b[D': 'close', k: 'up', j: 'down', l: 'open', h: 'close', ' ': 'space', a: 'all', '\r': 'enter', '\n': 'enter', q: 'cancel', '\x03': 'cancel', '\x1b': 'cancel' };
+/** resolves to the selection (an array of booleans, one per item), or null when the person cancelled */
+export function selectMany(spec) {
+  return new Promise((resolve) => {
+    const input = process.stdin;
+    let st = { at: 0, on: spec.initial ? spec.items.map((_, i) => spec.initial[i] !== false) : spec.items.map(() => true), open: [] };
+    let drawn = 0;
+    const draw = () => {
+      const lines = selectFrame(spec, st);
+      // a frame may be shorter than the one before it (a folder closed): the lines left over are cleared
+      const extra = Math.max(0, drawn - lines.length);
+      process.stderr.write((drawn ? `\x1b[${drawn}A` : '') + lines.map((l) => `\r\x1b[2K${l}`).join('\n') + '\n' + '\r\x1b[2K\n'.repeat(extra) + (extra ? `\x1b[${extra}A` : ''));
+      drawn = lines.length;
+    };
+    const done = (value) => {
+      input.off('data', onKey); try { input.setRawMode(false); } catch { /* not a tty any more */ } input.pause();
+      // the list leaves the screen: what was chosen is said by the lines that follow
+      process.stderr.write(`\x1b[${drawn}A` + '\r\x1b[2K\n'.repeat(drawn) + `\x1b[${drawn}A`);
+      resolve(value);
+    };
+    const onKey = (buf) => {
+      const key = KEYS[String(buf)];
+      if (key === 'cancel') return done(null);
+      if (key === 'enter') return done(st.on);
+      if (key) { st = selectStep(spec.items, st, key); draw(); }
+    };
+    try { input.setRawMode(true); } catch { return resolve(st.on); }
+    input.resume(); input.on('data', onKey);
+    draw();
+  });
+}
+
+export const ok = (s) => out(`  ${green('✓')} ${s}`);
+export const warn = (s) => out(`  ${yellow('!')} ${s}`);
+export const fail = (s, hint) => { out(`  ${red('✗')} ${s}`); if (hint) out(`    ${dim(hint)}`); };
+
+/** the server's own words, or a status when it had none */
+export function serverMessage(status, bodyText) {
+  try { const b = JSON.parse(bodyText); if (b?.message) return b.message; } catch { /* not JSON */ }
+  return { 401: '로그인이 필요합니다.', 403: '권한이 없습니다.', 404: '찾을 수 없습니다.', 413: '요청이 너무 큽니다.', 429: '요청이 너무 잦습니다. 잠시 후 다시 시도해주세요.', 503: '서버가 바쁩니다. 잠시 후 다시 시도해주세요.' }[status]
+    ?? `서버 오류 (${status})`;
+}

package/lib/watch.mjs

@@ -0,0 +1,164 @@
+// What happens after `complete` used to be invisible: the CLI said "서버가 기록을
+// 정리하는 데 몇 분 걸립니다" and exited, so the first thing a person ever saw of this
+// product was a promise. The worker already writes its progress to the run record at
+// every stage boundary — the lamp the app polls — so the CLI can read the same thing
+// and stay until there is a result to show.
+//
+// Bounded and escapable: past WAIT_MAX the wait ends with the app's address, because
+// the run is the server's from `complete` onwards and nothing here can hurry it.
+import { SERVER, fetchRetry, runAuth } from './net.mjs';
+import { bar, dim, fail, pad, serverMessage, since, spin, stepDone, stepLive, stepSkip } from './ui.mjs';
+import { serverPlace } from './journey.mjs';
+
+/** how often a run is asked for its progress, and how long the CLI waits before saying it is still being processed;
+ *  a test passes shorter ones through `watchAll`'s options. An hour, not fifteen minutes: measured on the owner's own
+ *  backfills, eleven or twelve days of work took 12–20 minutes (13m34s, 14m53s, 19m54s) with nobody else in the queue,
+ *  so the old ceiling ended the wait on an ordinary first run and showed 「아직 정리 중」 where a result was minutes away.
+ *  The wait costs nothing — it is a poll every two seconds — and the person can close the terminal at any time. */
+const POLL_MS = 2000;
+const WAIT_MAX_MS = 60 * 60_000;
+const n = (x) => Number(x ?? 0).toLocaleString('ko-KR');
+/** the step this file draws: the server turning what was uploaded into records */
+const STEP = '기록 정리';
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * One poll. A transport failure is not a verdict — the network dropping a packet reads
+ * as "no news yet" and the next poll asks again. A REFUSAL is a verdict: a credential
+ * that stopped working, or a run this account cannot see, never becomes readable by
+ * being asked 450 more times, and waiting out fifteen minutes on it would look exactly
+ * like patience. `{ gone }` ends the wait; `null` continues it.
+ */
+async function look(token, runId) {
+  const res = await fetchRetry(`${SERVER}/backfill/runs/${runId}`, () => ({ headers: runAuth(token) })).catch(() => null);
+  if (!res) return null;
+  if ([401, 403, 404].includes(res.status)) return { gone: res.status };
+  if (!res.ok) return null;
+  const body = await res.json().catch(() => null);
+  return body ? { view: body } : null;
+}
+
+/**
+ * Watch one run to its end. Returns the run's last known view, or null if the wait ran
+ * out — the caller says what to do, because that differs between onboarding and a
+ * plain `diffin backfill`.
+ */
+/**
+ * The bar of a stage that counts something. A stage whose count is ONE has no bar: 0/1 for the whole of it and then
+ * gone is an empty bar that reads as a stall — the stitch stage of a backfill sat at 「0/1」 for minutes — and the
+ * clock beside it is what says the run is alive. Exported for the test.
+ */
+export function scaleOf(p) {
+  return p && p.total > 1 ? `${bar(p.done, p.total, 12)} ${dim(`${n(p.done)}/${n(p.total)}`)}` : '';
+}
+
+export async function watchRun(token, runId, label, { pollMs = POLL_MS, maxMs = WAIT_MAX_MS } = {}) {
+  const t0 = Date.now();
+  let view = null;
+  const stop = spin((frame) => {
+    const p = view?.progress ?? null;
+    // Before the first answer, and while the run sits unclaimed, the honest word is
+    // that it is queued — not a stage name we have not been told yet.
+    const lamp = p?.lamp ?? (view?.status === 'processing' ? '시작하는 중' : '차례 기다리는 중');
+    // A stage with a count gets a bar; one without (scan, relevance, project) does not,
+    // so the field is padded — otherwise the cost and the clock jump left and right as
+    // the run moves between the two kinds and the eye has to find them again.
+    const scale = scaleOf(p);
+    // What the run costs us to process is ours to know, not a line for the person watching — it used to be printed
+    // here, a dollar figure with nothing to do with what they pay. `DIFFIN_DEBUG` still shows it.
+    const cost = process.env.DIFFIN_DEBUG && p?.usd > 0 ? dim(`  $${Number(p.usd).toFixed(4)}`) : '';
+    // said on the line itself, where the waiting is: the run is the server's now, and closing the window costs nothing
+    return stepLive(frame, STEP, `${pad(`${label} · ${lamp}`, 30)}${pad(scale, 22)}${dim(`${since(Date.now() - t0)} · 창을 닫아도 계속됩니다`)}${cost}`);
+  });
+  try {
+    for (;;) {
+      const r = await look(token, runId);
+      if (r?.gone) return { status: 'failed', note: serverMessage(r.gone, ''), code: `http-${r.gone}` };
+      if (r?.view) view = r.view;
+      if (view && ['done', 'failed', 'empty'].includes(view.status)) return view;
+      if (Date.now() - t0 > maxMs) return null;
+      await sleep(pollMs);
+    }
+  } finally { stop(); }
+}
+
+/** the one line a finished run is worth, in the person's units */
+export function reportRun(label, view, ms) {
+  if (!view) {
+    stepSkip(STEP, `${label} · 서버가 아직 정리하고 있습니다`, dim('앱에서 이어서 볼 수 있습니다'));
+    return 'waiting';
+  }
+  // A refusal is not the run failing: the worker may be processing it happily and we
+  // simply cannot read it any more. Saying "처리에 실패했습니다" there would send a
+  // person to re-upload work that is already being written.
+  if (String(view.code ?? '').startsWith('http-')) {
+    const how = { 'http-401': '앱의 연결 화면에서 받은 토큰으로 diffin login 을 다시 하세요.', 'http-403': '이 계정의 런이 아닙니다.', 'http-404': '앱에서 진행 상황을 확인하세요.' }[view.code];
+    fail(`${label} 진행 상황을 읽지 못했습니다 — ${view.note}`, `${how ?? '앱에서 진행 상황을 확인하세요.'} 올린 작업은 서버에서 계속 정리됩니다.`);
+    return 'failed';
+  }
+  if (view.status === 'failed') {
+    fail(`${label} 처리에 실패했습니다 — ${view.note ?? '서버가 이유를 남기지 않았습니다'}`,
+      view.code === 'machine-gone' ? 'npx @diffin/cli onboard 를 다시 실행하면 같은 구간을 다시 올립니다.' : 'npx @diffin/cli onboard 를 다시 실행하세요.');
+    return 'failed';
+  }
+  const p = view.progress ?? {};
+  const spent = process.env.DIFFIN_DEBUG && p.usd > 0 ? dim(`  $${Number(p.usd).toFixed(4)}`) : '';
+  const took = dim(since((p.secs ?? 0) * 1000 || ms));
+  if (view.status === 'empty' || !(p.atoms > 0)) {
+    stepDone(STEP, `${label} · 새로 기록할 작업이 없었습니다`, took);
+    return 'empty';
+  }
+  stepDone(STEP, `${label} · 기록 ${n(p.atoms)}개 · 작업 ${n(p.goals)}개`, `${took}${spent}`);
+  return 'done';
+}
+
+/** watch every run this invocation handed over, in the order they were made */
+export async function watchAll(token, runs, opts = {}) {
+  if (!runs.length) return [];
+  const results = [];
+  for (const r of runs) {
+    const t0 = Date.now();
+    const view = await watchRun(token, r.runId, r.label, opts);
+    results.push({ ...r, view, outcome: reportRun(r.label, view, Date.now() - t0) });
+  }
+  return results;
+}
+
+/** what a finished run came to, without a line printed — the journey draws it (`watchJourney`) */
+function outcomeOf(view) {
+  if (!view) return 'waiting';
+  if (String(view.code ?? '').startsWith('http-') || view.status === 'failed') return 'failed';
+  return view.status === 'empty' || !(view.progress?.atoms > 0) ? 'empty' : 'done';
+}
+
+/**
+ * Every run this invocation handed over, watched TOGETHER and drawn as one journey (`journey.mjs`): the worker takes a
+ * person's runs one at a time, so the journey reads them as a queue, each by its size (`weight`, `journey.mjs` `queue`). Ends the journey — done, stopped (a run
+ * failed or could no longer be read) or later (the wait ran out with the server still at it) — and returns what
+ * `watchAll` returns, so the caller reads one shape either way.
+ */
+export async function watchJourney(token, runs, J, { pollMs = POLL_MS, maxMs = WAIT_MAX_MS } = {}) {
+  const t0 = Date.now();
+  const views = runs.map(() => null);
+  const finished = (v) => v && (v.gone || ['done', 'failed', 'empty'].includes(v.status));
+  for (;;) {
+    await Promise.all(runs.map(async (r, i) => {
+      if (finished(views[i])) return;
+      const got = await look(token, r.runId);
+      if (got?.gone) views[i] = { status: 'failed', note: serverMessage(got.gone, ''), code: `http-${got.gone}`, gone: got.gone };
+      else if (got?.view) views[i] = got.view;
+    }));
+    J.server(views.map((v, i) => ({ ...serverPlace(v), w: runs[i].weight ?? 1 })));
+    if (views.every(finished) || Date.now() - t0 > maxMs) break;
+    await sleep(pollMs);
+  }
+  const results = runs.map((r, i) => ({ ...r, view: finished(views[i]) ? views[i] : null, outcome: finished(views[i]) ? outcomeOf(views[i]) : 'waiting' }));
+  const sum = (k) => results.reduce((t, r) => t + Number(r.view?.progress?.[k] ?? 0), 0);
+  if (results.some((r) => r.outcome === 'failed')) {
+    J.end('stopped');
+    for (const r of results.filter((x) => x.outcome === 'failed')) fail(`${r.label} 처리에 실패했습니다 — ${r.view?.note ?? '서버가 이유를 남기지 않았습니다'}`, 'npx @diffin/cli onboard 를 다시 실행하세요.');
+  } else if (results.some((r) => r.outcome === 'waiting')) J.end('later');
+  else J.end('done', { result: { atoms: sum('atoms'), goals: sum('goals') } });
+  return results;
+}

package/package.json

@@ -1,6 +1,23 @@
 {
   "name": "@diffin/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Capture your AI work history into diffin",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://diffin.work",
+  "type": "module",
+  "bin": {
+    "diffin": "./bin/diffin.mjs"
+  },
+  "publishConfig": { "access": "public" },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "templates"
+  ],
+  "scripts": {
+    "test": "for f in bin/*.mjs lib/*.mjs lib/sources/*.mjs; do node --check $f || exit 1; done && node test/no-shadowed-import.mjs && node test/ui.mjs && node test/scrub-self.mjs && node test/scrub-rules.mjs && node test/run-pin.mjs && node test/capture.mjs && node test/capture-all.mjs && node test/ignore.mjs && node test/allow.mjs && node test/machine.mjs && node test/launch.mjs && node test/command.mjs && node test/init.mjs && node test/onboard.mjs && node test/watch.mjs && node test/journey.mjs && node test/net-https.mjs && node test/net-429.mjs && node test/state.mjs && node test/hermes.mjs && node test/codex.mjs && node test/antigravity.mjs && node test/status.mjs"
+  }
+}

package/templates/skills/capture/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: capture
+description: Records the work of every agent session on this machine to diffin (the AI-work ledger). Run `diffin capture` at the end of ANY turn in which a step of work got done — in any kind of work, not only code. A step is done when (1) something left the person's hands: sent, submitted, published, shared, handed over, exported, committed, merged, deployed; (2) a version was accepted: a draft, design, wording, plan or fix the person said yes to after revising; (3) a question got its answer: a research, comparison, calculation or diagnosis the person will act on; (4) a direction was decided; (5) the person wrapped up, moved to something else, or a long turn came to a stop. Examples outside code: an email ready to send, a report section finished, a slide deck shared, a spreadsheet analysis answered, a contract clause agreed, a lesson plan done, an application submitted. Always when the user says "기록해", "캡처해", "record this", "capture". The bar is low on purpose: run it after each finished step, not only at milestones, and when unsure, run it — the command itself ends a call that comes too soon, without sending, and says when the next may go up, so an extra call costs nothing and a missed one loses the record. Runs alone, with no confirmation.
+license: Proprietary. Part of the diffin CLI.
+compatibility: Requires the diffin CLI on PATH (`npx @diffin/cli onboard` installs it; or npm i -g @diffin/cli), signed in once with `diffin login`, and network access to the diffin server. Reads the agent session transcripts on this machine — every session that moved since it was last recorded. Capture supports Claude Code, Codex, Antigravity and Hermes sessions; under other agents the command says so.
+allowed-tools: Bash(diffin capture:*)
+metadata:
+  author: diffin
+  version: "3.13"
+---
+
+# Capture (diffin)
+
+You decide **when** to record. You never describe the work: the server extracts it
+from the transcript, so nothing is recorded twice or in a different shape. The person
+consented to recording when they installed diffin and chose which folders to exclude,
+so the send needs no confirmation and asks nothing — it is one command at the end of
+your turn, like a commit.
+
+## When — whenever something just landed
+
+One record carries **everything since the last one**, from every session on this
+machine, and the server arranges the whole day again each time. Spacing is not your
+job: the command ends a call that comes too soon on this machine, without sending
+anything, and the server refuses one that slips through. A call too many costs nothing;
+a call missed leaves the person's work unrecorded until someone remembers.
+
+Run it at the end of the turn in which a step got done. Work of any kind ends in one
+of five ways; the developer's commit, merge and deploy are only the first one's
+examples:
+
+- **something left the person's hands** — sent, submitted, published, shared, handed
+  over, exported, saved and closed. Code: committed, merged, pushed, deployed,
+  released. Elsewhere: an email sent, a report section handed over, a slide deck
+  shared, an application submitted, a post published, a file exported
+- **a version was accepted** — a revise-and-review loop ended in "좋아 / 이걸로 가자 /
+  확정". Code: a bug fixed and verified, a test made to pass, a screen or feature
+  finished. Elsewhere: a draft, a wording, a design, a plan, a contract clause, a
+  lesson plan the person said yes to
+- **a question got its answer** — an analysis, comparison, investigation, calculation
+  or diagnosis reached what the person will act on. Code: the cause of a failure found.
+  Elsewhere: a research conclusion, a candidate chosen, a figure computed
+- **a direction was decided** — the person confirmed a choice or a plan that changes
+  what gets made or sent next
+- **it stopped** — the person is wrapping up, turning to something unrelated, stepping
+  away, or a long turn (many files, many commands, many drafts) came to a stop with no
+  milestone behind it
+
+A step of a larger job counts; the next step is another record. And always when the
+person says **기록해 / 캡처해 / record this / capture**.
+
+The bar is low on purpose. A record is for a finished step, not a finished project: a
+working session of a few hours should produce several, not one at the end. Hold off
+only in the middle of something still moving — a test still failing, a change
+half-made, a question you just asked them. Otherwise, **when you are unsure, run it.**
+
+## You do not need to know when the last record was
+
+You usually cannot know — it may have gone up from another window, or this
+conversation may have been cleared or compacted since. That is fine: **the command
+knows**. It keeps, on this machine, the time before which the server will refuse a
+record, and answers an early call at once without sending anything.
+
+So the rule is about what you have *seen in this conversation*:
+
+- If a reply in this conversation said `다음 기록은 HH:MM 이후에 가능합니다`, do not
+  run the command again before that time. Check the time with `date` if you are unsure.
+- If you have seen no such reply (a new or cleared conversation), running it once at a
+  resting point is right. If it is early you get that line back, and now you know.
+- Never run it twice in a row, and never retry a refusal.
+
+## How — one command, at the end of the turn
+
+Finish the person's work first. Then run, as a lone command:
+
+```
+diffin capture
+```
+
+It sends the new turns of **every** agent session on this machine, each from where it
+was last recorded, already scrubbed; tool output, images and thinking never leave the
+machine. `diffin capture --this` sends only this session. Do not bundle it with other
+commands, do not ask whether to send, and do not tell the person to run it.
+
+Then one short line at most, and stop:
+
+| reply | what to say |
+|---|---|
+| `올렸습니다` | `diffin 에 기록했습니다.` — and remember the time it gives for the next record |
+| `다음 기록은 … 이후에 가능합니다` | nothing if you ran it on your own judgment; if the person asked for a record, tell them that time and that this work goes up then |
+| `새 작업이 없습니다` / `최근 움직인 세션이 없습니다` | nothing — it was already recorded |
+| `새 폴더 N곳은 아직 기록하지 않습니다 · …` | relay that line once, as it is — it names the folders and the two commands. Do not run `diffin allow` or `diffin folders` yourself: they refuse without a terminal, and allowing a folder is the person's decision |
+| `일시정지 중` | nothing — the person paused recording; what is said while paused is not recorded, and `diffin resume` turns it back on |
+| `샌드박스 안이라 올릴 수 없습니다` | tell the person once, in one line, what it says to do (run `diffin init` in a terminal, then restart the agent); do not retry |
+| `로그인이 필요합니다` | tell the person to run the connect command from the diffin app once |
+| a daily limit | nothing — tomorrow |
+| anything else | show the message once; do not retry |
+
+## Never
+
+- Write, edit or summarise the record yourself — the server extracts it.
+- Send anything by another path (no curl, no reading transcripts into a message).
+- Record from a folder the person excluded (`--exclude`, `.diffin-ignore`) or a
+  conversation they asked you not to record — say `diffin pause` exists if they want
+  a quiet stretch.
+- Allow a folder on the person's behalf. A folder they never allowed is held by the
+  command itself; only they widen it, on a terminal (`diffin allow`, `diffin folders`).