@hypercarrier/rarebit 0.2.0 → 0.3.0

package/test/rarebit-recap.test.mjs

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import test from "node:test";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 
-import { selectRarebits } from "../src/rarebit-core.mjs";
+import { selectRarebits, sha256 } from "../src/rarebit-core.mjs";
 import registerPiRarebit from "../src/extension.mjs";
 import { readConfiguredRarebitSettings } from "../src/extension.mjs";
 import { processRarebitSummary } from "../src/rarebit-service.mjs";
@@ -52,20 +52,41 @@ function contextFor({ sessionId = "session-1", sessionFile = "/tmp/session-1.jso
 function receiptFor(ctx, jobId = "job-1") {
   const branch = ctx.sessionManager.getBranch();
   const selection = selectRarebits(branch);
+  const observedAt = "2026-09-27T00:00:00.000Z";
+  const latestUser = selection.occurrences.filter((item) => item.role === "user").at(-1);
   return {
+    schemaVersion: 4,
     type: "rarebit_summary",
     status: "ok",
-    jobId,
+    jobId: /^[a-f0-9]{64}$/.test(jobId) ? jobId : "1".repeat(64),
     sessionId: ctx.sessionManager.getHeader().id,
-    branch: {
-      leafId: branch.at(-1)?.id ?? null,
-    },
+    implementationVersion: "hc-rarebit-summary-v7",
+    synthesisMode: "forced",
+    lifecycleBoundary: "agent_settled",
+    inputCoveragePolicy: { strategy: "newest_suffix_with_explicit_omission", maxPromptChars: 10_000 },
+    promptVersion: "rarebit-summary-v8",
+    model: { provider: "test", id: "model" },
+    modelProvenance: { source: "test", status: "resolved" },
+    observedAt,
+    branch: { leafId: branch.at(-1)?.id ?? null, entryCount: branch.length, pathHash: sha256(branch.map((item) => item.id)) },
     selection: {
       manifestHash: selection.manifestHash,
       selectorVersion: selection.manifest.selectorVersion,
+      occurrenceCount: selection.occurrences.length,
+      uniquePayloadCount: selection.payloads.length,
+      latestUserSourceEntryId: latestUser?.sourceEntryId ?? null,
     },
     sessionStatus: "finished",
+    statusReason: "all_requests_accomplished",
+    inputCoverage: { totalMessageCount: selection.occurrences.length, includedMessageCount: selection.occurrences.length, omittedMessageCount: 0, omittedTextChars: 0, promptChars: 500, complete: true },
     summary: "RECAP_SENTINEL: display-only current Summary",
+    synthesis: {
+      schemaVersion: 1, kind: "rarebit_model_synthesis", outcome: "complete",
+      requestedModel: { provider: "test", id: "model" },
+      timing: { startedAt: observedAt, completedAt: observedAt, durationMs: 0, provenance: "local_monotonic_clock" },
+      provider: Object.fromEntries(["responseProvider", "responseProviderSource", "responseModel", "responseModelSource", "responseId", "responseIdSource", "requestId", "requestIdSource"].map((key) => [key, null])),
+      usage: { availability: "unavailable", ...Object.fromEntries(["inputTokens", "outputTokens", "totalTokens", "cacheReadTokens", "cacheWriteTokens", "reasoningTokens", "estimatedCostUsd"].map((key) => [key, null])), provenance: Object.fromEntries(["inputTokens", "outputTokens", "totalTokens", "cacheReadTokens", "cacheWriteTokens", "reasoningTokens", "estimatedCostUsd"].map((key) => [key, null])) },
+    },
   };
 }
 
@@ -81,6 +102,47 @@ function currentFor(receipt) {
   };
 }
 
+test("request-prefix Recap stores only the receipt evidence cut and its hash", async () => {
+  const branch = branchFor("later-assistant");
+  branch[1].message.stopReason = "toolUse";
+  const ctx = contextFor({ branch, setWidget() {} });
+  const prefix = selectRarebits(branch.slice(0, 1));
+  const receipt = {
+    ...receiptFor(ctx), lifecycleBoundary: "owner_request", sessionStatus: "user_requested",
+    statusReason: "owner_request_recorded",
+    selection: {
+      manifestHash: prefix.manifestHash,
+      selectorVersion: prefix.manifest.selectorVersion,
+      occurrenceCount: prefix.occurrences.length,
+      uniquePayloadCount: prefix.payloads.length,
+      latestUserSourceEntryId: "owner-1",
+    },
+  };
+  const saved = [];
+  const controller = createRarebitRecapController({
+    delayMs: 0,
+    appendEntry: (type, data) => {
+      const entry = { type: "custom", customType: type, id: `entry-${saved.length}`, data };
+      saved.push(entry);
+      branch.push(entry);
+    },
+    readCurrent: async () => ({ receipt, artifactState: {
+      syncState: "request_current", applicability: "request_generation",
+      receiptRef: { jobId: receipt.jobId }, projection: { status: receipt.sessionStatus },
+    } }),
+  });
+  const result = await controller.showExisting(ctx);
+  assert.equal(result.shown, true);
+  assert.equal(saved.length, 1);
+  assert.equal(saved[0].data.coveredEntryId, "owner-1");
+  assert.equal(saved[0].data.selectionHash, prefix.manifestHash);
+  assert.equal((await controller.showExisting(ctx)).shown, true);
+  assert.equal(saved.length, 1, "redisplay reuses the active-branch Recap identity");
+  const rendered = controller.renderEntry(saved[0], {}, { fg: (_tone, text) => text }).render(15);
+  assert.ok(rendered.some((line) => line.includes("Recap·") && line.endsWith("[got it]")), "ANSI-aware truncation reserves the inline action width");
+  assert.equal(rendered.some((line) => line.trim() === "[got it]"), false);
+});
+
 function fakeClock() {
   let now = 0;
   let nextId = 1;
@@ -115,6 +177,45 @@ function fakeClock() {
   };
 }
 
+test("a request-prefix Recap rejects a live assistant stop while settlement is pending", async () => {
+  const branch = branchFor();
+  const ctx = contextFor({ branch, setWidget() {} });
+  const prefix = selectRarebits(branch.slice(0, 1));
+  const receipt = { ...receiptFor(ctx), lifecycleBoundary: "owner_request", sessionStatus: "user_requested",
+    statusReason: "owner_request_recorded", selection: {
+    manifestHash: prefix.manifestHash, selectorVersion: prefix.manifest.selectorVersion,
+    occurrenceCount: 1, uniquePayloadCount: prefix.payloads.length,
+    latestUserSourceEntryId: "owner-1",
+  } };
+  const controller = createRarebitRecapController({ readCurrent: async () => ({ receipt, artifactState: {
+    syncState: "request_current", applicability: "request_generation",
+    receiptRef: { jobId: receipt.jobId }, projection: { status: receipt.sessionStatus },
+  } }) });
+  const result = await controller.showExisting(ctx);
+  assert.equal(result.shown, false);
+  assert.equal(result.reason, "settlement_pending");
+});
+
+test("Recap reprojects the live branch after asynchronous renderer imports", async () => {
+  const branch = branchFor();
+  const ctx = contextFor({ branch, setWidget() {} });
+  const receipt = receiptFor(ctx);
+  let reads = 0;
+  const saved = [];
+  const controller = createRarebitRecapController({
+    appendEntry: (type, data) => saved.push({ type, data }),
+    readCurrent: async () => {
+      reads += 1;
+      if (reads === 2) branch.push({ id: "new-user", type: "message", message: { role: "user", content: "new request" } });
+      return currentFor(receipt);
+    },
+  });
+  const result = await controller.showExisting(ctx);
+  assert.equal(reads, 2);
+  assert.equal(result.shown, false);
+  assert.equal(saved.length, 0);
+});
+
 test("default recap delay is one minute and a current receipt renders only in the TUI widget", async () => {
   assert.equal(DEFAULT_RAREBIT_RECAP_DELAY_MS, 60_000);
   const clock = fakeClock();
@@ -147,7 +248,7 @@ test("default recap delay is one minute and a current receipt renders only in th
   await clock.advance(1);
   await Promise.resolve();
   await Promise.resolve();
-  assert.equal(reads, 1);
+  assert.equal(reads, 2, "the live projection is rechecked after renderer imports");
   assert.equal(widgets.length, 1);
   assert.equal(widgets[0][0], RAREBIT_RECAP_WIDGET_KEY);
   assert.match(widgetText(widgets[0][1]), /RECAP_SENTINEL/);
@@ -352,7 +453,7 @@ test("showExisting accepts current metadata-only branch drift and rejects change
       { sessionRoot, rarebitRoot },
     );
     assert.equal(rejected.shown, false);
-    assert.equal(rejected.reason, "no_current_summary");
+    assert.equal(rejected.reason, "materialization_pending");
     assert.equal(widgets.at(-1)[1], undefined);
   } finally {
     await rm(root, { recursive: true, force: true });
@@ -389,7 +490,11 @@ test("extension lifecycle materializes a real sidecar and arms the widget withou
   const handlers = new Map();
   const commands = new Map();
   const widgets = [];
+  const notices = [];
   let providerCalls = 0;
+  let releaseDelayedProvider;
+  let markProviderStarted;
+  const delayedProviderStarted = new Promise((resolve) => { markProviderStarted = resolve; });
   const pi = {
     on: (event, handler) => handlers.set(event, handler),
     registerCommand: (name, command) => commands.set(name, command),
@@ -414,6 +519,12 @@ test("extension lifecycle materializes a real sidecar and arms the widget withou
     modelClient: {
       complete: async () => {
         providerCalls += 1;
+        if (providerCalls === 3) {
+          markProviderStarted();
+          return new Promise((resolve) => { releaseDelayedProvider = () => resolve({
+            text: JSON.stringify({ summary: "Delayed synthetic assessment", sessionStatus: "finished", statusReason: "all_requests_accomplished" }),
+          }); });
+        }
         return {
           text: JSON.stringify({
             summary: "RECAP_SENTINEL: generated only for the sidecar",
@@ -438,7 +549,7 @@ test("extension lifecycle materializes a real sidecar and arms the widget withou
     isProjectTrusted: () => true,
     ui: {
       setWidget: (...args) => widgets.push(args),
-      notify() {},
+      notify: (text, level) => notices.push({ text, level }),
     },
     sessionManager: {
       getHeader: () => ({ id: "session-1" }),
@@ -469,6 +580,44 @@ test("extension lifecycle materializes a real sidecar and arms the widget withou
     assert.doesNotMatch(native, /RECAP_SENTINEL/);
     await commands.get("rarebit").handler("recap", ctx);
     assert.equal(providerCalls, 1, "displaying an existing recap must not synthesize");
+    await commands.get("rarebit").handler("summarize", ctx);
+    const manualDeadline = Date.now() + 2_000;
+    while (!notices.some((item) => /updated and current/.test(item.text))) {
+      if (Date.now() > manualDeadline) throw new Error("manual Summary result was not reported");
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+    assert.equal(providerCalls, 2);
+    await commands.get("rarebit").handler("summarize", ctx);
+    const duplicateDeadline = Date.now() + 2_000;
+    while (!notices.some((item) => /already current/.test(item.text))) {
+      if (Date.now() > duplicateDeadline) throw new Error("duplicate Summary result was not reported");
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+    assert.equal(providerCalls, 2);
+
+    branch.push({ type: "message", id: "owner-2", parentId: branch.at(-1).id,
+      timestamp: "2026-09-27T00:00:03.000Z", message: { role: "user", content: "Synthetic request for delayed currentness check" } });
+    await writeFile(sessionFile, `${[{ type: "session", version: 3, id: "session-1", cwd: root }, ...branch].map((entry) => JSON.stringify(entry)).join("\n")}\n`, { mode: 0o600 });
+    await commands.get("rarebit").handler("summarize", ctx);
+    await delayedProviderStarted;
+    const nextContext = {
+      ...ctx,
+      sessionId: "session-2",
+      sessionManager: {
+        getHeader: () => ({ id: "session-2" }),
+        getSessionFile: () => join(sessionRoot, "session-2.jsonl"),
+        getBranch: () => branchFor("session-2-assistant"),
+      },
+    };
+    handlers.get("session_start")({}, nextContext);
+    releaseDelayedProvider();
+    const staleDeadline = Date.now() + 2_000;
+    while (!notices.some((item) => /generated but is not current/.test(item.text))) {
+      if (Date.now() > staleDeadline) throw new Error("session-switched Summary result was not reported as non-current");
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+    assert.equal(notices.at(-1).level, "warning");
+    assert.equal(providerCalls, 3);
   } finally {
     handlers.get("session_shutdown")({}, ctx);
     await rm(root, { recursive: true, force: true });

package/test/rarebit-settings-ui.test.mjs

@@ -15,7 +15,8 @@ import {
   processRarebitSummary,
 } from "../src/rarebit-service.mjs";
 import { createRarebitRecapController } from "../src/rarebit-recap.mjs";
-import { selectRarebits } from "../src/rarebit-core.mjs";
+import { selectRarebits, sha256 } from "../src/rarebit-core.mjs";
+import { extractRarebitSynthesisReceipt } from "../src/rarebit-model.mjs";
 import registerPiRarebit, { readConfiguredRarebitSettings } from "../src/extension.mjs";
 import {
   RAREBIT_SETTINGS_TABS,
@@ -151,6 +152,20 @@ test("recap renders the human label and converts the receipt timestamp to the co
     { id: "a1", type: "message", message: { role: "assistant", content: [{ type: "text", text: "A response" }] } },
   ];
   const selection = selectRarebits(branch);
+  const observedAt = "2026-01-01T00:00:00.000Z";
+  const model = { provider: "fixture", id: "summary" };
+  const receipt = {
+    schemaVersion: 4, type: "rarebit_summary", status: "ok", jobId: sha256("job-1"), sessionId: "session-1",
+    branch: { leafId: "a1", entryCount: 2, pathHash: sha256(["u1", "a1"]) }, observedAt,
+    selection: { manifestHash: selection.manifestHash, selectorVersion: selection.manifest.selectorVersion,
+      occurrenceCount: selection.occurrences.length, uniquePayloadCount: selection.payloads.length, latestUserSourceEntryId: "u1" },
+    lifecycleBoundary: "agent_settled", implementationVersion: "hc-rarebit-summary-v7", synthesisMode: "forced",
+    inputCoveragePolicy: { strategy: "newest_suffix_with_explicit_omission", maxPromptChars: 10_000 },
+    promptVersion: "rarebit-summary-v8", model, modelProvenance: { source: "test", status: "resolved" },
+    summary: "A current summary.", sessionStatus: "needs_attention", statusReason: "approval",
+    inputCoverage: { totalMessageCount: selection.occurrences.length, includedMessageCount: selection.occurrences.length, omittedMessageCount: 0, omittedTextChars: 0, promptChars: 100, complete: true },
+    synthesis: extractRarebitSynthesisReceipt({}, { requestedModel: model, startedAt: observedAt, completedAt: observedAt, durationMs: 0 }),
+  };
   const widgets = [];
   const context = {
     mode: "tui",
@@ -165,31 +180,20 @@ test("recap renders the human label and converts the receipt timestamp to the co
   const controller = createRarebitRecapController({
     timezone: "Asia/Hong_Kong",
     readCurrent: async () => ({
-      receipt: {
-        status: "ok",
-        jobId: "job-1",
-        sessionId: "session-1",
-        observedAt: "2026-01-01T00:00:00.000Z",
-        sessionStatus: "needs_attention",
-        summary: "A current summary.",
-        selection: {
-          manifestHash: selection.manifestHash,
-          selectorVersion: selection.manifest.selectorVersion,
-        },
-      },
+      receipt,
       artifactState: {
         syncState: "assessment_current",
         applicability: "exact_selection",
-        receiptRef: { jobId: "job-1" },
+        receiptRef: { jobId: receipt.jobId },
         projection: { status: "needs_attention" },
       },
     }),
   });
   const result = await controller.showExisting(context);
   assert.equal(result.shown, true);
-  const heading = widgets[0]({ requestRender() {} }, { fg: (_name, text) => text }).render(200).find((line) => line.includes("Recap ·")).trim();
-  assert.match(heading, /^(?:◆! )?Recap · needs you · as of /);
-  assert.match(heading, /Asia\/Hong_Kong/);
+  const heading = widgets[0]({ requestRender() {} }, { fg: (_name, text) => text }).render(200).find((line) => line.includes("Recap·")).trim();
+  assert.match(heading, /^(?:◆!)?Recap·needsyou·01\/01 08:00\(GMT\+8\)/);
+  assert.doesNotMatch(heading, /as of|2026|Asia\/Hong_Kong/);
   assert.doesNotMatch(heading, /Rarebit Summary/);
 });
 
@@ -198,6 +202,7 @@ test("quiet Summary diagnostics still report materialization failures", async ()
   const handlers = new Map();
   const commands = new Map();
   const notices = [];
+  let providerCalls = 0;
   registerPiRarebit(
     {
       on: (event, handler) => handlers.set(event, handler),
@@ -209,7 +214,7 @@ test("quiet Summary diagnostics still report materialization failures", async ()
       sessionRoot: root,
       rarebitRoot: join(root, "rarebit"),
       queryAutomaticSummaryPolicy: async () => ({ decision: "abstain", queryStatus: "test" }),
-      modelClient: { complete: async () => ({ text: "not valid JSON" }) },
+      modelClient: { complete: async () => { providerCalls += 1; throw new Error("synthetic provider failure"); } },
       diagnostics: { summaryTriggered: false, summaryUpdated: false },
     },
   );
@@ -230,11 +235,18 @@ test("quiet Summary diagnostics still report materialization failures", async ()
     ui: { notify: (text, level) => notices.push({ text, level }) },
   };
   handlers.get("session_start")({}, context);
+  const waitForFailure = async (count) => {
+    const deadline = Date.now() + 2_000;
+    while (Date.now() < deadline && notices.filter(({ text, level }) => level === "error" && /Summary failed/.test(text)).length < count)
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.equal(notices.filter(({ text, level }) => level === "error" && /Summary failed/.test(text)).length, count);
+  };
+  await commands.get("rarebit").handler("summarize", context);
+  await waitForFailure(1);
   await commands.get("rarebit").handler("summarize", context);
-  const deadline = Date.now() + 2_000;
-  while (Date.now() < deadline && !notices.some(({ text }) => /Summary failed/.test(text)))
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  assert.ok(notices.some(({ text, level }) => level === "error" && /Summary failed/.test(text)));
+  await waitForFailure(2);
+  assert.equal(providerCalls, 1, "the cached failure reuses the original provider outcome");
+  assert.equal(notices.some(({ text }) => /already current|updated and current/.test(text)), false);
   assert.equal(notices.some(({ text }) => /Summary triggered/.test(text)), false);
 });
 

package/test/rarebit-sidecar-protocol.test.mjs

@@ -328,6 +328,26 @@ test("compact exact and owner-request prefix applicability re-derives native man
   };
   assert.equal(exactSelectionApplies(exact, current), true);
 });
+test("store promotes a newer manual assessment after an older settled receipt", async () => {
+  const f = await fixture();
+  const branch = [entry("u", "user", "Synthetic request"), entry("a", "assistant", "Synthetic completion")];
+  await writeFile(f.sessionFile, [JSON.stringify({ type: "session", id: "s" }), ...branch.map(JSON.stringify)].join("\n") + "\n");
+  const ctx = { sessionManager: { getHeader: () => ({ id: "s" }), getSessionFile: () => f.sessionFile, getBranch: () => branch } };
+  const config = {
+    sessionRoot: f.sessionRoot, rarebitRoot: f.rarebitRoot,
+    summaryPolicy: { minTotalLength: 0, maxRarebitRatio: 1 },
+    model: { provider: "test", id: "model" },
+    modelClient: { complete: async () => JSON.stringify({ summary: "Synthetic current assessment", sessionStatus: "finished", statusReason: "all_requests_accomplished" }) },
+  };
+  const settled = await processRarebitSummary(ctx, { ...config, lifecycleBoundary: "agent_settled" });
+  const manual = await processRarebitSummary(ctx, { ...config, lifecycleBoundary: "manual", forceSynthesis: true });
+  assert.notEqual(settled.record.jobId, manual.record.jobId);
+  const current = await readRarebitCurrent({ sessionFile: f.sessionFile, sessionRoot: f.sessionRoot, rarebitRoot: f.rarebitRoot });
+  assert.equal(current.artifactState.syncState, "assessment_current");
+  assert.equal(current.artifactState.receiptRef.jobId, manual.record.jobId);
+  assert.equal(current.receipt.lifecycleBoundary, "manual");
+});
+
 test("generated successful and terminal failure receipts satisfy runtime and JSON Schema closure", async () => {
   const f = await fixture();
   const success = await materialize(f, [entry("u", "user", "x")]);

package/test/rarebit-v020.test.mjs

@@ -12,8 +12,10 @@ import {
   normalizeRarebitSummaryPrompt,
   rarebitJobIdentity,
   selectRarebits,
+  sha256,
 } from "../src/rarebit-core.mjs";
 import { processRarebitSummary } from "../src/rarebit-service.mjs";
+import { extractRarebitSynthesisReceipt } from "../src/rarebit-model.mjs";
 import { resolveRarebitSettings } from "../src/rarebit-settings.mjs";
 import {
   RAREBIT_SETTINGS_FIELDS,
@@ -57,19 +59,22 @@ function recapContext(summary, setWidget) {
     entry("recap-a", { role: "assistant", stopReason: "stop", content: "The deployment is complete." }),
   ];
   const selection = selectRarebits(branch);
+  const observedAt = "2026-09-27T00:00:00.000Z";
+  const model = { provider: "fixture", id: "summary" };
   const receipt = {
-    type: "rarebit_summary",
-    status: "ok",
-    jobId: "recap-v020-job",
+    schemaVersion: 4, type: "rarebit_summary", status: "ok", jobId: sha256("recap-v020-job"),
     sessionId: "recap-v020-session",
-    branch: { leafId: "recap-a", pathHash: "recap-v020-path" },
-    selection: {
-      manifestHash: selection.manifestHash,
-      selectorVersion: selection.manifest.selectorVersion,
-    },
-    sessionStatus: "finished",
-    observedAt: "2026-09-27T00:00:00.000Z",
-    summary,
+    branch: { leafId: "recap-a", entryCount: branch.length, pathHash: sha256(branch.map((item) => item.id)) },
+    selection: { manifestHash: selection.manifestHash, selectorVersion: selection.manifest.selectorVersion,
+      occurrenceCount: selection.occurrences.length, uniquePayloadCount: selection.payloads.length,
+      latestUserSourceEntryId: "recap-u" },
+    sessionStatus: "finished", statusReason: "all_requests_accomplished", observedAt, summary,
+    lifecycleBoundary: "agent_settled", implementationVersion: "hc-rarebit-summary-v7", synthesisMode: "forced",
+    inputCoveragePolicy: { strategy: "newest_suffix_with_explicit_omission", maxPromptChars: 10_000 },
+    promptVersion: "rarebit-summary-v8", model, modelProvenance: { source: "test", status: "resolved" },
+    inputCoverage: { totalMessageCount: selection.occurrences.length, includedMessageCount: selection.occurrences.length,
+      omittedMessageCount: 0, omittedTextChars: 0, promptChars: 500, complete: true },
+    synthesis: extractRarebitSynthesisReceipt({}, { requestedModel: model, startedAt: observedAt, completedAt: observedAt, durationMs: 0 }),
   };
   return {
     ctx: {