@diffin/cli 0.1.1 → 0.1.3

package/lib/capture.mjs

@@ -24,7 +24,7 @@ import { putFile } from './backfill.mjs';
 import { machineHash } from './machine.mjs';
 import { detectAgent, agentById } from './agents.mjs';
 import { ensureInit } from './init.mjs';
-import { ALL_LOOKBACK_MS, allowFolders, allowedFolders, allowedSince, excludeFolders, excludedFolders, heldBy, ignoredBy, includeFolder, topFolders, withoutIgnored } from './ignore.mjs';
+import { ALL_LOOKBACK_MS, allowFolders, allowedFolders, excludeFolders, excludedFolders, folderCensus, heldBy, heldFolders, ignoredBy, includeFolder, topFolders, withoutIgnored } from './ignore.mjs';
 import { homedir } from 'node:os';
 
 const ROOT = join(process.env.DIFFIN_HOME ?? homedir(), '.claude', 'projects');
@@ -277,8 +277,8 @@ export async function planAll(ad, floors, to, entries) {
  * Candidate sessions: moved recently, and not in a folder the person excluded (ignore.mjs — the folder it began in
  * or the one it is in now, either of them under a `.diffin-ignore`).
  */
-export async function candidates(ad, now = Date.now(), { hold = false } = {}) {
-  return withoutIgnored(ad.enumerate({ from: new Date(now - ALL_LOOKBACK_MS).toISOString() }), { hold });
+export async function candidates(ad, now = Date.now()) {
+  return withoutIgnored(ad.enumerate({ from: new Date(now - ALL_LOOKBACK_MS).toISOString() }));
 }
 
 /**
@@ -289,8 +289,10 @@ export async function candidates(ad, now = Date.now(), { hold = false } = {}) {
 async function seedAllowed() {
   if (allowedFolders() !== null) return;
   const dirs = [];
-  // both folders of a session — where it began and where it is — or a session that moved would be held by the seed it made
-  for (const ad of allAdapters()) { try { const { kept } = await candidates(ad); dirs.push(...kept.flatMap((e) => [e.cwd, e.cwd0]).filter(Boolean)); } catch { /* an unreadable agent seeds nothing */ } }
+  // every folder a turn of these sessions was typed in — what the capture would have sent before the list existed, now
+  // that a turn is held by its own folder (2026-10-12; before, the two ends of each session)
+  const now = Date.now();
+  for (const ad of allAdapters()) { try { const { kept } = await candidates(ad, now); dirs.push(...(await folderCensus(kept, { tsOf: ad.tsOf, fromMs: now - ALL_LOOKBACK_MS })).keys()); } catch { /* an unreadable agent seeds nothing */ } }
   if (dirs.length) allowFolders(topFolders(dirs));
 }
 
@@ -304,10 +306,10 @@ const unscrub = (p) => (p === '~' ? homedir() : p.startsWith('~/') ? join(homedi
  * decision's own time — only the work after it goes up. Nothing here may stop a capture: a server that cannot be
  * reached, or an older server without the route, leaves the lists as they are.
  */
-async function syncFolders(token, heldAll) {
+async function syncFolders(token, heldDirs) {
   const allowed = allowedFolders();
   if (allowed === null) return { changed: false };
-  const held = topFolders(heldAll.map((h) => h.folder).filter(Boolean)).map((f) => posixPath(scrub(f)));
+  const held = topFolders(heldDirs).map((f) => posixPath(scrub(f)));
   let body = null;
   try {
     const res = await fetchRetry(`${SERVER}/folders/held`, () => ({ method: 'POST', headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' }, body: JSON.stringify({ device: deviceId(), held, allowed: allowed.map((f) => posixPath(scrub(f))), excluded: excludedFolders().map((f) => posixPath(scrub(f))) }) }), 1);
@@ -328,8 +330,8 @@ async function syncFolders(token, heldAll) {
 }
 
 /** the one line about folders waiting for the person — the agent relays it, the person acts on a terminal */
-function sayHeld(held) {
-  const folders = topFolders(held.map((h) => h.folder).filter(Boolean));
+function sayHeld(heldDirs) {
+  const folders = topFolders(heldDirs);
   if (!folders.length) return;
   say(marks.wait(), `새 폴더 ${folders.length}곳은 아직 기록하지 않습니다 · ${folders.map((f) => posixPath(scrub(f))).join(' · ')}`,
     '허용하려면 터미널에서 diffin allow <폴더> 또는 diffin folders (사람이 직접 실행합니다)');
@@ -353,13 +355,15 @@ async function captureAll() {
   // sent one agent's sessions kept the others' waiting for their own agent to ask after the gap — with three agents
   // on a machine, most of a day's work. The run is the asker's; a session of another agent names its own.
   await seedAllowed();
+  // the folders waiting are those of the turns typed in the lookback in a folder not allowed — the whole lookback, not
+  // only since the last capture: the server REPLACES its pending list with each report, so a folder reported once and
+  // left out of the next would vanish from the app before the person decided on it
   const gather = async () => {
     const found = [], heldAll = [];
     for (const ad of allAdapters()) {
-      let kept = [], held = [];
-      try { ({ kept, held } = await candidates(ad, Date.now(), { hold: true })); } catch { /* an agent whose sessions cannot be read holds nobody else back */ }
+      let kept = [];
+      try { ({ kept } = await candidates(ad, Date.now())); heldAll.push(...(await heldFolders(kept, { tsOf: ad.tsOf, fromMs: Date.now() - ALL_LOOKBACK_MS })).keys()); } catch { /* an agent whose sessions cannot be read holds nobody else back */ }
       for (const e of kept) found.push({ ad, e });
-      heldAll.push(...held);
     }
     return { found, heldAll };
   };
@@ -367,13 +371,13 @@ async function captureAll() {
   // the app may have decided on a held folder since the last capture: apply, then look again with the lists as they are now
   const { changed } = await syncFolders(token, heldAll);
   if (changed) ({ found, heldAll } = await gather());
-  // a session of a folder the person allowed after the fact goes up from that moment: the later of its two folders' times
-  const sinceOf = (e) => { const ts = [e.cwd, e.cwd0].map((c) => allowedSince(c)).filter(Boolean).sort(); return ts.length ? ts[ts.length - 1] : null; };
+  // a folder the person allowed after the fact goes up from that moment — judged per turn as the rows are read
+  // (`turnHeld`), so no session-wide `since` is sent any more: one would floor the session's other folders too
   const offered = newestFirst(found);
   if (!offered.length) { say(marks.wait(), '최근 움직인 세션이 없습니다.'); sayHeld(heldAll); return; }
   const res = await fetchRetry(`${SERVER}/backfill/runs`, () => ({
     method: 'POST', headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
-    body: JSON.stringify({ source, device: deviceId(), ...(machineHash() ? { computer: machineHash() } : {}), capture: { all: true, sessions: offered.map(({ ad, e }) => ({ id: e.sid, ...(e.last ? { last: new Date(e.last).toISOString() } : {}), ...(sinceOf(e) ? { since: sinceOf(e) } : {}), ...(ad.name !== source ? { source: ad.name } : {}) })) } }),
+    body: JSON.stringify({ source, device: deviceId(), ...(machineHash() ? { computer: machineHash() } : {}), capture: { all: true, sessions: offered.map(({ ad, e }) => ({ id: e.sid, ...(e.last ? { last: new Date(e.last).toISOString() } : {}), ...(ad.name !== source ? { source: ad.name } : {}) })) } }),
   }));
   if (!res.ok) { await refused(res); return; }
   const { runId, machine, to, floors, resumed, done } = await res.json();

package/lib/folders.mjs

@@ -6,7 +6,7 @@
 // result line names the held folders and these two commands; the agent relays the line, the person types.
 import { resolve as resolvePath } from 'node:path';
 import { allAdapters } from './sources/index.mjs';
-import { ALL_LOOKBACK_MS, allowFolders, allowedFolders, allowedFrom, excludeFolders, excludedFrom, folderCensus, folderTree, heldBy, ignoreFileFor, includeFolder, topFolders, withoutIgnored } from './ignore.mjs';
+import { ALL_LOOKBACK_MS, allowFolders, allowedFolders, allowedFrom, excludeFolders, excludedFrom, folderCensus, folderTree, heldBy, heldFolders, ignoreFileFor, includeFolder, topFolders, withoutIgnored } from './ignore.mjs';
 import { posixPath, scrub } from './scrub.mjs';
 import { dim, fail, ok, out, selectMany, spin, stepLive } from './ui.mjs';
 
@@ -20,9 +20,9 @@ async function recent() {
   const jobs = [], heldDirs = [];
   for (const ad of allAdapters()) {
     try {
-      const { kept, held } = await withoutIgnored(ad.enumerate({ from: new Date(fromMs).toISOString() }), { hold: true });
-      jobs.push({ ad, entries: [...kept, ...held.map((h) => h.entry)], cutOpts: { tsOf: ad.tsOf, fromMs, toMs: now } });
-      heldDirs.push(...held.map((h) => h.folder));
+      const { kept } = await withoutIgnored(ad.enumerate({ from: new Date(fromMs).toISOString() }));
+      jobs.push({ ad, entries: kept, cutOpts: { tsOf: ad.tsOf, fromMs, toMs: now } });
+      heldDirs.push(...(await heldFolders(kept, { tsOf: ad.tsOf, fromMs })).keys());
     } catch { /* an agent whose sessions cannot be read is left out */ }
   }
   return { jobs, held: topFolders(heldDirs) };

package/lib/ignore.mjs

@@ -81,7 +81,7 @@ export function topFolders(folders) {
 }
 /**
  * Allow folders. `at` is the moment the PERSON allowed them (a terminal command, the app's decision): only the work after
- * it goes up (`allowedSince`, sent as a capture session's `since`). The onboarding list and the seed pass no time — those
+ * it goes up — each turn made in that folder is judged against it (`turnHeld`). The onboarding list and the seed pass no time — those
  * folders' history is the backfill's and the watermark's, as before.
  */
 export function allowFolders(folders, at) {
@@ -149,12 +149,9 @@ export async function folderCensus(entries, { tsOf, fromMs = 0, toMs = Infinity
   const turns = new Map();
   for (const e of entries) {
     for await (const r of e.files[0].rows()) {
-      if (r?.type !== 'user' || r.isMeta) continue;
+      if (!isSaid(r)) continue;
       const t = tsOf(r);
       if (t && (t < fromMs || t >= toMs)) continue;
-      const c = r.message?.content;
-      const said = typeof c === 'string' ? c.trim() : Array.isArray(c) && !c.some((b) => b?.type === 'tool_result') && c.some((b) => b?.type === 'text' && String(b.text ?? '').trim());
-      if (!said) continue;
       const dir = String(r.cwd ?? e.cwd ?? '');
       if (!dir || ignoredBy(dir)) continue;
       turns.set(dir, (turns.get(dir) ?? 0) + 1);
@@ -190,19 +187,62 @@ export function excludedFrom(tree, on) {
 }
 
 /**
- * Split a list of sessions into the ones that may be sent, how many a `.diffin-ignore` held back, and — with `hold` —
- * the ones waiting for the person to allow their folder (`held`: the session and the folder it is in). A session is
- * held when the folder it began in OR the one it is in now is held, as it is excluded by either.
+ * Split a list of sessions into the ones that may be sent and how many a `.diffin-ignore` or an exclusion held back
+ * (by the folder a session began in OR is in now — an exclusion stays session-wide, the stricter reading).
+ *
+ * Waiting for an allowance is NOT decided here any more (2026-10-12): it is decided per TURN, by the folder the person
+ * spoke in (`turnHeld`, applied as rows are read in stream.mjs). Judged per session, a session that began in a folder
+ * since renamed was held for good (the front session: 183 turns under the old name, 722 under the allowed one), and a
+ * session that began and ended in an allowed folder sent the turns it made in another project in between (miner-server:
+ * 281 turns in two other apps; this repository's oldest session: 74 in two folders never allowed).
  */
-export async function withoutIgnored(entries, { hold = false } = {}) {
-  const kept = [], held = [];
+export async function withoutIgnored(entries) {
+  const kept = [];
   let ignored = 0;
   for (const e of entries) {
     const f = await sessionFolders(e);
     if (f.ignored) { ignored++; continue; }
     const cwd = f.last ?? f.first ?? e.cwd;
-    if (hold && (heldBy(f.first) || heldBy(f.last))) { held.push({ entry: { ...e, cwd }, folder: heldBy(f.last) ? f.last : f.first }); continue; }
     kept.push({ ...e, cwd, cwd0: f.first ?? cwd });
   }
-  return { kept, ignored, held };
+  return { kept, ignored };
+}
+
+/**
+ * Whether a turn the person made in `dir` at `ms` waits (is not sent): its folder is not allowed on a machine that has a
+ * list, or it was made before the person allowed that folder. A machine with no list holds nothing — it sends as before.
+ */
+export function turnHeld(dir, ms) {
+  if (!dir || allowedFolders() === null) return false;
+  if (heldBy(dir)) return true;
+  const since = allowedSince(dir);
+  return Boolean(since && ms && ms < Date.parse(since));
+}
+
+/** a row that is a turn the person typed — not a tool result, not a meta line — the unit a folder is judged by */
+export function isSaid(r) {
+  if (r?.type !== 'user' || r.isMeta) return false;
+  const c = r.message?.content;
+  return typeof c === 'string' ? Boolean(c.trim()) : Array.isArray(c) && !c.some((b) => b?.type === 'tool_result') && c.some((b) => b?.type === 'text' && String(b.text ?? '').trim());
+}
+
+/**
+ * The folders of the turns that are waiting — made at or after `fromMs` in a folder the person has not allowed — with how
+ * many. What a capture reports to the app and names in its result line, and what `diffin folders` puts first: the folders
+ * a person actually spoke in, never the name a session began under.
+ */
+export async function heldFolders(entries, { tsOf, fromMs = 0 }) {
+  const turns = new Map();
+  if (allowedFolders() === null) return turns;
+  for (const e of entries) {
+    for await (const r of e.files[0].rows()) {
+      if (!isSaid(r)) continue;
+      const t = tsOf(r);
+      if (t && t < fromMs) continue;
+      const dir = String(r.cwd ?? e.cwd ?? '');
+      if (!dir || ignoredBy(dir) || !heldBy(dir)) continue;
+      turns.set(dir, (turns.get(dir) ?? 0) + 1);
+    }
+  }
+  return turns;
 }

package/lib/stream.mjs

@@ -7,7 +7,7 @@
 // that has a database yields rows straight from its query. Nothing is written to disk
 // on the way — so no unscrubbed copy of a session ever sits in a temp directory.
 import { cleanRow, queuedTurn } from './scrub.mjs';
-import { ignoredBy } from './ignore.mjs';
+import { ignoredBy, isSaid, turnHeld } from './ignore.mjs';
 import { offTheRecord } from './state.mjs';
 
 const TAIL = 8;
@@ -19,6 +19,7 @@ const TAIL_CHARS = 300;
 export async function* streamCutScrub(rows, { tsOf, fromMs = 0, toMs = Infinity }) {
   const tail = [];
   let started = false, hidden = false;
+  let waiting = null; // the current turn waits for an allowance: set at each turn the person typed, inherited by its answer
   const off = offTheRecord(); // the stretches the person had recording paused
 
   for await (const row of rows) {
@@ -27,6 +28,13 @@ export async function* streamCutScrub(rows, { tsOf, fromMs = 0, toMs = Infinity
     // passed through an excluded folder loses those turns and keeps the rest.
     if (row?.cwd && ignoredBy(String(row.cwd))) continue;
     const t = tsOf(row);
+    // …and a TURN the person made in a folder they have not allowed (or before they allowed it) waits, with its answer:
+    // judged at the row the person typed, by the folder they spoke in, and inherited by every row up to the next one —
+    // so an agent that steps into /tmp mid-answer does not cut the answer, and an answer given while the person sat in
+    // another project does not go up with the allowed work around it (ignore.mjs `turnHeld`, 2026-10-12). Before the
+    // first typed turn a row is judged by its own folder.
+    if (row?.cwd && (isSaid(row) || waiting === null)) waiting = turnHeld(String(row.cwd), t); // a turn with no folder keeps the last verdict
+    if (waiting) continue;
     // …and a row from a paused stretch does not either: paused means off the record, not sent later. A row with no
     // time goes with the row before it, as it does at the window's edge.
     if (off) { if (t) hidden = off(t); if (hidden) continue; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diffin/cli",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Capture your AI work history into diffin",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://diffin.work",
@@ -18,6 +18,6 @@
     "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"
+    "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/turn-hold.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

@@ -1,12 +1,12 @@
 ---
 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.
+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, exported, committed, merged, deployed); (2) a version was accepted (a draft, design, plan or fix the person said yes to); (3) a question got its answer (research, comparison, diagnosis the person will act on); (4) a direction was decided; (5) the person wrapped up or moved on. Outside code: an email ready to send, a report section finished, a deck shared, an analysis answered. Always when the user says \"기록해\", \"캡처해\", \"record this\", \"capture\". The bar is low: when unsure, run it. The command ends a call that comes too soon without sending, so an extra call costs nothing and a missed one loses the record. A failed call never ends capturing: run it again at the next step. Runs alone, 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"
+  version: "3.14"
 ---
 
 # Capture (diffin)
@@ -96,6 +96,11 @@ Then one short line at most, and stop:
 | a daily limit | nothing — tomorrow |
 | anything else | show the message once; do not retry |
 
+"Do not retry" is about THAT call, never about the session. A capture that failed, crashed or was refused does not
+end capturing here: at the next finished step, run `diffin capture` again as if nothing had happened — the cause may
+already be fixed, and the command decides for itself whether it may send. Do not leave capturing to another session,
+another agent or the person because one call failed.
+
 ## Never
 
 - Write, edit or summarise the record yourself — the server extracts it.