@intentic/sandbox-contract 1.309.0 → 1.310.0

package/src/schemas/metrics.ts

@@ -59,9 +59,7 @@ export const SandboxUsageSchema = z.object({
         .optional()
         .describe("CPU the whole sandbox used over the window, as a percentage of all it may use (`cores`). Absent on a first reading."),
     cores: z.number().describe("How many cores the sandbox may use: its CPU quota, or every core it is allowed to run on when it has none."),
-    memoryBytes: z
-        .number()
-        .describe("Memory in use, less the file cache the kernel takes back on demand: the figure that runs into the limit."),
+    memoryBytes: z.number().describe("Memory in use, less the file cache the kernel takes back on demand: the figure that runs into the limit."),
     memoryLimitBytes: z.number().describe("The memory limit: the container's own, or the machine's memory when the container has none."),
     swapBytes: z.number().optional().describe("Memory pushed out to swap. Absent where the sandbox cannot see its own swap."),
     diskBytes: z.number().optional().describe("Space used on the volume the workspace lives on. Absent when the volume would not say."),
@@ -70,7 +68,9 @@ export const SandboxUsageSchema = z.object({
         .tuple([z.number(), z.number(), z.number()])
         .describe("The load average over 1, 5 and 15 minutes. It is the machine's, so other sandboxes on it count too."),
     processes: z.number().describe("How many processes are running in the sandbox."),
-    pressure: PressureMetricsSchema.optional().describe("How much work waited on CPU, memory or disk lately. Absent where the kernel does not report it."),
+    pressure: PressureMetricsSchema.optional().describe(
+        "How much work waited on CPU, memory or disk lately. Absent where the kernel does not report it.",
+    ),
 });
 export type SandboxUsage = z.infer<typeof SandboxUsageSchema>;
 
@@ -109,89 +109,58 @@ export type SandboxMetrics = z.infer<typeof SandboxMetricsSchema>;
 // What is filling the sandbox's disk, by what it is for (GET /system/storage). Sizes are apparent bytes, and a file
 // with several hard links counts once, toward the first place the scan met it.
 
-// Every category a byte on the sandbox's volumes can belong to; STORAGE_CLEANABILITY below says which may be cleaned.
-export const STORAGE_CATEGORIES = [
-    // The workspace's own files: repositories, their dependencies, anything the owner or an agent put there.
-    "workspace",
-    // Transcripts, runtime session stores, attachments and loop memory of every conversation, archived ones included.
-    "conversations",
-    // Each open conversation's own checkout of the repositories, and the dependencies its turns installed over them.
-    "checkouts",
-    // The minute-by-minute and per-turn snapshots the History timeline restores from.
-    "restorePoints",
-    // The repositories' own git data: every commit and branch, pushed or not.
-    "repositories",
-    // Installed versions of the agent runtimes: the one turns use and the one kept for Revert.
-    "engines",
-    // Search indexes and caches the sandbox keeps up to date by itself while it runs.
-    "indexes",
-    // Installed extensions and their scratch.
-    "extensions",
-    // The sandbox's own Docker: images, containers, volumes.
-    "docker",
-    // Settings, credentials, sign-ins and the ledgers of what was spent and done.
-    "state",
-    // Anything no part of the sandbox claims.
-    "other",
-    // Git data and checkouts of repositories deleted from the workspace.
-    "trash",
-    // Copies of the sandbox packed for download.
-    "exports",
-    // Files agents produced: generated images, reports, harness output.
-    "artifacts",
-    // Screenshots and page snapshots the agent's browser took.
-    "browserCaptures",
-    // The agent browser's profiles, with the sites it is signed in to.
-    "browserProfiles",
-    // Weights downloaded for local models.
-    "modelWeights",
-    // The sandbox's own logs and terminal captures.
-    "logs",
-    // Scratch space agents and checks leave behind.
-    "scratch",
-    // Package managers' content stores, which the next install refills.
-    "packageStores",
-    // Build tools' output caches.
-    "buildCaches",
-] as const;
-export const StorageCategoryIdSchema = z.enum(STORAGE_CATEGORIES);
-export type StorageCategoryId = z.infer<typeof StorageCategoryIdSchema>;
-
 // none: never removed from here; safe: comes back by itself, removed without asking; confirm: removed only once the
 // owner has read what it costs.
 export const StorageCleanabilitySchema = z.enum(["none", "safe", "confirm"]);
 export type StorageCleanability = z.infer<typeof StorageCleanabilitySchema>;
 
-// Which categories may be cleaned, and which ask first: the daemon's cleaner refuses by it, the editor words its
-// confirm by it. State, credentials and live work are `none`; what regenerates is `safe`; the owner's own data asks.
+// Every category a byte on the volumes can belong to, and its cleanability: the cleaner refuses by it, the editor words its confirm by it.
 export const STORAGE_CLEANABILITY = {
+    // The workspace's own files: repositories, their dependencies, anything the owner or an agent put there.
     workspace: "none",
+    // Transcripts, runtime session stores, attachments and loop memory of every conversation, archived ones included.
     conversations: "none",
-    // A live conversation's working copy; archiving the conversation is what frees it.
+    // Each open conversation's own checkout of the repositories and the dependencies its turns installed; archiving the conversation frees it.
     checkouts: "none",
-    // No compaction is safe to offer: `git gc --auto` already runs after every snapshot, and every object is reachable.
+    // Per-turn and minute-by-minute snapshots History restores from; no compaction to offer: `git gc --auto` runs after each, all is reachable.
     restorePoints: "none",
+    // The repositories' own git data: every commit and branch, pushed or not.
     repositories: "none",
-    // The Engines card keeps two versions and owns which is which; removing one here would strand its Revert.
+    // Installed agent runtimes, the one turns use and the one kept for Revert; the Engines card owns which is which, so removing one strands it.
     engines: "none",
-    // Held open by what maintains them: removing a file frees nothing until they close it.
+    // Search indexes and caches the sandbox keeps up to date while it runs, held open by it: removing a file frees nothing until it closes.
     indexes: "none",
+    // Installed extensions and their scratch.
     extensions: "none",
+    // The sandbox's own Docker: images, containers, volumes.
     docker: "none",
+    // Settings, credentials, sign-ins and the ledgers of what was spent and done.
     state: "none",
+    // Anything no part of the sandbox claims.
     other: "none",
-    // Nothing reads it again, but it may hold commits never pushed anywhere.
+    // Git data and checkouts of repositories deleted from the workspace; nothing reads it again, but it may hold commits never pushed.
     trash: "confirm",
+    // Copies of the sandbox packed for download.
     exports: "confirm",
+    // Files agents produced: generated images, reports, harness output.
     artifacts: "confirm",
+    // Screenshots and page snapshots the agent's browser took.
     browserCaptures: "confirm",
+    // The agent browser's profiles, with the sites it is signed in to.
     browserProfiles: "confirm",
+    // Weights downloaded for local models.
     modelWeights: "confirm",
+    // The sandbox's own logs and terminal captures.
     logs: "safe",
+    // Scratch space agents and checks leave behind.
     scratch: "safe",
+    // Package managers' content stores, which the next install refills.
     packageStores: "safe",
+    // Build tools' output caches.
     buildCaches: "safe",
-} as const satisfies Record<StorageCategoryId, StorageCleanability>;
+} as const satisfies Record<string, StorageCleanability>;
+export type StorageCategoryId = keyof typeof STORAGE_CLEANABILITY;
+export const StorageCategoryIdSchema = z.enum(Object.keys(STORAGE_CLEANABILITY) as StorageCategoryId[]);
 
 export const StorageItemSchema = z.object({
     path: z.string().describe("Where it is, as an absolute path inside the sandbox."),
@@ -245,11 +214,11 @@ export type StorageCleanInput = z.infer<typeof StorageCleanInputSchema>;
 
 export const StorageCleanResultSchema = z.object({
     category: StorageCategoryIdSchema,
-    freedBytes: z.number().describe("Space the removals gave back, in bytes. A file that is still linked elsewhere frees nothing and is not counted."),
-    removed: z.number().describe("How many items were removed."),
-    kept: z
+    freedBytes: z
         .number()
-        .describe("How many were left in place: changed too recently, in use by a running program, or no longer this category's."),
+        .describe("Space the removals gave back, in bytes. A file that is still linked elsewhere frees nothing and is not counted."),
+    removed: z.number().describe("How many items were removed."),
+    kept: z.number().describe("How many were left in place: changed too recently, in use by a running program, or no longer this category's."),
     failed: z.number().describe("How many removals the filesystem refused."),
 });
 export type StorageCleanResult = z.infer<typeof StorageCleanResultSchema>;

package/src/schemas/settings.test.ts

@@ -1,5 +1,4 @@
-import { describe, test, expect } from "bun:test";
-import { RuleSchema } from "./settings.js";
+import { RepoChecksFileSchema, RuleSchema, SandboxSettingsSchema } from "./settings.js";
 
 // A rule that saves cleanly and silently does nothing is the failure this schema exists to refuse: an action, and a
 // built-in's name, are checked against the moment they are written at.
@@ -12,14 +11,49 @@ describe(`which built-in stands at which moment`, () => {
         expect(rule(`turn.ending`, { kind: `builtin`, name: `version-landed` }).success).toBe(false);
     });
 
-    test(`the verifiers stand at the turn's end and not at the landing`, () => {
-        expect(rule(`turn.ending`, { kind: `builtin`, name: `verify-edits` }).success).toBe(true);
-        expect(rule(`agent.landed`, { kind: `builtin`, name: `verify-edits` }).success).toBe(false);
+    test(`the look stands at the turn's end and not at the landing`, () => {
+        expect(rule(`turn.ending`, { kind: `builtin`, name: `verify-ui-edits` }).success).toBe(true);
+        expect(rule(`agent.landed`, { kind: `builtin`, name: `verify-ui-edits` }).success).toBe(false);
     });
 
-    test(`the landed moment takes no verdict, command or instruction: the work is already in the tree`, () => {
+    test(`the landed moment takes no verdict and no command: the work is already in the tree`, () => {
         expect(rule(`agent.landed`, { kind: `verdict`, verdict: `allow` }).success).toBe(false);
         expect(rule(`agent.landed`, { kind: `command`, command: `pnpm test` }).success).toBe(false);
-        expect(rule(`agent.landed`, { kind: `instruct`, text: `well done` }).success).toBe(false);
+    });
+
+    test(`there is no push moment: the repository's own pre-push hook gates a push`, () => {
+        expect(rule(`push.starting`, { kind: `command`, command: `pnpm test` }).success).toBe(false);
+    });
+});
+
+describe(`where a command lives`, () => {
+    test(`settings refuse a command rule, since it belongs to the repository it checks`, () => {
+        const command = { id: `lint`, label: `lint`, moment: `file.edited`, action: { kind: `command`, command: `oxlint {file}` } };
+        expect(SandboxSettingsSchema.safeParse({ rules: [command] }).success).toBe(false);
+        const land = { id: `auto-land`, label: `land`, moment: `agent.finished`, action: { kind: `verdict`, verdict: `allow` } };
+        expect(SandboxSettingsSchema.safeParse({ rules: [land] }).success).toBe(true);
+    });
+
+    test(`a repository declares edit, turn and land checks, and no push check`, () => {
+        const file = (checks: unknown[]) => RepoChecksFileSchema.safeParse({ checks }).success;
+        expect(
+            file([
+                { when: `edit`, run: `lint {file}` },
+                { when: `turn`, run: `pnpm verify:turn` },
+                { when: `land`, run: `pnpm verify` },
+            ]),
+        ).toBe(true);
+        expect(file([{ when: `push`, run: `pnpm verify:push` }])).toBe(false);
+    });
+
+    test(`a land check is one per repository and narrows by no path`, () => {
+        const file = (checks: unknown[]) => RepoChecksFileSchema.safeParse({ checks }).success;
+        expect(
+            file([
+                { when: `land`, run: `pnpm verify` },
+                { when: `land`, run: `pnpm test` },
+            ]),
+        ).toBe(false);
+        expect(file([{ when: `land`, run: `pnpm verify`, paths: [`src/**`] }])).toBe(false);
     });
 });

package/src/schemas/settings.ts

@@ -13,39 +13,28 @@ 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"]) });
-// 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.
-
-// Five places the daemon already stops to decide something; this names those decisions rather than inventing new ones.
+// Rules: "at this moment, if this is true, do this". The owner's rules decide (land, hold, version) and switch the
+// daemon's built-in reviews; every command a moment runs is a repository's own check (`<repo>/.intentic/checks.json`),
+// compiled into this same table by the daemon, so no command lives in settings.
 export const RuleMomentSchema = z.enum([
     // A command here runs on the just-written file (`{file}` is its path); the cheapest moment to catch a defect.
     "file.edited",
     // The assistant is about to stop. A rule here can send it back to work, which is the only moment that can.
     "turn.ending",
-    // Code is about to leave the machine. A rule here gates the push on its own exit code.
-    "push.starting",
     // An agent's turn is over and its delta is sitting on its branch. A rule here decides whether it lands.
     "agent.finished",
     // An agent's delta has just reached the main tree. A rule here decides what becomes of it there.
     "agent.landed",
 ]);
 export type RuleMoment = z.infer<typeof RuleMomentSchema>;
-// What a rule does; the split is functional since the three settings this table replaces each needed a different shape.
-// command: runs a shell command; its exit code is the verdict.
-// instruct: says something to the assistant before it finishes.
-// verdict: allows or holds what is about to happen (a pass with nothing to run, told which way to go).
-// builtin: invokes a named daemon behaviour the table has no business expressing itself.
-// Each reads a record only the daemon keeps, which is what makes it a built-in rather than a command.
-// verify-edits: what a turn edited, against what it ran.
-// verify-removals: what a turn deleted, against the repo's own history (a `git log` question, not a shell one-liner).
+// command: a repository's check; its exit code is the verdict.
+// verdict: allows or holds what is about to happen.
+// builtin: a daemon behaviour that reads a record only the daemon keeps.
 // verify-ui-edits: rendered surfaces a turn changed, against whether it ever looked at one.
-// verify-tests: whether a touched test's assertions got weaker than at HEAD, or would have passed before its own
-// change.
 // version-landed: commits what a land brought, in the main tree, under the subject drafted for it, and the tree's own
 // remainder before the next isolated turn starts; the only way a person who never commits keeps every agent seeing
 // the latest tree, since worktrees are cut from HEAD.
-export const RuleBuiltinSchema = z.enum(["verify-edits", "verify-removals", "verify-ui-edits", "verify-tests", "version-landed"]);
+export const RuleBuiltinSchema = z.enum(["verify-ui-edits", "version-landed"]);
 export type RuleBuiltin = z.infer<typeof RuleBuiltinSchema>;
 export const RuleActionSchema = z.discriminatedUnion("kind", [
     z.object({
@@ -54,7 +43,6 @@ export const RuleActionSchema = z.discriminatedUnion("kind", [
         // Past this, the process group is killed and the run is `failed`, never a silent pass.
         timeoutMs: z.number().min(60_000).max(3_600_000).default(900_000),
     }),
-    z.object({ kind: z.literal("instruct"), text: z.string().min(1).max(4000) }),
     z.object({ kind: z.literal("verdict"), verdict: z.enum(["allow", "hold"]) }),
     z.object({ kind: z.literal("builtin"), name: RuleBuiltinSchema }),
 ]);
@@ -63,8 +51,7 @@ export type RuleAction = z.infer<typeof RuleActionSchema>;
 // defaults to HELD unless a rule explicitly allows it.
 export const RuleOutcomeSchema = z.enum(["clean", "error", "conflict", "checks-failed"]);
 export type RuleOutcome = z.infer<typeof RuleOutcomeSchema>;
-// Three keys covering "only this repo" and "skip docs-only changes" without a query language; every key absent means
-// the rule always matches.
+// Every key absent means the rule always matches.
 export const RuleConditionSchema = z.object({
     // A workspace repo id, or "root". Absent ⇒ any.
     repo: z.string().min(1).optional(),
@@ -80,15 +67,13 @@ export type RuleCondition = z.infer<typeof RuleConditionSchema>;
 // validated here, not left to the consumer — the alternative is a rule that saves cleanly and silently does nothing.
 const MOMENT_ACTIONS: Record<RuleMoment, readonly RuleAction["kind"][]> = {
     "file.edited": ["command"],
-    "turn.ending": ["builtin", "instruct", "command"],
-    "push.starting": ["command"],
+    "turn.ending": ["builtin", "command"],
     "agent.finished": ["verdict"],
     "agent.landed": ["builtin"],
 };
-// A built-in reads a record only one moment keeps, so it stands at that moment alone: the verifiers read a turn's
-// ledgers, the versioner reads a landing's claim.
+// A built-in reads a record only one moment keeps, so it stands at that moment alone.
 const MOMENT_BUILTINS: Partial<Record<RuleMoment, readonly RuleBuiltin[]>> = {
-    "turn.ending": ["verify-edits", "verify-removals", "verify-ui-edits", "verify-tests"],
+    "turn.ending": ["verify-ui-edits"],
     "agent.landed": ["version-landed"],
 };
 export const RuleSchema = z
@@ -429,14 +414,17 @@ export const SandboxSettingsSchema = z.object({
         .describe(
             "Which repositories may run the checks they declare for themselves, and exactly which version of those checks you agreed to. A repository's declaration does nothing until it appears here, the same rule git keeps for hooks, which are never cloned; and a declaration that changes afterwards is held until you look at it again.",
         ),
-    // Lives in the owner's own settings, not the workspace: a rule can hold work and gate a push, so it answers to the
-    // sandbox owner alone. A repository may declare a COMMAND of its own (see `adoptedChecks`), never a verdict.
+    // The owner's alone, since a rule can hold work. A command is refused here: it belongs to the repository it checks,
+    // in that repository's `.intentic/checks.json`, never in settings.
     rules: z
         .array(RuleSchema)
         .max(50)
         .default([])
+        .refine((rules) => rules.every((rule) => rule.action.kind !== "command"), {
+            message: "a command belongs in the repository's own .intentic/checks.json, not in settings",
+        })
         .describe(
-            "Standing instructions you give the sandbox about its own work: ask for proof before a turn ends, run something before a push, hold or release finished work. Empty is the default and is exactly the behaviour of a fresh sandbox, because each of those defaults is what no rule matched means at its own moment.",
+            "Standing decisions about the sandbox's own work: land or hold finished work, save a version of what landed, ask the assistant to look at an interface it changed. Empty is the default and is exactly the behaviour of a fresh sandbox, because each of those defaults is what no rule matched means at its own moment. A command to run is a repository's own check, declared in its .intentic/checks.json.",
         ),
     automationFailureLimit: z
         .number()
@@ -608,27 +596,23 @@ export type SavingsReport = z.infer<typeof SavingsReportSchema>;
 // spelling for the daemon that reads it, the screen that names it and the demo that mimics it.
 export const REPO_CHECKS_FILE = `${STATE_DIR}/checks.json`;
 
-// Named for the occasion as a repository would say it, not for the daemon's wire moment: `edit` is `file.edited`,
-// `turn` is `turn.ending` and `push` is `push.starting` (rules/repo-checks.ts maps them). Three, because these are the
-// occasions whose command a repository actually owns; a verdict moment has nothing here to express.
-//
-// `edit` is the cheapest of the three and the only one that reaches the model while it still holds the line it wrote:
-// the command runs on that one file (`{file}`), and its output rides back in the edit's own response. A repository
-// that declares a whole-tree command here pays it per edit, so the command has to take the file.
-export const RepoCheckMomentSchema = z.enum(["edit", "turn", "push"]);
+// Named for the occasion as a repository would say it: `edit` is `file.edited`, `turn` is `turn.ending`, and `land` is
+// the daemon's run over the main tree after an install a land caused (rules/repo-checks.ts maps them). A push is gated by
+// the repository's own git pre-push hook, which every push runs, the app's included.
+// `edit` runs on one file (`{file}`) and its output rides back in the edit's own response, so a command declared there is
+// paid per edit and has to take the file.
+export const RepoCheckMomentSchema = z.enum(["edit", "turn", "land"]);
 export type RepoCheckMoment = z.infer<typeof RepoCheckMomentSchema>;
 
 export const RepoCheckSchema = z.object({
     when: RepoCheckMomentSchema.describe(
-        "When to run it: `edit` on each file as it is written (`{file}` is its path), `turn` before the assistant finishes, `push` before code leaves the machine.",
+        "When to run it: `edit` on each file as it is written (`{file}` is its path), `turn` before the assistant finishes, `land` on the main tree after finished work lands (absent, the package's own verify or test script runs there).",
     ),
     run: z.string().min(1).max(500).describe("The command, run in this repository's own directory, so it reads as it would in a terminal there."),
     label: z.string().min(1).max(80).optional().describe("What to call it on screen. Absent names it after the command."),
-    // Same ceiling as a rule's own command; past it the process group is killed and the run is a failure, never a
-    // silent pass.
+    // Same ceiling as a rule's own command; past it the process group is killed and the run is a failure.
     timeoutMs: z.number().min(60_000).max(3_600_000).optional().describe("How long it may take before it is killed and counted as failed."),
-    // Repo-relative, as anybody reading this file would write them; the daemon prefixes the repo id before matching,
-    // since a rule's globs are workspace-relative.
+    // Repo-relative; the daemon prefixes the repo id before matching, since a rule's globs are workspace-relative.
     paths: z
         .array(z.string().min(1))
         .max(20)
@@ -638,7 +622,16 @@ export const RepoCheckSchema = z.object({
 export type RepoCheck = z.infer<typeof RepoCheckSchema>;
 
 // The file itself. One key, so a second concern can be added later without breaking a file anyone has written.
-export const RepoChecksFileSchema = z.object({ checks: z.array(RepoCheckSchema).max(10).default([]) });
+export const RepoChecksFileSchema = z.object({
+    checks: z
+        .array(RepoCheckSchema)
+        .max(10)
+        .default([])
+        // One land check per repository: it is THE verdict on the main tree the push hook replays, not one of several.
+        .refine((checks) => checks.filter((check) => check.when === "land").length <= 1, { message: "a repository declares at most one land check" })
+        // A land checks the whole tree an install settled, not a change, so there is nothing for a glob to narrow.
+        .refine((checks) => checks.every((check) => check.when !== "land" || check.paths === undefined), { message: "a land check takes no paths" }),
+});
 export type RepoChecksFile = z.infer<typeof RepoChecksFileSchema>;
 
 // One repository, as a screen reads it: what it declares, and where that stands with the owner.
@@ -646,6 +639,11 @@ export const RepoChecksSummarySchema = z.object({
     repo: z.string().describe('Which repository, by its workspace id ("root" is the workspace itself).'),
     path: z.string().describe("Where the declaration lives, relative to the workspace, whether or not the file exists yet."),
     checks: z.array(RepoCheckSchema).describe("What it declares, in the order the file lists them."),
+    fired: z
+        .array(z.number().nullable())
+        .describe(
+            "When each declared check last reported something, in the file's order, as epoch milliseconds; null for one that never has, or for the land check, whose verdict the activity feed records instead.",
+        ),
     adopted: z
         .boolean()
         .describe("Whether these are running. False means declared and inert: nothing a repository writes runs until the owner switches it on."),
@@ -655,10 +653,16 @@ export const RepoChecksSummarySchema = z.object({
             "Whether the declaration changed since it was adopted, which holds it until the owner looks again. True only for a repository that was adopted before.",
         ),
     error: z.string().optional().describe("Why the file could not be read, when it exists but does not parse. The checks list is empty in that case."),
+    landDefault: z
+        .string()
+        .optional()
+        .describe(
+            "What runs on the main tree after a land when the file declares no `land` check: the package's own verify or test script. Absent when the repository has neither.",
+        ),
 });
 export type RepoChecksSummary = z.infer<typeof RepoChecksSummarySchema>;
 export const RepoChecksListSchema = z.object({
-    repos: z.array(RepoChecksSummarySchema).describe("Every repository that declares checks, plus any the owner has adopted before, sorted by id."),
+    repos: z.array(RepoChecksSummarySchema).describe("Every repository that declares checks or has a package check that runs after a land, in id order."),
 });
 export type RepoChecksList = z.infer<typeof RepoChecksListSchema>;
 export const RepoChecksAdoptSchema = z.object({

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

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

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

@@ -1,7 +1,6 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { packageRoot } from "@intentic/constants/node";
-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.

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

@@ -1,4 +1,3 @@
-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";

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

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { fixStance } from "./fix-stance.js";
 import type { AgentSummary } from "../schemas/agents.js";
 

package/src/state/landed-commit.test.ts

@@ -1,4 +1,3 @@
-import { expect, test } from "bun:test";
 import { declaredTestNote, landedCommitMessage } from "./landed-commit.js";
 
 // The push gate reads a weakening's declaration off the commit (assertion-ratchet.mjs), so the trailer must survive

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

@@ -1,4 +1,3 @@
-import { describe, it, expect } from "bun:test";
 import { RUNTIME_DOMAIN_BINDINGS, staleRuntimeQueryKeys } from "./runtime-state.js";
 
 describe(`staleRuntimeQueryKeys`, () => {

package/src/state/versions.test.ts

@@ -1,4 +1,3 @@
-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,5 @@
 import { STATE_DIR } from "@intentic/constants";
 import type { FileContribution } from "@intentic/extension-manifest";
-import { describe, it, expect } from "bun:test";
 import {
     BACKED_UP_STATE_PATHS,
     isLockedWorkspacePath,
@@ -346,8 +345,6 @@ describe(`VERSIONED_STATE_PATHS`, () => {
             // Which commands count as heavy, and how many may run at once; a shared-box decision worth a `git log`
             // line.
             `${STATE_DIR}/config/heavy-commands.json`,
-            // The exclude list carves entries out by name; an unlisted directory is invisible to git and to land.
-            `${STATE_DIR}/config/hooks/`,
             `${STATE_DIR}/config/loop-designs.json`,
             `${STATE_DIR}/config/personas.json`,
             // A persona's prompt and reachable skills: the text that decides how it behaves, same reason as its card.

package/src/state/workspace-state.ts

@@ -120,20 +120,6 @@ const STATE_FILES = [
     // Bash command. `carry`: a property of the workspace, not the machine. `versioned`: raising the limit is a decision
     // worth a diff.
     { path: ".intentic/config/heavy-commands.json", invalidates: ["settings"], portability: "carry", versioned: true },
-    // Scripts the rule table runs, one per reader (settings.json points at them per event, e.g. `file.edited`).
-    // `versioned`: this is code that runs against every file an agent writes, more consequential than the rule naming
-    // it. `carry`: authored text, no credential. Invalidates nothing: the settings screen renders the rules from
-    // settings.json, not these scripts.
-    {
-        path: ".intentic/config/hooks/",
-        invalidates: [],
-        why: "The settings screen renders the rules that name these scripts, out of settings.json; nothing in the browser reads the scripts themselves.",
-        portability: "carry",
-        versioned: true,
-        // The daemon only runs these scripts by path; it never builds them, so there's no `statePath` call for the
-        // coverage guard to find.
-        outsideWriter: "the owner or an agent, authoring them; the daemon only ever RUNS one, by the path a rule's command names",
-    },
     // Last-fired stamps for the rule table. `derived`: records what happened on this machine, not carried.
     {
         path: ".intentic/local/rule-firings.json",

package/src/text/archives.test.ts

@@ -1,4 +1,3 @@
-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,3 @@
-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/embed.test.ts

@@ -1,5 +1,4 @@
 import { webcrypto } from "node:crypto";
-import { test, expect, beforeAll, mock } from "bun:test";
 import { stubGlobal, unstubAllGlobals } from "@intentic/testing/bun";
 import { EmbedError, embedFailure, embedUrl, fetchEmbedJson, solveProofOfWork } from "./embed.js";
 
@@ -40,12 +39,12 @@ 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 () => {
     stubGlobal(
         "fetch",
-        mock(async () => new Response(JSON.stringify({ ok: true }), { status: 200 })),
+        jest.fn(async () => new Response(JSON.stringify({ ok: true }), { status: 200 })),
     );
     expect(await fetchEmbedJson<{ ok: boolean }>("https://x/y")).toEqual({ ok: true });
     stubGlobal(
         "fetch",
-        mock(async () => new Response(JSON.stringify({ error: "rate limited" }), { status: 429 })),
+        jest.fn(async () => new Response(JSON.stringify({ error: "rate limited" }), { status: 429 })),
     );
     await expect(fetchEmbedJson("https://x/y")).rejects.toMatchObject({ message: "rate limited", status: 429 });
     unstubAllGlobals();

package/src/text/emoji.test.ts

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

package/src/text/mentions.test.ts

@@ -1,4 +1,3 @@
-import { describe, it, expect } from "bun:test";
 import { AgentTurnSchema } from "../schemas/agent.js";
 import { MENTION_LIMIT, mentionedPathTokens, mentionPaths } from "./mentions.js";
 

package/src/text/path-refs.test.ts

@@ -1,4 +1,3 @@
-import { describe, test, expect } from "bun:test";
 import { isTestPath, rankRefCandidates, referenceTails } from "./path-refs.js";
 
 describe("referenceTails", () => {

package/src/text/title.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { AgentTurnSchema } from "../schemas/agent.js";
 import { deriveTitle } from "./title.js";
 

package/src/text/transcript-fold.test.ts

@@ -1,5 +1,4 @@
 import { STATE_DIR } from "@intentic/constants";
-import { describe, it, expect } from "bun:test";
 import type { AgentEvent } from "../events/agent-events.js";
 import type { TranscriptPatch, TranscriptRow } from "../events/transcript.js";
 import { watchWakePrompt } from "../events/watch-wake.js";
@@ -213,9 +212,19 @@ describe("foldTurn", () => {
         });
         // An outage nobody armed says so, instead of promising the breaker's retry.
         const unarmed: AgentEvent[] = [
-            { kind: "error", code: "provider-outage", message: "Anthropic is down.", autoResume: "available", outage: { retryAt: 1 }, retries: { made: 0, max: 6 } },
+            {
+                kind: "error",
+                code: "provider-outage",
+                message: "Anthropic is down.",
+                autoResume: "available",
+                outage: { retryAt: 1 },
+                retries: { made: 0, max: 6 },
+            },
         ];
-        expect(foldOf("hi", unarmed).at(-1)).toEqual({ role: "notice", text: "Anthropic is down. Nothing is retrying it, so the turn is waiting here." });
+        expect(foldOf("hi", unarmed).at(-1)).toEqual({
+            role: "notice",
+            text: "Anthropic is down. Nothing is retrying it, so the turn is waiting here.",
+        });
     });
 
     it("writes the turn's own events down as notices", () => {

package/src/text/whisper.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { cleanTranscription } from "./whisper.js";
 
 test("flattens whisper output onto one line", () => {

package/src/text/workflow-faults.test.ts

@@ -1,4 +1,3 @@
-import { test, expect } from "bun:test";
 import { type Workflow, WorkflowSchema, type WorkflowStep } from "../schemas/workflows.js";
 import { workflowFaults, workflowRunFaults } from "./workflow-faults.js";
 

package/src/time/zone.test.ts

@@ -1,4 +1,3 @@
-import { describe, test, expect } from "bun:test";
 import { asCivilDay, asZone, civilDayIn, cronOptions, isZone, sameClock, utcDayOf, UTC, zoneLabel } from "./zone.js";
 import type { Zone } from "./zone.js";