@hypercarrier/rarebit 0.1.0-alpha.5 → 0.2.0

package/src/types.d.ts

@@ -1,5 +1,77 @@
 export type RarebitModel = { provider: string; id: string };
 
+export type RarebitDiagnosticsSettings = {
+  summaryTriggered: boolean;
+  summaryUpdated: boolean;
+};
+export type RarebitRecapSettings = {
+  enabled: boolean;
+  delayMs: number;
+  timezone: string;
+};
+export type RarebitResolvedSettings = {
+  model?: RarebitModel;
+  modelConfigurationError?: string;
+  summaryPolicy: RarebitSummaryPolicy;
+  autoTitle: boolean;
+  summaryPrompt?: unknown;
+  maxInputTokens: number;
+  diagnostics: RarebitDiagnosticsSettings;
+  recap: RarebitRecapSettings;
+};
+export const DEFAULT_RAREBIT_RECAP_DELAY_MS: 60000;
+export const DEFAULT_RAREBIT_RECAP_TIMEZONE: "host";
+export const DEFAULT_RAREBIT_MAX_INPUT_TOKENS: 64000;
+export const MAX_RAREBIT_INPUT_TOKENS: number;
+export const DEFAULT_RAREBIT_DIAGNOSTICS: Readonly<RarebitDiagnosticsSettings>;
+export const RAREBIT_SUMMARY_PROMPT_IDENTITY_VERSION: "rarebit-summary-prompt-v1";
+export const MAX_RAREBIT_SUMMARY_PROMPT_CHARS: 64000;
+export const DEFAULT_RAREBIT_SUMMARY_PROMPT_GUIDANCE: string;
+export const MAX_RAREBIT_SUMMARY_CHARS: 8000;
+export function normalizeRarebitSummaryPrompt(value?: unknown): {
+  guidance: string;
+  promptIdentity: string | null;
+};
+export function mergeRarebitSettings(
+  globalSettings?: Record<string, unknown>,
+  projectSettings?: Record<string, unknown>,
+): Record<string, unknown>;
+export function normalizeRarebitRecapTimezone(value?: unknown): string;
+export function resolveRarebitSettings(
+  globalSettings?: Record<string, unknown>,
+  projectSettings?: Record<string, unknown>,
+): RarebitResolvedSettings;
+
+/** Seeded destination entries, including the generated fork notice. */
+export function getImportedRarebitEntryIds(entries: readonly unknown[]): Set<string>;
+export const RAREBIT_FORK_LINEAGE_SCHEMA_VERSION: 1;
+export const RAREBIT_FORK_ENTRY_MARKER_VERSION: "rarebit-fork-entry/1";
+export const RAREBIT_FORK_LINEAGE_CUSTOM_TYPE: "rarebit-fork-lineage";
+export const RAREBIT_FORK_OPENING_MARKER: "rarebit-fork-opening-v1";
+export const RAREBIT_FORK_DEFAULT_MAX_TOKEN_LENGTH: 64000;
+export const RAREBIT_FORK_DEFAULT_RESERVE_TOKENS: 16384;
+export type RarebitForkHeadroom = {
+  seedTokens: number;
+  overheadTokens: number;
+  requiredTokens: number;
+  contextWindow: number | null;
+  reserveTokens: number;
+  availableTokens: number | null;
+  basis: string;
+};
+/** A null context window yields an estimate without admission. Runtime adapters must require a known window before creating a Session. */
+export function checkRarebitForkHeadroom(options: {
+  seedText: string;
+  targetModel?: RarebitModel | null;
+  contextWindow?: number | null;
+  reserveTokens?: number;
+  promptOverheadTokens?: number;
+  toolOverheadTokens?: number;
+  messageRoundingOverheadTokens?: number;
+}): RarebitForkHeadroom;
+export function getRarebitForkSeedEntryIds(entries: readonly unknown[]): Set<string>;
+export function getRarebitForkLineageRecords(entries: readonly unknown[]): readonly Record<string, unknown>[];
+
 export type RarebitAutomaticSummaryPolicyDecision =
   | {
       contractVersion: "rarebit-automatic-summary-policy/1";
@@ -119,6 +191,7 @@ export function projectRarebitSessionActivity(selection: {
   occurrences?: RarebitOccurrence[];
   manifest?: { selectorVersion?: string };
   manifestHash?: string;
+  entries?: readonly unknown[];
 }): RarebitSessionActivity;
 
 export type RarebitVisualTone =
@@ -196,14 +269,20 @@ export function composeRarebitSummaryDerivationInput(
   selection: ReturnType<typeof selectRarebits>,
   options?: {
     promptVersion?: string;
+    summaryPrompt?: unknown;
     lifecycleBoundary?: "owner_request" | "agent_settled" | "manual";
     maxPromptChars?: number;
-  },
-): { prompt: string; coverage: RarebitSummaryInputCoverage };
+  }): {
+  prompt: string;
+  promptIdentity: string | null;
+  promptVersion: string;
+  coverage: RarebitSummaryInputCoverage;
+};
 export function composeRarebitSummaryPrompt(
   selection: ReturnType<typeof selectRarebits>,
   options?: {
     promptVersion?: string;
+    summaryPrompt?: unknown;
     lifecycleBoundary?: "owner_request" | "agent_settled" | "manual";
     maxPromptChars?: number;
   },
@@ -211,7 +290,10 @@ export function composeRarebitSummaryPrompt(
 export function composeRarebitTitlePrompt(
   selection: ReturnType<typeof selectRarebits>,
 ): string;
-export function normalizeRarebitSummary(value: unknown): string;
+export function normalizeRarebitSummary(
+  value: unknown,
+  options?: { maxChars?: number },
+): string;
 export function normalizeRarebitSummarySynthesis(
   value: unknown,
   options?: { maxChars?: number },
@@ -364,11 +446,17 @@ export type RarebitNativeObservation =
 
 export const RAREBIT_SUMMARY_SCHEMA_VERSION: 4;
 export const RAREBIT_SUMMARY_IMPLEMENTATION_VERSION: "hc-rarebit-summary-v6";
+export const RAREBIT_INPUT_CHARS_PER_TOKEN: 4;
+export const DEFAULT_RAREBIT_MAX_PROMPT_CHARS: 256000;
 export function processRarebitSummary(
   ctx: unknown,
   config?: {
     model?: RarebitModel;
     summaryPolicy?: RarebitSummaryPolicy;
+    summaryPrompt?: unknown;
+    maxInputTokens?: number;
+    maxPromptChars?: number;
+    diagnostics?: RarebitDiagnosticsSettings;
     forceSynthesis?: boolean;
     // New derivation accepts only evidence-transition or explicit boundaries;
     // RarebitSummaryReceiptV4 retains session_start for historical reads.

package/test/lifecycle-contract-independent.test.mjs

@@ -532,6 +532,7 @@ test("TUI notices state input cardinality, clearly estimated trigger tokens, and
       rarebitRoot: join(root, "rarebit"),
       summaryPolicy: { minTotalLength: 0, maxRarebitRatio: 1 },
       model: { provider: "test-provider", id: "cheap-model" },
+      diagnostics: { summaryTriggered: true, summaryUpdated: true },
       modelClient: {
         complete: async () => ({
           text: JSON.stringify({
@@ -588,6 +589,7 @@ test("updated notice never substitutes the local estimate for absent provider us
       rarebitRoot: join(root, "rarebit"),
       summaryPolicy: { minTotalLength: 0, maxRarebitRatio: 1 },
       model: { provider: "requested-provider", id: "requested-model" },
+      diagnostics: { summaryTriggered: true, summaryUpdated: true },
       modelClient: {
         complete: async () => ({
           text: JSON.stringify({

package/test/package-artifact-identity.test.mjs

@@ -0,0 +1,54 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const verifier = join(root, "scripts/verify-package.mjs");
+
+function syntheticTarball(field, value) {
+  const work = mkdtempSync(join(tmpdir(), "rarebit-artifact-test-"));
+  const packageDir = join(work, "package");
+  execFileSync("mkdir", ["-p", packageDir]);
+  const packageJson = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  packageJson[field] = value;
+  writeFileSync(join(packageDir, "package.json"), `${JSON.stringify(packageJson)}\n`);
+  const tarball = join(work, `${field}.tgz`);
+  execFileSync("tar", ["-czf", tarball, "-C", work, "package"]);
+  return { work, tarball };
+}
+
+function runVerifier(tarball) {
+  return spawnSync(process.execPath, [verifier], {
+    cwd: root,
+    env: { ...process.env, RELEASE_TARBALL: tarball },
+    encoding: "utf8",
+  });
+}
+
+test("rejects packed name and version changes against selected source", () => {
+  for (const [field, value] of [["name", "invalid-name"], ["version", "0.0.0-invalid-test"]]) {
+    const fixture = syntheticTarball(field, value);
+    try {
+      const result = runVerifier(fixture.tarball);
+      assert.notEqual(result.status, 0, `${field} mutation was accepted`);
+      assert.match(`${result.stdout}\n${result.stderr}`, /packed package (name|version) differs from selected source/);
+    } finally {
+      rmSync(fixture.work, { recursive: true, force: true });
+    }
+  }
+});
+
+test("accepts the normal packed artifact", () => {
+  const filename = JSON.parse(execFileSync("npm", ["pack", "--json", "--ignore-scripts"], { cwd: root, encoding: "utf8" }))[0].filename;
+  const tarball = join(root, filename);
+  try {
+    const result = runVerifier(tarball);
+    assert.equal(result.status, 0, result.stderr);
+  } finally {
+    rmSync(tarball, { force: true });
+  }
+});

package/test/piq.test.mjs

@@ -0,0 +1,212 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile, writeFile, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { readPiSession } from "../src/pi-session.mjs";
+import {
+  queryPiQ,
+  queryPiSessionBranches,
+} from "../src/piq.mjs";
+import { parsePiQCliArgs } from "../src/piq-cli.mjs";
+
+const records = [
+  {
+    type: "session",
+    version: 3,
+    id: "piq-fixture",
+    timestamp: "2026-09-21T00:00:00.000Z",
+    cwd: "/private/project",
+    unknownHeader: { retained: true },
+  },
+  {
+    type: "message",
+    id: "root",
+    parentId: null,
+    timestamp: "2026-09-21T00:00:01.000Z",
+    message: { role: "user", content: "root" },
+    unknownEntryField: "kept",
+    _piq: { source: "native" },
+  },
+  {
+    type: "message",
+    id: "tool-call",
+    parentId: "root",
+    timestamp: "2026-09-21T00:00:02.000Z",
+    message: {
+      role: "assistant",
+      content: [
+        "unknown-content-block",
+        { type: "text", text: "calling" },
+        { type: "toolCall", id: "call-1", name: "search", arguments: { q: "x" } },
+      ],
+    },
+  },
+  {
+    type: "compaction",
+    id: "compact",
+    parentId: "tool-call",
+    timestamp: "2026-09-21T00:00:03.000Z",
+    firstKeptEntryId: "tool-call",
+    summary: "older context",
+    futureField: { retained: "raw" },
+  },
+  {
+    type: "message",
+    id: "tool-result",
+    parentId: "compact",
+    timestamp: "2026-09-21T00:00:04.000Z",
+    message: {
+      role: "toolResult",
+      toolCallId: "call-1",
+      content: [{ type: "text", text: "result" }],
+    },
+  },
+  {
+    type: "message",
+    id: "active",
+    parentId: "tool-result",
+    timestamp: "2026-09-21T00:00:05.000Z",
+    message: { role: "assistant", stopReason: "stop", content: "done" },
+  },
+  {
+    type: "message",
+    id: "sibling",
+    parentId: "root",
+    timestamp: "2026-09-21T00:00:06.000Z",
+    message: { role: "user", content: "sibling" },
+  },
+];
+
+async function fixture(testContext) {
+  const root = await mkdtemp(join(tmpdir(), "piq-"));
+  testContext.after(() => rm(root, { recursive: true, force: true }));
+  const file = join(root, "session.jsonl");
+  const source = records.map(JSON.stringify).join("\n") + "\n";
+  await writeFile(file, source);
+  return { file, root, source };
+}
+
+test("generic reader resolves the default and explicit branches without timestamps", async (t) => {
+  const { file } = await fixture(t);
+  const loaded = await readPiSession(file);
+  assert.deepEqual(loaded.branch.map((entry) => entry.id), ["root", "sibling"]);
+  const active = await readPiSession(file, { leafId: "active" });
+  assert.deepEqual(active.branch.map((entry) => entry.id), [
+    "root",
+    "tool-call",
+    "compact",
+    "tool-result",
+    "active",
+  ]);
+  const branches = queryPiSessionBranches(active);
+  assert.deepEqual(
+    branches.map((branch) => branch.leafId),
+    ["active", "sibling"],
+  );
+});
+
+test("PiQ preserves raw fields and filters evidence", async (t) => {
+  const { file, source } = await fixture(t);
+  const entries = await queryPiQ(file, { kind: "entries", leafId: "active" });
+  assert.equal(entries[0].entry.unknownEntryField, "kept");
+  assert.equal(entries[0].entry._piq.source, "native");
+  assert.equal(entries[1]._piq.branchLeafId, "active");
+  const roles = await queryPiQ(file, { kind: "entries", leafId: "active", role: "toolResult" });
+  assert.deepEqual(roles.map((record) => record.entry.id), ["tool-result"]);
+  const tools = await queryPiQ(file, { kind: "tools", leafId: "active" });
+  assert.deepEqual(tools.map((record) => record._piq.kind), ["tool-call", "tool-result"]);
+  assert.equal(tools[0]._piq.blockIndex, 2);
+  const boundaries = await queryPiQ(file, { kind: "compactions", leafId: "active" });
+  assert.equal(boundaries[0].entry.futureField.retained, "raw");
+  const filteredBoundary = await queryPiQ(file, {
+    kind: "compactions",
+    leafId: "active",
+    entryId: "compact",
+    from: "2026-09-21T00:00:03.000Z",
+    to: "2026-09-21T00:00:03.000Z",
+  });
+  assert.equal(filteredBoundary.length, 1);
+  const prior = await queryPiQ(file, {
+    kind: "entries",
+    leafId: "active",
+    throughCompaction: "compact",
+  });
+  assert.deepEqual(prior.map((record) => record.entry.id), ["root", "tool-call", "compact"]);
+  const dated = await queryPiQ(file, {
+    kind: "entries",
+    leafId: "active",
+    from: "2026-09-21T00:00:04.000Z",
+  });
+  assert.deepEqual(dated.map((record) => record.entry.id), ["tool-result", "active"]);
+  const epochRange = await queryPiQ(file, {
+    kind: "entries",
+    leafId: "active",
+    from: "1970-01-01T00:00:00.000Z",
+    to: "1970-01-01T00:00:00.000Z",
+  });
+  assert.deepEqual(epochRange, []);
+  assert.equal(await readFile(file, "utf8"), source);
+});
+
+test("PiQ CLI emits JSONL and rejects malformed or ambiguous branch choices", async (t) => {
+  const { file, root } = await fixture(t);
+  const parsed = parsePiQCliArgs([
+    "entries",
+    "--session",
+    file,
+    "--leaf",
+    "sibling",
+    "--role",
+    "user",
+  ]);
+  assert.equal(parsed.leafId, "sibling");
+  const cli = new URL("../bin/piq.mjs", import.meta.url);
+  const output = spawnSync(
+    process.execPath,
+    [cli.pathname, "entries", "--session", file, "--leaf", "sibling"],
+    { encoding: "utf8" },
+  );
+  assert.equal(output.status, 0, output.stderr);
+  assert.deepEqual(
+    output.stdout.trim().split("\n").map((line) => JSON.parse(line).entry.id),
+    ["root", "sibling"],
+  );
+  const unsupported = spawnSync(
+    process.execPath,
+    [cli.pathname, "branches", "--session", file, "--role", "user"],
+    { encoding: "utf8" },
+  );
+  assert.notEqual(unsupported.status, 0);
+  assert.match(unsupported.stderr, /Branch listing does not support filters/);
+  await assert.rejects(
+    queryPiQ(file, { kind: "entries", leafId: "missing" }),
+    /no Session entry with leaf ID missing/i,
+  );
+  await assert.rejects(
+    queryPiQ(file, { kind: "entries", from: "not-a-date" }),
+    /ISO-8601 timestamp/,
+  );
+  await assert.rejects(
+    queryPiQ(file, { kind: "branches", role: "user" }),
+    /does not support filters/,
+  );
+  await assert.rejects(
+    queryPiQ(file, { kind: "branches", leafId: "active" }),
+    /does not support --leaf/,
+  );
+  const malformed = join(root, "malformed.jsonl");
+  await writeFile(malformed, `${JSON.stringify(records[0])}\n{bad\n`);
+  await assert.rejects(queryPiQ(malformed), /malformed JSON/);
+  const cycle = join(root, "cycle.jsonl");
+  await writeFile(
+    cycle,
+    [
+      { type: "session", version: 3, id: "cycle" },
+      { type: "message", id: "a", parentId: "b", message: { role: "user", content: "a" } },
+      { type: "message", id: "b", parentId: "a", message: { role: "user", content: "b" } },
+    ].map(JSON.stringify).join("\n"),
+  );
+  await assert.rejects(queryPiQ(cycle, { kind: "branches" }), /cycle/);
+});

package/test/rarebit-command.test.mjs

@@ -14,11 +14,11 @@ const values = (prefix) =>
 test("one grammar derives command description and usage", () => {
   assert.equal(
     rarebitCommandDescription(),
-    "Rarebit status/recall/config/auto-title/title/summarize",
+    "Rarebit menu/settings/help/status/recall/fork/config/auto-title/title/recap/summarize",
   );
   assert.equal(
     rarebitCommandUsage(),
-    "Usage: /rarebit [status|recall|config|auto-title|title|summarize]",
+    "Usage: /rarebit [menu|settings|help|status|recall|fork|config|auto-title|title|recap|summarize]",
   );
   assert.equal(
     rarebitCommandUsage("config"),
@@ -41,9 +41,11 @@ test("one grammar derives command description and usage", () => {
 test("parser accepts exactly the command grammar", () => {
   assert.deepEqual(parseRarebitCommand(""), {
     ok: true,
-    subcommand: "status",
+    subcommand: "menu",
     arguments: [],
   });
+  assert.equal(parseRarebitCommand("fork").ok, true);
+  assert.equal(parseRarebitCommand("fork --max-token-length 64000").ok, true);
   assert.equal(parseRarebitCommand("config").ok, true);
   assert.equal(parseRarebitCommand("config max_rarebit_ratio 0.4").ok, true);
   assert.equal(parseRarebitCommand("config min_total_length 80000").ok, true);
@@ -91,14 +93,19 @@ test("parser accepts exactly the command grammar", () => {
 
 test("autocomplete covers subcommands and discrete nested arguments", () => {
   assert.deepEqual(values(""), [
+    "menu",
+    "settings",
+    "help",
     "status",
     "recall",
+    "fork",
     "config",
     "auto-title",
     "title",
+    "recap",
     "summarize",
   ]);
-  assert.deepEqual(values("s"), ["status", "summarize"]);
+  assert.deepEqual(values("s"), ["settings", "status", "summarize"]);
   assert.deepEqual(values("config "), [
     "config max_rarebit_ratio ",
     "config min_total_length ",

package/test/rarebit-fork.test.mjs

@@ -0,0 +1,124 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { spawnSync } from "node:child_process";
+import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
+import {
+  buildRarebitForkPlan,
+  checkRarebitForkHeadroom,
+  createRarebitForkEntries,
+} from "../src/rarebit-fork.mjs";
+import {
+  getImportedRarebitEntryIds,
+  getRarebitForkSeedEntryIds,
+} from "../src/rarebit-fork-lineage.mjs";
+import { projectRarebitSessionActivity } from "../src/rarebit-activity.mjs";
+import registerPiRarebit from "../src/extension.mjs";
+
+const entry = (id, message, order) => ({
+  type: "message", id, parentId: order ? `e${order - 1}` : null,
+  timestamp: `2026-09-21T00:00:0${order}.000Z`, message,
+});
+
+test("fork keeps a maximal newest suffix under aggregate chars/4 and preserves outcomes", () => {
+  const branch = [
+    entry("e0", { role: "user", content: "old" }, 0),
+    entry("e1", { role: "assistant", stopReason: "toolUse", content: "middle" }, 1),
+    entry("e2", { role: "assistant", stopReason: "stop", content: "newest" }, 2),
+  ];
+  const plan = buildRarebitForkPlan({
+    header: { id: "source", cwd: "/source" }, sessionFile: "/source/s.jsonl",
+    cwd: "/source", branch, targetCwd: "/target", maxTokenLength: 2,
+    targetModel: { provider: "test", id: "target", contextWindow: 100_000 },
+    reserveTokens: 16_384,
+  });
+  assert.deepEqual(plan.selected.map((item) => item.sourceEntryId), ["e2"]);
+  assert.equal(plan.importedTokens, 2);
+  const built = createRarebitForkEntries(plan, { sessionId: "forked" });
+  const imported = built.entries.filter((item) => item.rarebitFork?.kind === "import");
+  assert.equal(imported[0].message.stopReason, "stop");
+  assert.equal(imported[0].message.provider, "rarebit-import");
+  assert.equal(imported[0].timestamp, plan.forkCreatedAt);
+  const modelChange = built.entries.at(-1);
+  assert.equal(modelChange.type, "model_change");
+  assert.deepEqual({ provider: modelChange.provider, id: modelChange.modelId }, { provider: "test", id: "target" });
+  assert.deepEqual(getImportedRarebitEntryIds(built.entries), new Set([built.entries[0].id, imported[0].id]));
+  assert.deepEqual(getRarebitForkSeedEntryIds(built.entries), new Set([built.entries[0].id]));
+});
+
+test("fork marker stays machine-only in Pi context and activity excludes seeded entries", () => {
+  const branch = [entry("e0", { role: "user", content: "source" }, 0)];
+  const plan = buildRarebitForkPlan({
+    header: { id: "source", cwd: "/source" }, sessionFile: "/source/s.jsonl", cwd: "/source",
+    branch, targetCwd: "/target", targetModel: { provider: "test", id: "target", contextWindow: 100_000 },
+  });
+  const built = createRarebitForkEntries(plan, { sessionId: "forked" });
+  const seeded = built.entries[0];
+  assert.equal(sessionEntryToContextMessages(seeded)[0].role, "user");
+  assert.equal("rarebitFork" in sessionEntryToContextMessages(seeded)[0], false);
+  const activity = projectRarebitSessionActivity({ ...({ occurrences: [{ sourceEntryId: seeded.id, role: "user", outcome: "user", timestamp: seeded.timestamp }] }), entries: built.entries });
+  assert.equal(activity.latestUser, null);
+});
+
+test("repeat forks preserve marker ancestry and apostrophe-safe PiQ recovery", () => {
+  const sourceBranch = [entry("e0", { role: "user", content: "source" }, 0)];
+  const sourcePlan = buildRarebitForkPlan({ header: { id: "source", cwd: "/source" }, sessionFile: "/tmp/a'b.jsonl", cwd: "/source", branch: sourceBranch, targetCwd: "/target", targetModel: { provider: "test", id: "target", contextWindow: 100_000 } });
+  const first = createRarebitForkEntries(sourcePlan, { sessionId: "first" });
+  const secondPlan = buildRarebitForkPlan({ header: first.header, sessionFile: "/target/first.jsonl", cwd: "/target", branch: first.entries.slice(0, -2), targetCwd: "/target", targetModel: { provider: "test", id: "target", contextWindow: 100_000 } });
+  assert.equal(secondPlan.selected.length, 1);
+  const second = createRarebitForkEntries(secondPlan, { sessionId: "second" });
+  assert.equal(second.manifest.mappings[0].ancestry.length, 2);
+  assert.equal(second.manifest.mappings[0].ancestry[0].sessionId, "source");
+  assert.equal(second.manifest.mappings[0].ancestry[1].sessionId, "first");
+  const recovery = first.entries[0].message.content.split("\n").find((line) => line.startsWith("Recover source"));
+  const command = recovery.slice(recovery.indexOf(": ") + 2).replace(/^piq entries/, "set --");
+  const shell = spawnSync("sh", ["-c", `${command}; printf '%s' \"$2\"`], { encoding: "utf8" });
+  assert.equal(shell.status, 0);
+  assert.equal(shell.stdout, "/tmp/a'b.jsonl");
+});
+
+test("tool schema overhead can refuse when prose and prompt alone fit", () => {
+  assert.doesNotThrow(() => checkRarebitForkHeadroom({ seedText: "x", contextWindow: 100, reserveTokens: 90, promptOverheadTokens: 8, toolOverheadTokens: 0 }));
+  assert.throws(() => checkRarebitForkHeadroom({ seedText: "x", contextWindow: 100, reserveTokens: 90, promptOverheadTokens: 8, toolOverheadTokens: 3 }), /headroom|reserve/i);
+});
+
+test("slash fork counts active Pi tool schemas before writing or switching", async () => {
+  const commands = new Map();
+  let switched = false;
+  const notifications = [];
+  const pi = {
+    on: () => {},
+    registerCommand: (name, command) => commands.set(name, command),
+    getActiveTools: () => ["large_tool"],
+    getAllTools: () => [{ name: "large_tool", description: "tool", parameters: { type: "object", properties: { payload: { type: "string", description: "x".repeat(2_000) } } } }],
+  };
+  registerPiRarebit(pi, { settingsLoader: async () => ({ reserveTokens: 0 }) });
+  const branch = [entry("source-entry", { role: "user", content: "source" }, 0)];
+  const ctx = {
+    hasUI: true, cwd: "/tmp", model: { provider: "test", id: "target", contextWindow: 100 },
+    getSystemPrompt: () => "", getActiveTools: () => ["large_tool"],
+    waitForIdle: async () => {}, isIdle: () => true,
+    ui: { notify: (message, level) => notifications.push({ message, level }) },
+    switchSession: async () => { switched = true; return { cancelled: false }; },
+    sessionManager: {
+      getSessionFile: () => "/tmp/source.jsonl", getHeader: () => ({ id: "source" }), getBranch: () => branch,
+      getLeafId: () => "source-entry", getSessionDir: () => "/tmp",
+    },
+  };
+  await commands.get("rarebit").handler("fork", ctx);
+  assert.equal(switched, false);
+  ctx.model = null;
+  await commands.get("rarebit").handler("fork", ctx);
+  assert.equal(switched, false);
+  assert.match(notifications.at(-1).message, /destination model\/context window is unavailable/);
+});
+
+test("headroom refuses before a destination can be switched", () => {
+  assert.throws(() => buildRarebitForkPlan({
+    header: { id: "source" }, sessionFile: "/source/s.jsonl", branch: [entry("e0", { role: "user", content: "x" }, 0)],
+    maxTokenLength: 10, targetModel: { provider: "test", id: "tiny", contextWindow: 10 }, reserveTokens: 9,
+  }), /headroom|reserve/i);
+});