@bunshin-cc/bunshin 0.4.1 → 0.4.3

package/dist/bin.js

@@ -879,6 +879,8 @@ function firstHeading(text2) {
 function applyTextOp(text2, op, legacyAnchor = "") {
   const anchor = "anchor" in op && op.anchor || legacyAnchor;
   switch (op.op) {
+    case "situation":
+      return { ok: true, text: text2 };
     case "rewrite":
       return { ok: true, text: op.text };
     case "create":
@@ -1744,6 +1746,11 @@ ${robot ? `- Values that belong to THIS robot or cell (calibration, pixel column
 - Code that should change (a hard-coded constant, a helper) \u2192 describe it as an append to the
   skill's section, stating the change; reconciliation turns it into a harness patch.` : `- Machine specifics and personal preferences \u2192 your own user layer.`}
 - Never include secrets, credentials or customer data.
+- A retrieval miss: if a document in the list above would have helped, but the agent did not use
+  it (the user had to point at it, asked why it was not used, or the agent found it only late), add
+  op "situation" to that document: the request as the user actually phrased it, made general (names
+  and ticket ids replaced by what they stand for), e.g. "run me through an e2e test and what it
+  does". Recall learns from it, so the next such request finds the document.
 
 ## Output
 
@@ -1755,7 +1762,8 @@ At most ${max} suggestions. Schema:
                       | {"op": "create", "section": {"kind": "skill"|"procedure"|"spec"|"verification"|"rule"|"guardrail"|"reference",
                                                       "title": string, "body": string, "when": string,
                                                       "paths"?: string[], "entities"?: string[], "skills"?: string[]}}
-                      | {"op": "param", "key": string, "value": string|number|boolean},
+                      | {"op": "param", "key": string, "value": string|number|boolean}
+                      | {"op": "situation", "text": string},
                   "rationale": string, "urgency": "normal"|"urgent"}]}`;
 }
 function extractJson(text2) {
@@ -1797,6 +1805,10 @@ function parseOp(raw) {
         section: { kind, title, body, when: when || title, paths: strList(s.paths), entities: strList(s.entities).map((e) => e.toLowerCase()), skills: strList(s.skills) }
       };
     }
+    case "situation": {
+      const text2 = clean(o.text);
+      return text2 ? { op: "situation", text: text2.slice(0, 500) } : null;
+    }
     case "param": {
       const key = typeof o.key === "string" ? o.key.trim() : "";
       const v = o.value;
@@ -2375,6 +2387,17 @@ var init_store2 = __esm({
         this.writeSession(s);
         return s;
       }
+      listSessions() {
+        const dir = this.p("sessions");
+        if (!fileExists(dir)) return [];
+        const out = [];
+        for (const f of fs4.readdirSync(dir)) {
+          if (!f.endsWith(".json") || f === "current.json") continue;
+          const raw = readJson(path3.join(dir, f), null);
+          if (raw?.sessionId) out.push(normalizeSession(raw.sessionId, raw));
+        }
+        return out;
+      }
       readCurrent() {
         return readJson(this.p("sessions", "current.json"), null);
       }
@@ -3599,6 +3622,8 @@ function summarize(op) {
       return clip(op.content === null ? `delete ${op.path}` : `file ${op.path}`);
     case "retire":
       return clip(`retire: ${op.reason}`);
+    case "situation":
+      return clip(`also applies to: ${op.text}`);
   }
 }
 function describeTarget(s, view) {
@@ -3776,8 +3801,8 @@ __export(sync_exports, {
 import fs9 from "node:fs";
 import path8 from "node:path";
 function episodePayload(e) {
-  const { orgId: _o, uploaded: _u, servedReported: _s, ...rest } = e;
-  void _o, _u, _s;
+  const { orgId: _o, uploaded: _u, servedReported: _s, reportedServed: _rs, reportedLoaded: _rl, ...rest } = e;
+  void _o, _u, _s, _rs, _rl;
   return rest;
 }
 function suggestionPayload(s) {
@@ -3817,15 +3842,18 @@ async function syncV2(store, opts = {}) {
         await call("POST", "/episodes", { episode: episodePayload(e) });
         const fresh = v2.readEpisode(e.id) ?? e;
         const next = { ...fresh, uploaded: JSON.stringify(episodePayload(fresh)) === JSON.stringify(episodePayload(e)) ? true : fresh.uploaded };
-        if (!fresh.servedReported) {
-          const served = e.sectionsServed.filter((id) => !isLocalId(id));
-          const loaded = e.sectionsLoaded.filter((id) => !isLocalId(id));
-          try {
-            if (served.length) await call("POST", "/recall/served", { sectionIds: served });
-            if (loaded.length) await call("POST", "/recall/served", { sectionIds: loaded, loaded: true });
-            next.servedReported = true;
-          } catch {
-          }
+        const legacy = fresh.servedReported && !fresh.reportedServed;
+        const doneServed = new Set(legacy ? e.sectionsServed : fresh.reportedServed ?? []);
+        const doneLoaded = new Set(legacy ? e.sectionsLoaded : fresh.reportedLoaded ?? []);
+        const served = e.sectionsServed.filter((id) => !isLocalId(id) && !doneServed.has(id));
+        const loaded = e.sectionsLoaded.filter((id) => !isLocalId(id) && !doneLoaded.has(id));
+        try {
+          if (served.length) await call("POST", "/recall/served", { sectionIds: served });
+          if (loaded.length) await call("POST", "/recall/served", { sectionIds: loaded, loaded: true });
+          next.reportedServed = [...doneServed, ...served];
+          next.reportedLoaded = [...doneLoaded, ...loaded];
+          delete next.servedReported;
+        } catch {
         }
         v2.writeEpisode(next);
         report.uploadedEpisodes++;
@@ -8016,6 +8044,10 @@ init_store2();
 init_view();
 var NUDGE_TEXT = "This looks worth capturing. Consider /learn.";
 var NUDGE_INTERVAL_MS = 60 * 6e4;
+var CHECKPOINT_MS = 30 * 6e4;
+var LEFTOVER_IDLE_MS = 60 * 6e4;
+var LEFTOVER_MAX_AGE_MS = 14 * 24 * 60 * 6e4;
+var LEFTOVERS_PER_START = 5;
 var MAX_PUSH = 3;
 var additional = (hookEventName, text2) => text2.trim() ? { hookSpecificOutput: { hookEventName, additionalContext: text2.trim() } } : {};
 function touch(v2, ctx, patch = () => {
@@ -8058,6 +8090,11 @@ async function onSessionStart(ctx) {
   v2.writeCurrent({ sessionId: id, cwd: ctx.cwd, at: now });
   const config = ctx.store.config();
   if (canCall(config)) {
+    try {
+      const swept = checkpointLeftovers(ctx.store, id);
+      if (swept.length) v2.log("v2-leftovers", { session: id, episodes: swept });
+    } catch {
+    }
     const budget = Math.min(3e3, ctx.deadline - Date.now() - 400);
     if (budget > 100) {
       try {
@@ -8240,6 +8277,16 @@ function onStop(ctx) {
   const config = ctx.store.config();
   if (ctx.input.stop_hook_active) return {};
   const scan = scanTranscript(ctx.input.transcript_path ?? session.transcriptPath);
+  if (canCall(config) && checkpointDue(session, scan, now)) {
+    try {
+      const { episode } = buildEpisode(ctx.store, session, void 0, now, { scan });
+      v2.writeEpisode(episode);
+      markCheckpoint(v2, session, scan, now);
+      ctx.detach(["--root", ctx.store.root, "sync", "--quiet"], { cwd: ctx.cwd });
+      v2.log("v2-checkpoint", { session: session.sessionId, episode: episode.id });
+    } catch {
+    }
+  }
   const check = learningCheck(v2, session, scan.facts.toolCalls, now);
   if (check) return check;
   if (!config.reflect.nudge) return {};
@@ -8271,11 +8318,11 @@ function learningCheck(v2, session, toolCalls, now) {
   const reason = doc.body.replace(/^\s*<!--\s*bunshin:[\s\S]*?-->\s*/, "").trim().replace(/\{delta\}/g, String(toolCalls - last));
   return { decision: "block", reason };
 }
-function buildEpisode(store, session, transcriptPath, now = /* @__PURE__ */ new Date()) {
+function buildEpisode(store, session, transcriptPath, now = /* @__PURE__ */ new Date(), opts = {}) {
   const v2 = new V2Store(store);
   const config = store.config();
   const view = localView(v2, config, session.cwd, { index: false });
-  const scan = scanTranscript(transcriptPath);
+  const scan = opts.scan ?? scanTranscript(transcriptPath ?? session.transcriptPath);
   const outcome = v2.readOutcome(session.sessionId);
   const signals = { ...sessionSignals({ scan, startedAt: session.startedAt, lastActivityAt: session.lastActivityAt }), ...outcome ? { outcome: outcome.status } : {} };
   const gate = sessionGate(signals, { now: now.toISOString(), cacheTtlMs: config.reflect.cacheTtlMs });
@@ -8292,7 +8339,7 @@ function buildEpisode(store, session, transcriptPath, now = /* @__PURE__ */ new
     harness: ["claude-code", "codex", "pi", "other"].includes(session.harness) ? session.harness : config.harness,
     task: session.task,
     startedAt: session.startedAt,
-    endedAt: now.toISOString(),
+    endedAt: opts.endedAt ?? now.toISOString(),
     sectionsServed: session.served,
     sectionsLoaded: session.loaded,
     captured: session.captured,
@@ -8305,10 +8352,53 @@ function buildEpisode(store, session, transcriptPath, now = /* @__PURE__ */ new
     ...snippets.length ? { snippets } : {},
     ...outcome ? { outcome } : {},
     ...view.bundle?.release?.version ? { harnessVersion: view.bundle.release.version } : {},
-    uploaded: false
+    uploaded: false,
+    ...previous?.reportedServed ? { reportedServed: previous.reportedServed } : {},
+    ...previous?.reportedLoaded ? { reportedLoaded: previous.reportedLoaded } : {},
+    ...previous?.servedReported ? { servedReported: true } : {}
   };
   return { episode, gate, scan };
 }
+var progressOf = (scan) => scan.facts.toolCalls + scan.facts.turns.length;
+function checkpointDue(session, scan, now) {
+  const since = Date.parse(session.checkpointAt ?? session.startedAt);
+  if (!Number.isFinite(since) || now.getTime() - since < CHECKPOINT_MS) return false;
+  return progressOf(scan) > (session.checkpointProgress ?? 0);
+}
+function markCheckpoint(v2, session, scan, now) {
+  v2.updateSession(session.sessionId, session.cwd, (s) => {
+    s.checkpointAt = now.toISOString();
+    s.checkpointProgress = progressOf(scan);
+    s.checkpointActivity = s.lastActivityAt;
+  });
+}
+function checkpointLeftovers(store, currentSessionId, now = /* @__PURE__ */ new Date()) {
+  const v2 = new V2Store(store);
+  const out = [];
+  const candidates = v2.listSessions().filter((s) => {
+    if (s.sessionId === currentSessionId || !s.transcriptPath) return false;
+    const idle = now.getTime() - Date.parse(s.lastActivityAt);
+    if (!(idle >= LEFTOVER_IDLE_MS && idle <= LEFTOVER_MAX_AGE_MS)) return false;
+    return s.checkpointActivity !== s.lastActivityAt;
+  }).sort((a, b) => b.lastActivityAt.localeCompare(a.lastActivityAt));
+  for (const s of candidates) {
+    if (out.length >= LEFTOVERS_PER_START) break;
+    const config = store.config();
+    const id = episodeIdFor(localView(v2, config, s.cwd, { index: false }).ctx.id, s.sessionId);
+    const prev = v2.readEpisode(id);
+    if (prev && prev.endedAt >= s.lastActivityAt) {
+      v2.updateSession(s.sessionId, s.cwd, (x) => {
+        x.checkpointActivity = x.lastActivityAt;
+      });
+      continue;
+    }
+    const { episode, scan } = buildEpisode(store, s, void 0, now, { endedAt: s.lastActivityAt });
+    v2.writeEpisode(episode);
+    markCheckpoint(v2, s, scan, now);
+    out.push(episode.id);
+  }
+  return out;
+}
 function recordTrialEvidence(v2, session, outcome) {
   if (!outcome || outcome.status === "unknown") return 0;
   const used = /* @__PURE__ */ new Set([...session.loaded, ...session.pushed]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunshin-cc/bunshin",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Shared memory for company AI agents. Connect Codex, Claude Code, or Pi to Bunshin.",
   "type": "module",
   "bin": {