@intentic/sandbox-contract 1.304.0 → 1.305.0

package/src/schemas/settings.ts

@@ -13,10 +13,6 @@ export const SystemPromptModeSchema = z.enum(["intentic", "claude", "custom"]);
 export type SystemPromptMode = z.infer<typeof SystemPromptModeSchema>;
 // Excludes "custom": there is nothing to fetch, it's whatever the owner already typed into the settings field.
 export const BuiltinPromptSchema = z.object({ base: z.enum(["intentic", "claude"]) });
-// Declared out here because the daemon branches on it in three places (whether to wire the hook, consult the successor
-// list, what the notice says) and the browser branches on it too.
-export const DependencyFreshnessSchema = z.enum(["off", "versions", "full"]);
-export type DependencyFreshness = z.infer<typeof DependencyFreshnessSchema>;
 // Rules: "at this moment, if this is true, do this" — one table replacing three settings that were the same idea built
 // three ways; a fourth is now a row here, not a release. Moments are named to match `WorkspaceEventKind`, so folding
 // chores in later won't rename what users wrote.
@@ -225,14 +221,15 @@ export const SandboxSettingsSchema = z.object({
             "Keep the instructions identical between turns so the provider can cache them, moving anything that varies into the message instead. Cheaper, at the cost of some flexibility.",
         ),
     skills: z.array(z.string()).default(["lsp", "fileq"]).describe("Which built-in tools are switched on. A skill of your own is not listed here: it is on while the agent's copy of it exists."),
-    // Router reads the sent message and one line per card, once per chat, between send and the first turn
-    // (persona-router.ts / model-roles.ts). Never asked of a draft: only a sent message is a finished one.
-    // Attended chats only: routing onto a card would grant an unwatched wake accounts nobody named for it.
+    // One half of the reading a new chat gets between send and its first turn (chat-router.ts): with this on, the
+    // message and one line per card are put to the same model that chooses what the chat runs on, in the same call.
+    // Never asked of a draft: only a sent message is a finished one. Attended chats only: routing onto a card would
+    // grant an unwatched wake accounts nobody named for it.
     personaRouting: z
         .boolean()
         .default(true)
         .describe(
-            "Whether a new chat is matched to one of your personas from its first message. The message is read once it is sent, by the model on the persona-routing list, and the chat says in its own transcript what was asked and which persona it landed on. Never applies to unwatched runs, which name their persona themselves.",
+            "Whether a new chat is matched to one of your personas from its first message. It is read once the message is sent, in the same single call that chooses what the chat runs on (the New chat routing job under Models), and the chat says in its own transcript which persona it landed on. Never applies to unwatched runs, which name their persona themselves.",
         ),
     hashlineEdits: z
         .boolean()
@@ -240,7 +237,8 @@ export const SandboxSettingsSchema = z.object({
         .describe(
             "Have the agent edit files by line number rather than by quoting the text it wants replaced. Cheaper on large files, and less forgiving of a stale read.",
         ),
-    // intentic: this product's own prompt (intentic-prompt.ts), tuned for this harness. Default.
+    // intentic: Claude Code's preset, read the same way, with what this harness does not want cut out (intentic-prompt.ts).
+    // Default.
     // claude: Claude Code's preset, read live from the installed CLI, not a stored copy — tracks whatever prompt ships
     // with it.
     // custom: `systemPrompt` below, and nothing else.
@@ -321,14 +319,6 @@ export const SandboxSettingsSchema = z.object({
         .describe(
             "Keep an up-to-date markdown rendering of every document, image and audio file in the workspace, made in the background as files land, so the agent reads a pre-derived text instead of paying to parse the file mid-task. Costs background CPU on a document-heavy workspace, so it is a switch rather than a default.",
         ),
-    // versions: a measurement only (the registry's own newest release).
-    // full: also the name of a successor, but only where the registry itself corroborates it (deprecated, or nothing
-    // published in 18 months) — curation supplies the name, measurement supplies the reason.
-    // Informs, never blocks: matching a version the workspace already pins is usually correct, and a gate would fight
-    // legitimate work more than it caught mistakes.
-    dependencyFreshness: DependencyFreshnessSchema.default("off").describe(
-        "Whether a version the agent is about to pin is checked against the package's own registry first. Facts only, or facts plus the name of a maintained replacement where the registry agrees the current choice has been abandoned. It tells the agent and lets it decide rather than refusing, because matching a version your project already uses is usually the right answer and a gate would fight it.",
-    ),
     outputCleaners: z
         .string()
         .default("")
@@ -349,7 +339,7 @@ export const SandboxSettingsSchema = z.object({
         .describe(
             "Which models do which job, one ordered list per job: commit messages, session titles, the safety judge, pipeline fixes, and every other place this sandbox picks a model for you. Tried in order, so one spent account does not take a job down. Nothing is chosen for you: a one-shot job with no list does not run, and a whole session with no list opens on whatever your own chat is set to.",
         ),
-    // Folded into the Auto router's prompt (agent/prompt/model-router.ts), never into a turn's own. Capped small on
+    // Folded into the router's prompt (agent/prompt/chat-router.ts), never into a turn's own. Capped small on
     // purpose: the reading runs under a 5s deadline, and this text is paid for on every chat that opens on Auto.
     autoModelGuidance: z
         .string()
@@ -479,7 +469,7 @@ export const TimezoneStateSchema = z.object({
 });
 export type TimezoneState = z.infer<typeof TimezoneStateSchema>;
 // Read live from the installed CLI (preset-prompt.ts), not a stored transcription. `version` is the CLI build it came
-// from, so a fork from an older build reads as a snapshot; empty for Intentic's own prompt.
+// from, so a fork from an older build reads as a snapshot.
 export const BuiltinPromptTextSchema = z.object({ text: z.string(), version: z.string() });
 export type BuiltinPromptText = z.infer<typeof BuiltinPromptTextSchema>;
 // What each token-reduction mechanism actually saved. Input-side: both sides of the comparison come off the same
@@ -551,22 +541,6 @@ export const TurnExperimentSchema = z.object({
     cohort: z.string().optional(),
 });
 export type TurnExperiment = z.infer<typeof TurnExperimentSchema>;
-// One dependency version or library improvement suggested or pinned.
-export const DependencyImprovementSchema = z.object({
-    prevented: z.string(),
-    chosen: z.string(),
-    reason: z.string(),
-    at: z.number().optional(),
-});
-export type DependencyImprovement = z.infer<typeof DependencyImprovementSchema>;
-// Rollup of registry freshness interventions over the queried day window.
-export const DependencySavingsSchema = z.object({
-    checked: z.number(),
-    improved: z.number(),
-    recent: z.array(DependencyImprovementSchema),
-    updatedAt: z.number().optional(),
-});
-export type DependencySavings = z.infer<typeof DependencySavingsSchema>;
 // What the settings row can say about the brief without opening it: whether there is one, how much of it this budget
 // reaches, and whether anything is scheduled to rewrite it. Read off the file and the automation store, never stored.
 export const FieldNotesStatusSchema = z.object({
@@ -595,7 +569,6 @@ export const SavingsReportSchema = z.object({
     // Same absence rule as `search`: not measured, never zero.
     map: TurnExperimentSchema.optional(),
     notes: TurnExperimentSchema.optional(),
-    dependencies: DependencySavingsSchema.optional(),
 });
 export type SavingsReport = z.infer<typeof SavingsReportSchema>;
 

package/src/schemas/shared.ts

@@ -8,18 +8,18 @@ export const OkSchema = object({
     ok: literal(true)
         .describe("Always true. A route that answers this either did the thing or refused with a status; there is no third outcome to report."),
 });
-// Trust tiers, ordered low to high: desk talks to the persona cards it was handed and sees nothing else, viewer
+// Trust tiers, ordered low to high: guest talks to the persona cards it was handed and sees nothing else, viewer
 // watches, collaborator's outward actions become requests, writer changes files inside the areas it holds and ships
 // none of them, maintainer holds the owner's authority but is revocable, owner is the one bound identity and not a
 // grant.
-export const MemberRoleSchema = zEnum(["desk", "viewer", "collaborator", "writer", "maintainer", "owner"]);
+export const MemberRoleSchema = zEnum(["guest", "viewer", "collaborator", "writer", "maintainer", "owner"]);
 export type MemberRole = z.infer<typeof MemberRoleSchema>;
 // Roles an invite can grant: everything but owner, which binds at first sign-in and is never granted.
-export const GrantedRoleSchema = zEnum(["desk", "viewer", "collaborator", "writer", "maintainer"]);
+export const GrantedRoleSchema = zEnum(["guest", "viewer", "collaborator", "writer", "maintainer"]);
 export type GrantedRole = z.infer<typeof GrantedRoleSchema>;
-// Single source for role order; every surface that gates on a role reads this ranking. A desk is below every
-// floor: its routes are an allowlist of its own (auth/role-floor.ts deskReach), never a floor it can clear.
-const MEMBER_ROLE_RANK: Record<MemberRole, number> = { desk: 0, viewer: 1, collaborator: 2, writer: 3, maintainer: 4, owner: 5 };
+// Single source for role order; every surface that gates on a role reads this ranking. A guest is below every
+// floor: its routes are an allowlist of its own (auth/role-floor.ts guestReach), never a floor it can clear.
+const MEMBER_ROLE_RANK: Record<MemberRole, number> = { guest: 0, viewer: 1, collaborator: 2, writer: 3, maintainer: 4, owner: 5 };
 export const roleAtLeast = (role: MemberRole, floor: MemberRole): boolean => MEMBER_ROLE_RANK[role] >= MEMBER_ROLE_RANK[floor];
 // Rotating a door credential (event webhook, release gate, bug intake): the old value stops working immediately; the
 // new one is shown once to be saved.

package/src/schemas/system-prompt.ts

@@ -0,0 +1,41 @@
+// system-prompt: what a conversation was told before its own words
+import { z } from "zod";
+import { SystemPromptModeSchema } from "./settings.js";
+
+// Every section names its mechanism: the reader asks "did my AGENTS.md arrive", not "what does paragraph nine say".
+export const PromptSectionSourceSchema = z.enum(["guidance", "persona", "field-notes", "memory"]);
+export type PromptSectionSource = z.infer<typeof PromptSectionSourceSchema>;
+
+export const PromptSectionSchema = z.object({
+    source: PromptSectionSourceSchema.describe("Which mechanism added this."),
+    title: z.string().describe("The one line a reader sees on the row that opens to the text below."),
+    text: z.string().describe("The section's exact words, as the model received them."),
+});
+export type PromptSection = z.infer<typeof PromptSectionSchema>;
+
+// `runtime`: a CLI that keeps its own prompt, so no text; `trimmed`: the small-window paragraph, never reported as `custom`.
+export const PromptBaseKindSchema = z.enum(["intentic", "claude", "custom", "runtime", "trimmed"]);
+export type PromptBaseKind = z.infer<typeof PromptBaseKindSchema>;
+
+export const PromptBaseSchema = z.object({
+    kind: PromptBaseKindSchema.describe("Which prompt the additions ride on."),
+    text: z.string().optional().describe("The base's own words, when they can be read here. Absent for a runtime that keeps its prompt to itself."),
+    model: z.string().optional().describe("The model the turn ran on, for a built-in base: Claude Code renders a different preset for each."),
+});
+export type PromptBase = z.infer<typeof PromptBaseSchema>;
+
+// Recorded at dispatch from the request the adapter was handed: what was sent, not what would be composed now.
+export const SystemPromptDisclosureSchema = z.object({
+    at: z.number().describe("When the turn that was told this was sent (epoch ms)."),
+    runtime: z.string().describe("Which runtime served that turn."),
+    mode: SystemPromptModeSchema.describe("Which base the turn was configured to run on."),
+    base: PromptBaseSchema,
+    sections: z.array(PromptSectionSchema).describe("What the daemon added to that base, in the order the model reads them."),
+});
+export type SystemPromptDisclosure = z.infer<typeof SystemPromptDisclosureSchema>;
+
+// Absent `prompt` means no turn was dispatched since the daemon started recording.
+export const ConversationPromptSchema = z.object({
+    prompt: SystemPromptDisclosureSchema.optional().describe("What the most recent turn of this conversation was told, if one has been recorded."),
+});
+export type ConversationPrompt = z.infer<typeof ConversationPromptSchema>;

package/src/schemas/version-seam.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { test, expect } from "bun:test";
 import { CapabilitiesListSchema } from "./capabilities.js";
 import { SandboxSettingsSchema } from "./settings.js";
 import { SmbNetdiskConfigSchema } from "./netdisk.js";

package/src/schemas/webext.ts

@@ -34,7 +34,7 @@ export const WebExtGrantSchema = object({
     mode: zEnum(["read", "act"]),
 });
 export type WebExtGrant = z.infer<typeof WebExtGrantSchema>;
-// What a connected browser reports about itself: mirrors HostFacts, adding exactly which sites it may touch right now.
+// What a connected browser reports about itself: mirrors DeviceFacts, adding exactly which sites it may touch right now.
 export const WebExtFactsSchema = object({
     // How a person would name it: "Chrome 141 on Windows".
     browser: string(),

package/src/schemas/workflows.ts

@@ -107,15 +107,15 @@ export const WorkflowGateSchema = z.object({
         ),
 });
 export type WorkflowGate = z.infer<typeof WorkflowGateSchema>;
-// Small next to the Front Desk's 200: a gate run is a whole graph of sessions, not one turn.
+// Small next to the Visitor chat's 200: a gate run is a whole graph of sessions, not one turn.
 export const GATE_DAILY_MAX_DEFAULT = 20;
 // blocked means the gate couldn't reach a judgment, not that the product is broken; conflating the two makes teams turn
 // the gate off. Maps to a neutral pipeline exit, never a failed build.
-export const GateOutcomeSchema = z.enum(["pass", "fail", "blocked"]);
-export type GateOutcome = z.infer<typeof GateOutcomeSchema>;
+export const GuardOutcomeSchema = z.enum(["pass", "fail", "blocked"]);
+export type GuardOutcome = z.infer<typeof GuardOutcomeSchema>;
 // value is the field as the step wrote it; absent means most blocked verdicts had nothing to read.
 export const GateVerdictSchema = z.object({
-    outcome: GateOutcomeSchema.describe(
+    outcome: GuardOutcomeSchema.describe(
         "Ship it, do not, or we could not tell. That third answer exists because could not reach a judgement is not the product is broken: a gate that reported its own outages as failures is one a team switches off, so it should be the honest answer far more often than the convenient one, and it means a neutral build rather than a red one.",
     ),
     // Why, in one line; realistically the only part of this a pipeline log will show.

package/src/state/contract-lock.test.ts

@@ -1,17 +1,21 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { packageRoot } from "@intentic/constants/node";
-import { expect, test } from "vitest";
+import { test, expect } from "bun:test";
 import { currentLock } from "./contract-lock.js";
 
 // contract.lock.json must match the exported schemas; the git-aware half of this check lives in contract-shrink.mjs.
-// Needs 30s: serializing ~500 schemas can run past vitest's 5s hang-detector default under load.
-test("contract.lock.json matches the schemas this package exports", { timeout: 30_000 }, () => {
-    const committed: unknown = JSON.parse(readFileSync(join(packageRoot(import.meta.url), "contract.lock.json"), "utf8"));
-    expect(
-        currentLock(),
-        "the wire contract moved — run `pnpm --filter @intentic/sandbox-contract lock` and commit contract.lock.json with this change. " +
-            "If a schema or field was removed or changed (not added), land it as a `type!:` commit with a `Breaking-Note:` trailer " +
-            "saying, in the user's words, what stops working and what to do instead.",
-    ).toEqual(committed);
-});
+// Needs 30s: serializing ~500 schemas can run past the unit hang detector under load.
+test(
+    "contract.lock.json matches the schemas this package exports",
+    () => {
+        const committed = JSON.parse(readFileSync(join(packageRoot(import.meta.url), "contract.lock.json"), "utf8")) as Record<string, unknown>;
+        expect(
+            currentLock(),
+            "the wire contract moved — run `pnpm --filter @intentic/sandbox-contract lock` and commit contract.lock.json with this change. " +
+                "If a schema or field was removed or changed (not added), land it as a `type!:` commit with a `Breaking-Note:` trailer " +
+                "saying, in the user's words, what stops working and what to do instead.",
+        ).toEqual(committed);
+    },
+    { timeout: 30_000 },
+);

package/src/state/fix-attempt-plan.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { test, expect } from "bun:test";
 import { ciFixConversationId, fixAttemptId } from "../ids/conversation-ids.js";
 import type { AgentSummary } from "../schemas/agents.js";
 import { planFixAttempt } from "./fix-attempt-plan.js";
@@ -36,6 +36,15 @@ test("an attempt that ended is continued by a plain press, and by an explicit Co
     expect(planFixAttempt(BASE, roster, [], `continue`)).toEqual({ kind: `continue`, conversationId: BASE, attempt: 1 });
 });
 
+// A nudge to carry on names evidence earlier in the conversation, which an attempt turned away never received.
+test("an attempt turned away at the door is sent the whole task again, in the same conversation", () => {
+    const roster = [agent(BASE, { status: `error`, failureCode: `sandbox-memory-low`, failure: `Sandbox memory is low.` })];
+    expect(planFixAttempt(BASE, roster, [])).toEqual({ kind: `resend`, conversationId: BASE, attempt: 1 });
+    expect(planFixAttempt(BASE, roster, [], `continue`)).toEqual({ kind: `resend`, conversationId: BASE, attempt: 1 });
+    // Starting over is still the reader's to ask for.
+    expect(planFixAttempt(BASE, roster, [], `start-over`)).toMatchObject({ kind: `start-over`, retire: BASE });
+});
+
 test("start over retires the latest attempt and numbers the next past it", () => {
     const second = fixAttemptId(BASE, 2);
     const plan = planFixAttempt(BASE, [agent(BASE, { status: `stopped` }), agent(second, { status: `error` })], [], `start-over`);

package/src/state/fix-attempt-plan.ts

@@ -1,6 +1,6 @@
 import { fixAttemptOf, latestFixAttempt, nextFixAttemptId } from "../ids/conversation-ids.js";
 import type { AgentSummary } from "../schemas/agents.js";
-import { type FixStance, fixStance } from "./fix-stance.js";
+import { type FixStance, fixStance, turnedAwayAttempt } from "./fix-stance.js";
 
 /* WHAT A PRESS ON A FAILURE'S FIX CONTROL DOES, decided once for every surface that has one — the push question in the shell, the pipelines board's rows. */
 
@@ -12,6 +12,8 @@ export type FixAttemptPlan =
     | { readonly kind: "new"; readonly conversationId: string; readonly attempt: number }
     // The latest attempt ended without a fix: carry on in it, with a nudge rather than the whole opening prompt.
     | { readonly kind: "continue"; readonly conversationId: string; readonly attempt: number }
+    // The latest attempt was turned away before it started, so it never saw the task: the whole prompt again, in it.
+    | { readonly kind: "resend"; readonly conversationId: string; readonly attempt: number }
     // Set the latest attempt aside (stopped first if still running) and open the next one on a clean worktree.
     | {
           readonly kind: "start-over";
@@ -40,7 +42,9 @@ export const planFixAttempt = (base: string, roster: readonly AgentSummary[], kn
         return { kind: "start-over", retire: latest.agent.id, stopFirst: stance.kind === "working", ...next() };
     }
     if (stance.retry) {
-        return { kind: "continue", conversationId: latest.agent.id, attempt: latest.attempt };
+        // A nudge to carry on names evidence earlier in the conversation, which an attempt turned away never received.
+        const kind = turnedAwayAttempt(latest.agent) ? "resend" : "continue";
+        return { kind, conversationId: latest.agent.id, attempt: latest.attempt };
     }
     return { kind: "busy", conversationId: latest.agent.id, stance };
 };

package/src/state/fix-stance.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { test, expect } from "bun:test";
 import { fixStance } from "./fix-stance.js";
 import type { AgentSummary } from "../schemas/agents.js";
 
@@ -97,3 +97,12 @@ test("an unknown ending still produces a stance", () => {
     expect(stance.label).toBe(`Agent stopped`);
     expect(stance.retry).toBe(true);
 });
+
+// Refused before the model saw a word, so there is no work to carry on: the chip says it never started, and the press
+// sends the whole task rather than a nudge that points at evidence the attempt never received.
+test("an attempt turned away at the door says it never started, with the refusal's own sentence", () => {
+    const stance = fixStance(agent({ status: `error`, failureCode: `sandbox-memory-low`, failure: `Sandbox memory is low` }));
+    expect(stance).toMatchObject({ kind: `ended`, ongoing: false, retry: true, label: `Didn't start` });
+    expect(stance.hint).toContain(`turned away before it started: Sandbox memory is low.`);
+    expect(stance.hint).toContain(`sends it the whole task again`);
+});

package/src/state/fix-stance.ts

@@ -1,3 +1,4 @@
+import { turnedAwayCode } from "../policy/turned-away.js";
 import type { AgentSummary } from "../schemas/agents.js";
 
 /* WHAT BECAME OF THE AGENT A SURFACE SENT AFTER A FAILURE — a red pipeline row, a refused push. */
@@ -87,7 +88,19 @@ const ENDINGS: Partial<Record<AgentSummary["status"], { readonly label: string;
     idle: { label: "Nothing changed", why: "The fix agent finished without changing any files" },
 };
 
+// A failed turn the refusal stopped before the model saw a word: it never started, so there is nothing to carry on.
+export const turnedAwayAttempt = (agent: AgentSummary): boolean => agent.status === "error" && turnedAwayCode(agent.failureCode);
+
 const ended = (agent: AgentSummary): FixStance => {
+    if (turnedAwayAttempt(agent)) {
+        return {
+            kind: "ended",
+            ongoing: false,
+            retry: true,
+            label: "Didn't start",
+            hint: `The fix agent was turned away before it started${agent.failure === undefined ? "" : `: ${agent.failure}`}. Continuing sends it the whole task again; starting over opens a fresh conversation.`,
+        };
+    }
     const ending = ENDINGS[agent.status] ?? { label: "Agent stopped", why: "The fix agent's turn ended" };
     // File count left behind by a turn that died mid-edit; not a fix, but worth surfacing.
     const files = agent.diff?.files ?? 0;

package/src/state/history-state.ts

@@ -19,12 +19,16 @@ export const HISTORY_STATE_FILES: readonly StateFile[] = [
     // Armed condition watches; carries safely: the journal holds no credential, only names re-derived on target.
     { path: "watches/", portability: "carry" },
     { path: "transcripts/", portability: "carry" },
+    // What each conversation's last turn was told before its own words (prompt-record.ts), one file per conversation.
+    // Carried with the transcripts it explains: a restored conversation whose prompt record stayed behind can no
+    // longer say whether its AGENTS.md arrived or a small window trimmed it, which is the whole point of keeping it.
+    { path: "system-prompts/", portability: "carry" },
     // One runtime session store per fenced conversation, holding for it what `.intentic/records/sessions/claude/` holds
     // for every other: its own transcripts, plans, backups and checklists, kept off /work so no other conversation's
     // namespace can reach them. Carried for the same reason that one is.
     { path: "sessions/", portability: "carry" },
     // What each message can restore to (a checkpoint or isolated commit); the join between transcripts and scopes.
-    { path: "turn-anchors.json", portability: "carry" },
+    { path: "turn-checkpoints.json", portability: "carry" },
     // Index of published-page conversations; the pages travel with /work anyway, this makes one withdrawable.
     { path: "shares.json", portability: "carry" },
     { path: "activity.jsonl", portability: "carry" },
@@ -60,6 +64,18 @@ export const HISTORY_STATE_FILES: readonly StateFile[] = [
     },
     // Search phrase index, derived from transcripts/; rebuilt by the first boot's backfill instead of carried.
     { path: "said-index/", portability: "derived", note: "Rebuilt from the carried transcripts by the first boot's backfill." },
+    // What each conversation was last told (prompt-record.ts). Tens of kilobytes per conversation, rewritten by every
+    // turn — and a prompt composed on THIS sandbox names its paths, devices and accounts, so carrying it would describe
+    // the machine the bundle left rather than the one it landed on.
+    {
+        path: "system-prompts/",
+        portability: "derived",
+        note: "Each conversation records what it was told again on its next turn.",
+    },
+    // What each connected machine and browser publishes as its tools, so one that is asleep still appears in a turn
+    // (peers/peer-tool-memory.ts). Re-asked of every peer the moment it reconnects, and about software that stayed
+    // behind on somebody else's computer, so it is not worth carrying.
+    { path: "peer-tools.json", portability: "derived" },
     { path: "overlays/", portability: "derived" },
     { path: "logs/", portability: "derived" },
     { path: "trash/", portability: "derived" },

package/src/state/runtime-state.test.ts

@@ -1,5 +1,5 @@
-import { describe, expect, it } from "vitest";
-import { RUNTIME_DOMAIN_BINDINGS, runtimeBoundQueryKeys, staleRuntimeQueryKeys } from "./runtime-state.js";
+import { describe, it, expect } from "bun:test";
+import { RUNTIME_DOMAIN_BINDINGS, staleRuntimeQueryKeys } from "./runtime-state.js";
 
 describe(`staleRuntimeQueryKeys`, () => {
     it(`maps a pushed domain to the queries it makes stale`, () => {
@@ -30,13 +30,7 @@ describe(`staleRuntimeQueryKeys`, () => {
     });
 });
 
-describe(`runtimeBoundQueryKeys`, () => {
-    it(`covers every declared domain, since a reconnect is the only recovery for a frame nobody received`, () => {
-        // Joined into strings for comparison: two equal arrays are still different object identities.
-        const joined = (keys: readonly (readonly string[])[]): string[] => [...new Set(keys.map((key) => key.join(`/`)))].toSorted();
-        expect(joined(runtimeBoundQueryKeys())).toEqual(joined(RUNTIME_DOMAIN_BINDINGS.flatMap((binding) => binding.invalidates)));
-    });
-
+describe(`RUNTIME_DOMAIN_BINDINGS`, () => {
     it(`leaves no domain declaring no keys: a domain nothing renders has no reason to be pushed`, () => {
         expect(RUNTIME_DOMAIN_BINDINGS.filter((binding) => binding.invalidates.length === 0)).toEqual([]);
     });

package/src/state/runtime-state.ts

@@ -63,7 +63,3 @@ const dedupe = (keys: readonly QueryKeyPath[]): readonly QueryKeyPath[] => [...n
 // browser share one table. An unknown domain is dropped rather than throwing, for forward compatibility.
 export const staleRuntimeQueryKeys = (domains: readonly string[]): readonly QueryKeyPath[] =>
     dedupe(RUNTIME_DOMAIN_BINDINGS.filter((binding) => domains.includes(binding.domain)).flatMap((binding) => binding.invalidates));
-
-// Every key any runtime domain feeds; what a fresh /events connection re-asks wholesale, since a missed push here is
-// gone for good. Bounds the cost to one read per key, letting these views stay unpolled.
-export const runtimeBoundQueryKeys = (): readonly QueryKeyPath[] => dedupe(RUNTIME_DOMAIN_BINDINGS.flatMap((binding) => binding.invalidates));

package/src/state/versions.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { test, expect } from "bun:test";
 import { DEV_VERSION, isBehind, isNewer } from "./versions.js";
 
 test("isNewer compares dotted numeric versions", () => {

package/src/state/workspace-state.test.ts

@@ -1,6 +1,6 @@
 import { STATE_DIR } from "@intentic/constants";
 import type { FileContribution } from "@intentic/extension-manifest";
-import { describe, expect, it } from "vitest";
+import { describe, it, expect } from "bun:test";
 import {
     BACKED_UP_STATE_PATHS,
     isLockedWorkspacePath,
@@ -302,12 +302,12 @@ describe(`VERSIONED_STATE_PATHS`, () => {
     // versioned asks if a human should review it; carry asks if it moves. Frequently-rewritten ledgers are carry only.
     it(`leaves the ledgers and the bulk out even though they travel`, () => {
         for (const path of [
-            `.intentic/records/workflow-runs.json`,
+            `${STATE_DIR}/records/workflow-runs.json`,
             // Split from the tracked automations manifest so a run doesn't dirty it.
-            `.intentic/records/automation-runs.json`,
-            `.intentic/records/loops.json`,
-            `.intentic/records/thread-sessions.json`,
-            `.intentic/records/extension-usage.json`,
+            `${STATE_DIR}/records/automation-runs.json`,
+            `${STATE_DIR}/records/loops.json`,
+            `${STATE_DIR}/records/thread-sessions.json`,
+            `${STATE_DIR}/records/extension-usage.json`,
             `.intentic/records/webchat-installs.json`,
             `.intentic/records/sessions/claude/`,
             `.intentic/records/artifacts/`,
@@ -529,7 +529,12 @@ describe(`BACKED_UP_STATE_PATHS`, () => {
 
     // identity means never restoring into another sandbox; that doesn't stop the owner keeping their own copy.
     it(`copies the ownership records that may never travel`, () => {
-        for (const path of [`.intentic/identity/owner.json`, `.intentic/identity/members.json`, `.intentic/identity/workspace.json`, `.intentic/identity/passkeys.json`]) {
+        for (const path of [
+            `.intentic/identity/owner.json`,
+            `.intentic/identity/members.json`,
+            `.intentic/identity/workspace.json`,
+            `.intentic/identity/passkeys.json`,
+        ]) {
             expect([path, BACKED_UP_STATE_PATHS.includes(path)]).toEqual([path, true]);
         }
     });

package/src/state/workspace-state.ts

@@ -225,25 +225,25 @@ const STATE_FILES = [
     {
         path: ".intentic/records/webchat-installs.json",
         invalidates: [],
-        why: "Which origins have loaded a Front Desk's widget, written on a 30s flush timer while a customer's site serves page views. The install panel that renders it fetches on open and polls itself while it is on screen, which is the whole window in which the answer changes for anyone. Pushing instead would bill every connected browser a refetch per flush, for a panel almost nobody has open.",
+        why: "Which origins have loaded a Visitor chat's widget, written on a 30s flush timer while a customer's site serves page views. The install panel that renders it fetches on open and polls itself while it is on screen, which is the whole window in which the answer changes for anyone. Pushing instead would bill every connected browser a refetch per flush, for a panel almost nobody has open.",
         portability: "carry",
     },
     {
         path: ".intentic/records/issue-installs.json",
         invalidates: [],
-        why: "The same probe for the bug reporter's script, on the same flush timer and read by the same kind of panel, so it is outside the push path for the same reason the Front Desk's is.",
+        why: "The same probe for the bug reporter's script, on the same flush timer and read by the same kind of panel, so it is outside the push path for the same reason the Visitor chat's is.",
         portability: "carry",
     },
     {
         path: ".intentic/records/webchat-outbox.json",
         invalidates: [],
-        why: "Front Desk replies a visitor has not collected yet, written when an approved wake answers or a human writes as the agent. The only reader is a stranger's browser polling the public /webchat door, which no query key in this app addresses; the owner's own view of the same words is the conversation's transcript, which the agent registry already pushes.",
+        why: "Visitor chat replies a visitor has not collected yet, written when an approved wake answers or a human writes as the agent. The only reader is a stranger's browser polling the public /webchat door, which no query key in this app addresses; the owner's own view of the same words is the conversation's transcript, which the agent registry already pushes.",
         portability: "carry",
     },
     {
         path: ".intentic/records/thread-sessions.json",
         invalidates: [],
-        why: "Thread bookkeeping (an inbound thread, a Front Desk visitor, a Discord or Slack channel, → sandbox conversation + provider session), written on EVERY inbound message. Nothing in the browser reads it: what a thread produces is a conversation, and the fleet board already learns about that from the agent registry's own push. Naming a key here would bill every connected browser a refetch per inbound message, the request storm this table's own note warns about, to refresh nothing it can see.",
+        why: "Thread bookkeeping (an inbound thread, a Visitor chat visitor, a Discord or Slack channel, → sandbox conversation + provider session), written on EVERY inbound message. Nothing in the browser reads it: what a thread produces is a conversation, and the fleet board already learns about that from the agent registry's own push. Naming a key here would bill every connected browser a refetch per inbound message, the request storm this table's own note warns about, to refresh nothing it can see.",
         portability: "carry",
     },
     {

package/src/text/archives.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, it, expect } from "bun:test";
 import { archiveFormat, archivePrefixOf, archiveRootOf, archiveStem, isBrowsableArchive, wrapsItsOwnName } from "./archives.js";
 
 describe(`archive names`, () => {

package/src/text/documents.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, test, expect } from "bun:test";
 import { documentOf, documentTitle, isDocumentPath, isPlanDocumentPath } from "./documents.js";
 import { PLAN_DOCUMENTS_DIR } from "../state/workspace-state.js";
 

package/src/text/documents.ts

@@ -1,4 +1,4 @@
-import type { CardDocument, ToolCallContent } from "../events/cards.js";
+import type { RequestDocument, ToolCallContent } from "../events/requests.js";
 import { planParts } from "./title.js";
 import { PLAN_DOCUMENTS_DIR } from "../state/workspace-state.js";
 
@@ -24,7 +24,7 @@ export const documentTitle = (markdown: string, path: string): string => planPar
 
 // Reads the call's structured diff, not its result text: a Write's whole file already rides the frame as newText
 // (capped, truncated flags it). Works even for a published transcript with no workspace behind it.
-export const documentOf = (name: string, content: readonly ToolCallContent[] | undefined): CardDocument | undefined => {
+export const documentOf = (name: string, content: readonly ToolCallContent[] | undefined): RequestDocument | undefined => {
     if (name.toLowerCase() !== "write") {
         return undefined;
     }

package/src/text/embed.test.ts

@@ -1,5 +1,6 @@
 import { webcrypto } from "node:crypto";
-import { beforeAll, expect, test, vi } from "vitest";
+import { test, expect, beforeAll, mock } from "bun:test";
+import { stubGlobal, unstubAllGlobals } from "@intentic/testing/bun";
 import { EmbedError, embedFailure, embedUrl, fetchEmbedJson, solveProofOfWork } from "./embed.js";
 
 /* The wire every embed speaks before it speaks its own, against a fake fetch and the real WebCrypto. */
@@ -24,7 +25,9 @@ const leadingZeroBits = async (answer: string): Promise<number> => {
 };
 
 test("a door's route is spelled the daemon's way, with the automation id encoded", () => {
-    expect(embedUrl({ base: "https://sandbox.example", automationId: "a b" }, "webchat", "config")).toBe("https://sandbox.example/webchat/a%20b/config");
+    expect(embedUrl({ base: "https://sandbox.example", automationId: "a b" }, "webchat", "config")).toBe(
+        "https://sandbox.example/webchat/a%20b/config",
+    );
 });
 
 test("a refusal carries the server's own sentence and status, and a bodyless one says what it can", async () => {
@@ -35,11 +38,17 @@ test("a refusal carries the server's own sentence and status, and a bodyless one
 });
 
 test("a JSON fetch answers the body or throws the refusal", async () => {
-    vi.stubGlobal("fetch", vi.fn(async () => new Response(JSON.stringify({ ok: true }), { status: 200 })));
+    stubGlobal(
+        "fetch",
+        mock(async () => new Response(JSON.stringify({ ok: true }), { status: 200 })),
+    );
     expect(await fetchEmbedJson<{ ok: boolean }>("https://x/y")).toEqual({ ok: true });
-    vi.stubGlobal("fetch", vi.fn(async () => new Response(JSON.stringify({ error: "rate limited" }), { status: 429 })));
+    stubGlobal(
+        "fetch",
+        mock(async () => new Response(JSON.stringify({ error: "rate limited" }), { status: 429 })),
+    );
     await expect(fetchEmbedJson("https://x/y")).rejects.toMatchObject({ message: "rate limited", status: 429 });
-    vi.unstubAllGlobals();
+    unstubAllGlobals();
 });
 
 /* The one test that pays for real work: 12 bits is ~900 awaited digests. */
@@ -59,6 +68,8 @@ test("a different salt yields a different answer: a solution cannot be replayed
 
 test("an http:// page is told the truth, in the embed's own words, instead of hanging on a missing SubtleCrypto", async () => {
     Object.defineProperty(globalThis, "crypto", { value: { randomUUID: webcrypto.randomUUID }, configurable: true });
-    await expect(solveProofOfWork({ salt: "abc", difficulty: 8 }, "This page must be served over HTTPS to start a chat.")).rejects.toThrow(/HTTPS to start a chat/);
+    await expect(solveProofOfWork({ salt: "abc", difficulty: 8 }, "This page must be served over HTTPS to start a chat.")).rejects.toThrow(
+        /HTTPS to start a chat/,
+    );
     Object.defineProperty(globalThis, "crypto", { value: webcrypto, configurable: true });
 });

package/src/text/emoji.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, it, expect } from "bun:test";
 import { isSingleEmoji } from "./emoji.js";
 
 describe("isSingleEmoji", () => {