@hypercarrier/rarebit 0.1.0-alpha.6 → 0.2.0

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

@@ -0,0 +1,388 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import {
+  DEFAULT_RAREBIT_MAX_INPUT_TOKENS,
+  DEFAULT_RAREBIT_RECAP_TIMEZONE,
+  normalizeRarebitRecapTimezone,
+  resolveRarebitSettings,
+} from "../src/rarebit-settings.mjs";
+import {
+  DEFAULT_RAREBIT_MAX_PROMPT_CHARS,
+  processRarebitSummary,
+} from "../src/rarebit-service.mjs";
+import { createRarebitRecapController } from "../src/rarebit-recap.mjs";
+import { selectRarebits } from "../src/rarebit-core.mjs";
+import registerPiRarebit, { readConfiguredRarebitSettings } from "../src/extension.mjs";
+import {
+  RAREBIT_SETTINGS_TABS,
+  openRarebitPalette,
+  openRarebitSettings,
+  readRarebitSettingsDocument,
+  saveRarebitSettingsDocument,
+} from "../src/rarebit-settings-ui.mjs";
+import { parseRarebitCommand } from "../src/rarebit-command.mjs";
+
+async function fixture(initial = {}) {
+  const root = await mkdtemp(join(tmpdir(), "rarebit-settings-ui-"));
+  const cwd = join(root, "project");
+  const agentDir = join(root, "agent");
+  const settingsFile = join(agentDir, "settings.json");
+  const projectSettings = join(cwd, ".pi", "settings.json");
+  await mkdir(agentDir, { recursive: true });
+  await mkdir(join(cwd, ".pi"), { recursive: true });
+  await writeFile(settingsFile, `${JSON.stringify(initial, null, 2)}\n`);
+  return { root, cwd, agentDir, settingsFile, projectSettings };
+}
+
+function theme() {
+  return {
+    bold: (value) => value,
+    fg: (_role, value) => value,
+  };
+}
+
+function context(box, ui, overrides = {}) {
+  return {
+    mode: "tui",
+    hasUI: true,
+    cwd: box.cwd,
+    isProjectTrusted: () => true,
+    ui,
+    ...overrides,
+  };
+}
+
+test("resolved settings keep diagnostics quiet by default and retain global values through project partial overrides", () => {
+  const resolved = resolveRarebitSettings(
+    {
+      rarebit: {
+        model: "fixture/summary",
+        diagnostics: { summary_triggered: true, summary_updated: false },
+        max_input_tokens: 64_000,
+        recap: { enabled: false, delay_ms: 10_000, timezone: "Asia/Hong_Kong" },
+      },
+    },
+    { rarebit: { recap: { delay_ms: 2_000 } } },
+  );
+
+  assert.equal(resolved.diagnostics.summaryTriggered, true);
+  assert.equal(resolved.diagnostics.summaryUpdated, false);
+  assert.equal(resolved.recap.enabled, false);
+  assert.equal(resolved.recap.delayMs, 2_000);
+  assert.equal(resolved.recap.timezone, "Asia/Hong_Kong");
+  assert.equal(resolved.maxInputTokens, DEFAULT_RAREBIT_MAX_INPUT_TOKENS);
+
+  const defaults = resolveRarebitSettings({ rarebit: { model: "fixture/summary" } });
+  assert.deepEqual(defaults.diagnostics, { summaryTriggered: false, summaryUpdated: false });
+  assert.equal(defaults.recap.timezone, DEFAULT_RAREBIT_RECAP_TIMEZONE);
+});
+
+test("the real settings loader preserves a global disabled Recap through a partial trusted-project override", async () => {
+  const box = await fixture({
+    rarebit: {
+      model: "fixture/summary",
+      diagnostics: { summary_triggered: false, summary_updated: false },
+      max_input_tokens: 64_000,
+      recap: { enabled: false, delay_ms: 60_000, timezone: "Asia/Hong_Kong" },
+    },
+  });
+  await writeFile(box.projectSettings, JSON.stringify({
+    other_extension: { preserve: true },
+    rarebit: { recap: { delay_ms: 2_000 } },
+  }, null, 2));
+
+  const effective = await readConfiguredRarebitSettings({
+    cwd: box.cwd,
+    agentDir: box.agentDir,
+    projectTrusted: true,
+    model: { provider: "fixture", id: "summary" },
+  });
+  assert.equal(effective.maxInputTokens, 64_000);
+  assert.deepEqual(effective.diagnostics, { summaryTriggered: false, summaryUpdated: false });
+  assert.equal(effective.recap.enabled, false);
+  assert.equal(effective.recap.delayMs, 2_000);
+  assert.equal(effective.recap.timezone, "Asia/Hong_Kong");
+
+  const projectDocument = await readRarebitSettingsDocument({
+    cwd: box.cwd,
+    agentDir: box.agentDir,
+    scope: "project",
+    projectTrusted: true,
+  });
+  await saveRarebitSettingsDocument(projectDocument, {
+    ...projectDocument.namespace,
+    recap: { ...projectDocument.namespace.recap, timezone: "UTC" },
+  });
+  const global = JSON.parse(await readFile(box.settingsFile, "utf8"));
+  const project = JSON.parse(await readFile(box.projectSettings, "utf8"));
+  assert.equal(global.rarebit.recap.enabled, false);
+  assert.equal(global.rarebit.recap.timezone, "Asia/Hong_Kong");
+  assert.deepEqual(project.other_extension, { preserve: true });
+  assert.equal(project.rarebit.recap.delay_ms, 2_000);
+  assert.equal(project.rarebit.recap.timezone, "UTC");
+});
+
+test("recap timezone accepts an IANA zone and falls back to host for invalid input", () => {
+  assert.equal(normalizeRarebitRecapTimezone("Asia/Hong_Kong"), "Asia/Hong_Kong");
+  assert.equal(normalizeRarebitRecapTimezone("not/a-timezone"), DEFAULT_RAREBIT_RECAP_TIMEZONE);
+  assert.equal(normalizeRarebitRecapTimezone(""), DEFAULT_RAREBIT_RECAP_TIMEZONE);
+});
+
+test("summary service maps the configurable input-token limit to the persisted character cap", async () => {
+  const branch = [
+    { id: "u1", type: "message", message: { role: "user", content: [{ type: "text", text: "A request" }] } },
+    { id: "a1", type: "message", message: { role: "assistant", content: [{ type: "text", text: "A response" }] } },
+  ];
+  const result = await processRarebitSummary(
+    { sessionManager: { getBranch: () => branch } },
+    { branch, maxInputTokens: 32_000, forceSynthesis: true },
+  );
+  assert.equal(result.record.inputCoveragePolicy.maxPromptChars, 128_000);
+  assert.equal(DEFAULT_RAREBIT_MAX_PROMPT_CHARS, DEFAULT_RAREBIT_MAX_INPUT_TOKENS * 4);
+});
+
+test("recap renders the human label and converts the receipt timestamp to the configured timezone", async () => {
+  const branch = [
+    { id: "u1", type: "message", message: { role: "user", content: [{ type: "text", text: "A request" }] } },
+    { id: "a1", type: "message", message: { role: "assistant", content: [{ type: "text", text: "A response" }] } },
+  ];
+  const selection = selectRarebits(branch);
+  const widgets = [];
+  const context = {
+    mode: "tui",
+    hasUI: true,
+    sessionManager: {
+      getHeader: () => ({ id: "session-1" }),
+      getSessionFile: () => "/tmp/rarebit-settings-ui-session.jsonl",
+      getBranch: () => branch,
+    },
+    ui: { setWidget: (_key, lines) => widgets.push(lines) },
+  };
+  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,
+        },
+      },
+      artifactState: {
+        syncState: "assessment_current",
+        applicability: "exact_selection",
+        receiptRef: { jobId: "job-1" },
+        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/);
+  assert.doesNotMatch(heading, /Rarebit Summary/);
+});
+
+test("quiet Summary diagnostics still report materialization failures", async () => {
+  const root = await mkdtemp(join(tmpdir(), "rarebit-settings-failure-"));
+  const handlers = new Map();
+  const commands = new Map();
+  const notices = [];
+  registerPiRarebit(
+    {
+      on: (event, handler) => handlers.set(event, handler),
+      registerCommand: (name, command) => commands.set(name, command),
+    },
+    {
+      model: { provider: "fixture", id: "summary" },
+      summaryPolicy: { minTotalLength: 0, maxRarebitRatio: 1 },
+      sessionRoot: root,
+      rarebitRoot: join(root, "rarebit"),
+      queryAutomaticSummaryPolicy: async () => ({ decision: "abstain", queryStatus: "test" }),
+      modelClient: { complete: async () => ({ text: "not valid JSON" }) },
+      diagnostics: { summaryTriggered: false, summaryUpdated: false },
+    },
+  );
+  const branch = [
+    { id: "u1", type: "message", message: { role: "user", content: [{ type: "text", text: "A request" }] } },
+    { id: "a1", type: "message", message: { role: "assistant", content: [{ type: "text", text: "A response" }] } },
+  ];
+  const context = {
+    mode: "tui",
+    cwd: root,
+    hasUI: true,
+    isProjectTrusted: () => true,
+    sessionManager: {
+      getHeader: () => ({ id: "session-failure" }),
+      getSessionFile: () => join(root, "session.jsonl"),
+      getBranch: () => branch,
+    },
+    ui: { notify: (text, level) => notices.push({ text, level }) },
+  };
+  handlers.get("session_start")({}, context);
+  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)));
+  assert.equal(notices.some(({ text }) => /Summary triggered/.test(text)), false);
+});
+
+test("settings document round-trip preserves Pi and other extension namespaces", async () => {
+  const box = await fixture({
+    theme: "dark",
+    another_extension: { enabled: true },
+    rarebit: {
+      model: "fixture/summary",
+      recap: { enabled: false, delay_ms: 60_000, timezone: "UTC" },
+      max_input_tokens: 64_000,
+    },
+  });
+  const document = await readRarebitSettingsDocument({ cwd: box.cwd, agentDir: box.agentDir, scope: "global" });
+  const saved = await saveRarebitSettingsDocument(document, {
+    ...document.namespace,
+    max_input_tokens: 32_000,
+    recap: { ...document.namespace.recap, timezone: "Asia/Hong_Kong" },
+  });
+  const parsed = JSON.parse(await readFile(box.settingsFile, "utf8"));
+  assert.equal(parsed.theme, "dark");
+  assert.deepEqual(parsed.another_extension, { enabled: true });
+  assert.equal(parsed.rarebit.max_input_tokens, 32_000);
+  assert.equal(parsed.rarebit.recap.timezone, "Asia/Hong_Kong");
+  assert.notEqual(saved.revision, document.revision);
+});
+
+test("settings cancel and invalid input leave the file unchanged and do not enter the Session", async () => {
+  const box = await fixture({
+    unrelated: { keep: "yes" },
+    rarebit: { model: "fixture/summary", max_input_tokens: 64_000 },
+  });
+  const before = await readFile(box.settingsFile, "utf8");
+  let customCalls = 0;
+  let modelCalls = 0;
+  let sessionWrites = 0;
+  const notifications = [];
+  const ui = {
+    custom: async (factory) => {
+      customCalls += 1;
+      if (customCalls > 2) return undefined;
+      let selected;
+      const component = factory({ requestRender() {} }, theme(), {}, (value) => { selected = value; });
+      assert.match(component.render(120).join("\n"), /Actions.*Summary.*Recap.*Session/);
+      if (customCalls === 1) {
+        component.handleInput("\t");
+        component.handleInput("\x1b[B");
+        component.handleInput("\x1b[B");
+        component.handleInput("\r");
+        return selected;
+      }
+      return undefined;
+    },
+    input: async () => "not/a-timezone",
+    select: async () => undefined,
+    confirm: async () => false,
+    notify: (message, level) => notifications.push({ message, level }),
+  };
+  await openRarebitSettings(context(box, ui, {
+    sendUserMessage: () => { modelCalls += 1; },
+    sessionManager: { appendMessage: () => { sessionWrites += 1; } },
+  }), { agentDir: box.agentDir, initialScope: "global" });
+  assert.equal(await readFile(box.settingsFile, "utf8"), before);
+  assert.equal(modelCalls, 0);
+  assert.equal(sessionWrites, 0);
+  assert.equal(notifications.length, 1);
+  assert.equal(notifications[0].level, "error");
+});
+
+test("settings confirmation cancel leaves the source file unchanged", async () => {
+  const box = await fixture({ rarebit: { model: "fixture/summary" } });
+  const before = await readFile(box.settingsFile, "utf8");
+  let customCalls = 0;
+  const ui = {
+    custom: async (factory) => {
+      customCalls += 1;
+      if (customCalls > 2) return undefined;
+      let selected;
+      const component = factory({ requestRender() {} }, theme(), {}, (value) => { selected = value; });
+      if (customCalls === 1) component.handleInput("\r");
+      return selected;
+    },
+    select: async () => "on",
+    confirm: async () => false,
+    notify: () => {},
+  };
+  await openRarebitSettings(context(box, ui), { agentDir: box.agentDir });
+  assert.equal(await readFile(box.settingsFile, "utf8"), before);
+});
+
+test("settings UI exposes the tabbed Summary and Recap controls and saves a confirmed edit", async () => {
+  const box = await fixture({ rarebit: { model: "fixture/summary" } });
+  const rendered = [];
+  let customCalls = 0;
+  const ui = {
+    custom: async (factory) => {
+      customCalls += 1;
+      if (customCalls > 2) return undefined;
+      let selected;
+      const component = factory({ requestRender() {} }, theme(), {}, (value) => { selected = value; });
+      rendered.push(component.render(120).join("\n"));
+      if (customCalls === 1) {
+        component.handleInput("\r");
+      }
+      return selected;
+    },
+    select: async () => "on",
+    confirm: async () => true,
+    notify: () => {},
+  };
+  await openRarebitSettings(context(box, ui), { agentDir: box.agentDir });
+  assert.deepEqual(RAREBIT_SETTINGS_TABS, ["Actions", "Summary", "Recap", "Session"]);
+  assert.match(rendered[0], /Rarebit Settings/);
+  assert.match(rendered[0], /Show Summary triggered/);
+  const parsed = JSON.parse(await readFile(box.settingsFile, "utf8"));
+  assert.equal(parsed.rarebit?.diagnostics?.summary_triggered, true);
+});
+
+test("the Rarebit palette is a human-only TUI surface and includes settings and Recap", async () => {
+  const box = await fixture({});
+  let modelCalls = 0;
+  let sessionWrites = 0;
+  let rendered = "";
+  const ui = {
+    custom: async (factory) => {
+      let selected;
+      const component = factory({ requestRender() {} }, theme(), {}, (value) => { selected = value; });
+      rendered = component.render(120).join("\n");
+      component.handleInput("\x1b");
+      return selected;
+    },
+    notify: () => {},
+  };
+  const selection = await openRarebitPalette(context(box, ui, {
+    sendUserMessage: () => { modelCalls += 1; },
+    sessionManager: { appendMessage: () => { sessionWrites += 1; } },
+  }));
+  assert.equal(selection, undefined);
+  assert.match(rendered, /Rarebit/);
+  assert.match(rendered, /Summary/);
+  assert.match(rendered, /Recap/);
+  assert.match(rendered, /Settings/);
+  assert.equal(modelCalls, 0);
+  assert.equal(sessionWrites, 0);
+});
+
+test("/rarebit keeps menu and settings under one command surface", () => {
+  assert.deepEqual(parseRarebitCommand(""), { ok: true, subcommand: "menu", arguments: [] });
+  assert.deepEqual(parseRarebitCommand("settings"), { ok: true, subcommand: "settings", arguments: [] });
+  assert.deepEqual(parseRarebitCommand("settings project"), { ok: true, subcommand: "settings", arguments: ["project"] });
+});

package/test/rarebit-v020.test.mjs

@@ -0,0 +1,294 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import {
+  DEFAULT_RAREBIT_SUMMARY_PROMPT_GUIDANCE,
+  RAREBIT_SUMMARY_PROMPT_VERSION,
+  composeRarebitSummaryDerivationInput,
+  composeRarebitSummaryPrompt,
+  normalizeRarebitSummaryPrompt,
+  rarebitJobIdentity,
+  selectRarebits,
+} from "../src/rarebit-core.mjs";
+import { processRarebitSummary } from "../src/rarebit-service.mjs";
+import { resolveRarebitSettings } from "../src/rarebit-settings.mjs";
+import {
+  RAREBIT_SETTINGS_FIELDS,
+  readRarebitSettingsDocument,
+  saveRarebitSettingsDocument,
+} from "../src/rarebit-settings-ui.mjs";
+import {
+  createRarebitRecapController,
+  RAREBIT_RECAP_WIDGET_KEY,
+} from "../src/rarebit-recap.mjs";
+
+const entry = (id, message) => ({
+  type: "message",
+  id,
+  timestamp: "2026-09-27T00:00:00.000Z",
+  message,
+});
+
+function branch() {
+  return [
+    entry("u1", { role: "user", content: "Investigate the deployment issue." }),
+    entry("a1", { role: "assistant", stopReason: "stop", content: "I found the failing check." }),
+  ];
+}
+
+async function fixture() {
+  const root = await mkdtemp(join(tmpdir(), "rarebit-v020-prompt-"));
+  await mkdir(join(root, "agent"), { recursive: true });
+  await writeFile(join(root, "agent", "settings.json"), "{}\n");
+  const sessionRoot = join(root, "sessions");
+  const rarebitRoot = join(root, "rarebit");
+  await mkdir(sessionRoot, { recursive: true });
+  const sessionFile = join(sessionRoot, "trace.jsonl");
+  await writeFile(sessionFile, '{"type":"session","id":"prompt-contract"}\n');
+  return { root, sessionRoot, rarebitRoot, sessionFile };
+}
+
+function recapContext(summary, setWidget) {
+  const branch = [
+    entry("recap-u", { role: "user", content: "Read the current deployment state." }),
+    entry("recap-a", { role: "assistant", stopReason: "stop", content: "The deployment is complete." }),
+  ];
+  const selection = selectRarebits(branch);
+  const receipt = {
+    type: "rarebit_summary",
+    status: "ok",
+    jobId: "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,
+  };
+  return {
+    ctx: {
+      mode: "tui",
+      hasUI: true,
+      ui: { setWidget },
+      sessionManager: {
+        getHeader: () => ({ id: receipt.sessionId }),
+        getSessionFile: () => "/tmp/rarebit-v020-recap-session.jsonl",
+        getBranch: () => branch,
+      },
+    },
+    current: {
+      receipt,
+      artifactState: {
+        syncState: "assessment_current",
+        applicability: "exact_selection",
+        receiptRef: { jobId: receipt.jobId },
+        projection: { status: receipt.sessionStatus },
+      },
+    },
+  };
+}
+
+test("the default summary prompt keeps the current style and has no custom identity", () => {
+  const selection = selectRarebits(branch());
+  const normalized = normalizeRarebitSummaryPrompt();
+  const derivation = composeRarebitSummaryDerivationInput(selection);
+
+  assert.equal(normalized.guidance, DEFAULT_RAREBIT_SUMMARY_PROMPT_GUIDANCE);
+  assert.equal(normalized.promptIdentity, null);
+  assert.equal(derivation.promptIdentity, null);
+  assert.match(derivation.prompt, new RegExp(DEFAULT_RAREBIT_SUMMARY_PROMPT_GUIDANCE));
+  assert.equal(derivation.prompt, composeRarebitSummaryPrompt(selection));
+});
+
+test("a custom summary_prompt changes prose and job identity", () => {
+  const selection = selectRarebits(branch());
+  const summaryPrompt = "Use short factual bullets and state uncertainty.";
+  const normalized = normalizeRarebitSummaryPrompt(summaryPrompt);
+  const custom = composeRarebitSummaryDerivationInput(selection, { summaryPrompt });
+  const defaultIdentity = rarebitJobIdentity({
+    operation: "summary",
+    sessionId: "prompt-contract",
+    branch: { leafId: "a1", entryCount: 2, pathHash: "path" },
+    selection,
+    promptVersion: RAREBIT_SUMMARY_PROMPT_VERSION,
+    promptIdentity: null,
+  });
+  const customIdentity = rarebitJobIdentity({
+    operation: "summary",
+    sessionId: "prompt-contract",
+    branch: { leafId: "a1", entryCount: 2, pathHash: "path" },
+    selection,
+    promptVersion: RAREBIT_SUMMARY_PROMPT_VERSION,
+    promptIdentity: custom.promptIdentity,
+  });
+
+  assert.equal(normalized.promptIdentity, custom.promptIdentity);
+  assert.ok(custom.promptIdentity);
+  assert.match(custom.prompt, /Use short factual bullets and state uncertainty/);
+  assert.notEqual(custom.prompt, composeRarebitSummaryPrompt(selection));
+  assert.notEqual(customIdentity, defaultIdentity);
+});
+
+test("summary_prompt accepts only a nonblank scalar string", () => {
+  assert.throws(() => normalizeRarebitSummaryPrompt({ guidance: "custom" }), /summary_prompt/);
+  assert.throws(() => normalizeRarebitSummaryPrompt("   "), /summary_prompt/);
+  assert.throws(() => normalizeRarebitSummaryPrompt(42), /summary_prompt/);
+});
+
+test("settings resolve and round-trip the scalar summary_prompt without changing other namespaces", async () => {
+  const f = await fixture();
+  await writeFile(f.root + "/agent/settings.json", JSON.stringify({
+    theme: "dark",
+    other_extension: { keep: true },
+    rarebit: { model: "fixture/summary", summary_prompt: "Use an incident timeline." },
+  }, null, 2));
+  const resolved = resolveRarebitSettings({
+    rarebit: { model: "fixture/summary", summary_prompt: "Use an incident timeline." },
+  });
+  assert.equal(resolved.summaryPrompt, "Use an incident timeline.");
+  assert.equal(
+    RAREBIT_SETTINGS_FIELDS.some((field) => field.path?.join(".") === "summary_prompt"),
+    true,
+  );
+
+  const document = await readRarebitSettingsDocument({ agentDir: f.root + "/agent" });
+  await saveRarebitSettingsDocument(document, {
+    ...document.namespace,
+    summary_prompt: "Use an incident timeline with explicit uncertainty.",
+  });
+  const saved = JSON.parse(await readFile(f.root + "/agent/settings.json", "utf8"));
+  assert.equal(saved.theme, "dark");
+  assert.deepEqual(saved.other_extension, { keep: true });
+  assert.equal(saved.rarebit.summary_prompt, "Use an incident timeline with explicit uncertainty.");
+});
+
+test("invalid summary_prompt input fails before the provider or durable receipt", async () => {
+  const f = await fixture();
+  const calls = [];
+  const ctx = {
+    sessionManager: {
+      getHeader: () => ({ id: "prompt-contract" }),
+      getSessionFile: () => f.sessionFile,
+      getBranch: branch,
+    },
+  };
+
+  await assert.rejects(
+    processRarebitSummary(ctx, {
+      sessionRoot: f.sessionRoot,
+      rarebitRoot: f.rarebitRoot,
+      forceSynthesis: true,
+      model: { provider: "fixture", id: "summary" },
+      summaryPrompt: { guidance: "   " },
+      modelClient: { complete: async (request) => { calls.push(request); return "{}"; } },
+    }),
+    /summary_prompt/,
+  );
+  assert.equal(calls.length, 0);
+});
+
+test("custom summary_prompt reaches the provider and prevents reuse of the default receipt", async () => {
+  const f = await fixture();
+  const requests = [];
+  const ctx = {
+    sessionManager: {
+      getHeader: () => ({ id: "prompt-contract" }),
+      getSessionFile: () => f.sessionFile,
+      getBranch: branch,
+    },
+  };
+  const common = {
+    sessionRoot: f.sessionRoot,
+    rarebitRoot: f.rarebitRoot,
+    forceSynthesis: true,
+    model: { provider: "fixture", id: "summary" },
+    modelClient: {
+      complete: async (request) => {
+        requests.push(request);
+        return {
+          text: JSON.stringify({
+            summary: "The deployment issue is recorded.",
+            sessionStatus: "finished",
+            statusReason: "all_requests_accomplished",
+          }),
+        };
+      },
+    },
+  };
+  const first = await processRarebitSummary(ctx, common);
+  const second = await processRarebitSummary(ctx, {
+    ...common,
+    summaryPrompt: "Use a terse incident report with explicit uncertainty.",
+  });
+
+  assert.equal(first.record.status, "ok");
+  assert.equal(second.record.status, "ok");
+  assert.equal(requests.length, 2);
+  assert.doesNotMatch(requests[0].prompt, /terse incident report/);
+  assert.match(requests[1].prompt, /terse incident report/);
+  assert.notEqual(first.record.jobId, second.record.jobId);
+});
+
+test("Recap renders the full multiline Summary through a themed human-only widget", async () => {
+  const summary = Array.from({ length: 24 }, (_, index) => `line-${index + 1} FULL_RECAP_TAIL_${index + 1}`).join("\n");
+  const widgets = [];
+  const { ctx, current } = recapContext(summary, (...args) => widgets.push(args));
+  let modelCalls = 0;
+  let sessionWrites = 0;
+  const controller = createRarebitRecapController({
+    readCurrent: async () => current,
+  });
+
+  const shown = await controller.showExisting({
+    ...ctx,
+    modelClient: { complete: async () => { modelCalls += 1; } },
+    sessionManager: {
+      ...ctx.sessionManager,
+      appendMessage: () => { sessionWrites += 1; },
+    },
+  });
+  assert.equal(shown.shown, true);
+  assert.equal(widgets[0][0], RAREBIT_RECAP_WIDGET_KEY);
+  assert.equal(typeof widgets[0][1], "function");
+
+  const themed = widgets[0][1]({}, {
+    bold: (value) => value,
+    fg: (tone, value) => `[${tone}]${value}`,
+  });
+  const rendered = themed.render(200).join("\n");
+  assert.match(rendered, /Recap/);
+  assert.match(rendered, /line-1 FULL_RECAP_TAIL_1/);
+  assert.match(rendered, /line-24 FULL_RECAP_TAIL_24/);
+  assert.doesNotMatch(rendered, /recap expand/i);
+  assert.match(rendered, /\[muted\]|\[dim\]/);
+  assert.equal(modelCalls, 0);
+  assert.equal(sessionWrites, 0);
+
+  const refreshed = widgets[0][1]({}, {
+    bold: (value) => value,
+    fg: (tone, value) => `{${tone}}${value}`,
+  });
+  assert.match(refreshed.render(200).join("\n"), /\{muted\}|\{dim\}/);
+});
+
+test("Recap drops an async display when the Session changes before the widget factory resolves", async () => {
+  const widgets = [];
+  const first = recapContext("first Summary", (...args) => widgets.push(args));
+  const second = recapContext("second Summary", (...args) => widgets.push(args));
+  let releaseRead;
+  const readCurrent = new Promise((resolve) => { releaseRead = resolve; });
+  const controller = createRarebitRecapController({ readCurrent: async () => readCurrent });
+  const pending = controller.showExisting(first.ctx);
+  controller.invalidate(second.ctx, 2);
+  releaseRead(first.current);
+  const result = await pending;
+  assert.equal(result.shown, false);
+  assert.equal(result.reason, "stale");
+  assert.equal(widgets.some((call) => call[0] === RAREBIT_RECAP_WIDGET_KEY && call[1]), false);
+});

package/test/summary-attention-independent.test.mjs

@@ -108,7 +108,7 @@ test("v4 synthesis validates legal status/reason combinations without rigid sect
       }),
     ),
     {
-      summary: "Any free-form prose with controls removed",
+      summary: "Any free-form prose\nwith controls removed",
       sessionStatus: "needs_attention",
       statusReason: "unfinished",
     },