@mycadet/assistant 0.12.6-dev.202610091338.ee7f3e3 → 0.12.7

package/README.md

@@ -70,9 +70,9 @@ bun run src/index.ts                # interactive CLI session
 
 | Command                                                    | Description                                      |
 | ---------------------------------------------------------- | ------------------------------------------------ |
-| `cadet wake`                                              | Start assistant + gateway from current checkout  |
-| `cadet sleep`                                             | Stop assistant + gateway processes               |
-| `cadet ps`                                                | List assistants and per-assistant process status |
+| `cadet wake`                                               | Start assistant + gateway from current checkout  |
+| `cadet sleep`                                              | Stop assistant + gateway processes               |
+| `cadet ps`                                                 | List assistants and per-assistant process status |
 | `assistant`                                                | Launch interactive CLI session                   |
 | `assistant conversations list\|search\|new\|export\|clear` | Manage conversations                             |
 | `assistant config set\|get\|list`                          | Manage configuration                             |

package/docs/runbook-trusted-contacts.md

@@ -4,10 +4,10 @@ Operational procedures for inspecting, managing, and debugging the trusted conta
 
 Two databases hold this state — pick the right one before reaching for SQL:
 
-| Data                                                                                                                                                                                          | Database                      | Location                                                                                                                |
-| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| Data                                                                                                                                                                                          | Database                      | Location                                                                                                               |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
 | Contact ACL (`contacts` role, `contact_channels` status/policy/reasons), guardian requests (`guardian_requests` + `guardian_request_deliveries`), verification sessions, rate limits, invites | Gateway DB (`gateway.sqlite`) | `$GATEWAY_SECURITY_DIR/gateway.sqlite` (Docker: the `/gateway-security` volume; local fallback: `~/.cadet/protected/`) |
-| Notification pipeline, contact info/identity mirror                                                                                                                                           | Assistant DB (`assistant.db`) | `$CADET_WORKSPACE_DIR/data/db/assistant.db` (local fallback: `~/.cadet/workspace/`)                                   |
+| Notification pipeline, contact info/identity mirror                                                                                                                                           | Assistant DB (`assistant.db`) | `$CADET_WORKSPACE_DIR/data/db/assistant.db` (local fallback: `~/.cadet/workspace/`)                                    |
 
 Prefer the CLI and HTTP surfaces below over raw SQL — they go through the gateway's validation (status vocabulary, revoke-of-blocked guard) and emit the change events clients rely on. Raw SQL is break-glass only.
 

package/docs/skills.md

@@ -116,10 +116,10 @@ Acceptance is idempotent and recorded in `trust.json`. The bundle does not inclu
 
 Tools can execute in two contexts:
 
-| Target    | Description                                                                              |
-| --------- | ---------------------------------------------------------------------------------------- |
+| Target    | Description                                                                             |
+| --------- | --------------------------------------------------------------------------------------- |
 | `sandbox` | Isolated execution within `$CADET_WORKSPACE_DIR` (Docker container or OS-level sandbox) |
-| `host`    | Direct execution on the host machine                                                     |
+| `host`    | Direct execution on the host machine                                                    |
 
 Trust rules can include an `executionTarget` field to bind the rule to a specific context. A rule without `executionTarget` matches both sandbox and host invocations.
 

package/docs/trusted-contact-access.md

@@ -9,7 +9,7 @@ Design doc defining how unknown users gain access to a Cadet assistant via chann
 | `guardian`        | The verified owner/administrator of the assistant on a given channel. Has a record in the gateway DB `contacts` table with `role: 'guardian'` and an active `contact_channels` entry. Approves or denies access requests.                                                                                                                    |
 | `trusted_contact` | An external user who has completed the verification flow and holds a gateway `contact_channels` record with `status: 'active'` and `policy: 'allow'`.                                                                                                                                                                                        |
 | `gateway`         | The ACL and verification engine. Owns the contact ACL, guardian requests + their delivery records, verification sessions, rate limits, secret minting, code interception, and the validate+consume decision. Commits every guardian decision (status CAS + ACL outcome) in one transaction. Stamps a trust verdict on every inbound message. |
-| `assistant`       | The Cadet assistant daemon. Orchestrates the approval workflow around the gateway-owned requests: guardian notification, message composition, channel delivery, and post-decision side effects (cards, notices, grant minting). It never mints or validates verification secrets.                                                           |
+| `assistant`       | The Cadet assistant daemon. Orchestrates the approval workflow around the gateway-owned requests: guardian notification, message composition, channel delivery, and post-decision side effects (cards, notices, grant minting). It never mints or validates verification secrets.                                                            |
 
 ## Data Ownership
 
@@ -84,7 +84,7 @@ Identity binding ensures the verification code can only be consumed by the inten
 | Store                                                                                                 | Table                                      | Record                                                                                                                                                                                                                                                                   |
 | ----------------------------------------------------------------------------------------------------- | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | gateway `guardian-request-store.ts` (via the daemon's `channels/gateway-guardian-requests.ts` client) | `guardian_requests` (gateway DB)           | `status: 'pending'`, `kind: 'access_request'`, `toolName: 'ingress_access_request'`, `requesterExternalUserId`, `requesterChatId`, `guardianExternalUserId`/`guardianPrincipalId` (anchored resolution), `requestCode`, `expiresAt` (GUARDIAN_APPROVAL_TTL_MS from now). |
-| `guardian-delivery-recorder.ts` (single write sink, relays to the gateway)                            | `guardian_request_deliveries` (gateway DB) | Per-surface approval-card delivery records (cadet, Telegram, Slack).                                                                                                                                                                                                    |
+| `guardian-delivery-recorder.ts` (single write sink, relays to the gateway)                            | `guardian_request_deliveries` (gateway DB) | Per-surface approval-card delivery records (cadet, Telegram, Slack).                                                                                                                                                                                                     |
 | notification pipeline (assistant DB)                                                                  | `notification_events`                      | Event with `sourceEventName: 'ingress.access_request'`, deduped via `dedupeKey`.                                                                                                                                                                                         |
 | notification pipeline (assistant DB)                                                                  | `notification_decisions`                   | Decision engine output: `shouldNotify`, `selectedChannels`, `confidence`, reasoning.                                                                                                                                                                                     |
 | notification pipeline (assistant DB)                                                                  | `notification_deliveries`                  | Per-channel delivery records, linked via `notificationDecisionId`.                                                                                                                                                                                                       |

package/eslint.config.mjs

@@ -35,6 +35,21 @@ const eslintConfig = defineConfig([
         { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
       ],
       "@typescript-eslint/no-explicit-any": "error",
+      // Flag `mock.module` at warning level: the lint script pins
+      // --max-warnings to the current count and each PR chips away at it
+      // (same countdown the cli uses for `as` casts). Prefer running the
+      // test on the real backend behind a seam — e.g. the memory-backed
+      // helpers in src/__tests__/helpers/secure-keys.ts — instead of
+      // masking module state.
+      "no-restricted-syntax": [
+        "warn",
+        {
+          selector:
+            "CallExpression[callee.object.name='mock'][callee.property.name='module']",
+          message:
+            "mock.module masks module state across tests; run on the real backend behind a seam instead. Remaining uses are being counted down — do not add new ones.",
+        },
+      ],
     },
   },
   {

package/knip.json

@@ -11,14 +11,8 @@
     "src/api/index.ts!",
     "src/config/bundled-skills/**/tools/**/*.ts!"
   ],
-  "project": [
-    "src/**/*.ts!",
-    "src/**/*.tsx!",
-    "scripts/**/*.ts"
-  ],
-  "ignore": [
-    "src/config/preloaded-apps/**"
-  ],
+  "project": ["src/**/*.ts!", "src/**/*.tsx!", "scripts/**/*.ts"],
+  "ignore": ["src/config/preloaded-apps/**"],
   "ignoreDependencies": [
     "@microsoft/api-extractor",
     "@mycadet/app-icons",

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Cadet Assistant API
-  version: 0.12.6
+  version: 0.12.7
   description: Auto-generated OpenAPI specification for the Cadet Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821
@@ -5659,9 +5659,9 @@ paths:
       operationId: config_llm_defaultprovider_get
       summary: Get the default provider and its availability
       description:
-        Returns `llm.defaultProvider`, the connection name it resolves to, and whether that connection is currently
-        usable (connection exists, credential stored, Cadet authenticated). Availability is informational — a broken
-        default is a valid persisted state that surfaces explainable errors at resolution time.
+        Returns the default provider stored in `llm.default`, the connection name it resolves to, and whether that
+        connection is currently usable (connection exists, credential stored, Cadet authenticated). Availability is
+        informational — a broken default is a valid persisted state that surfaces explainable errors at resolution time.
       tags:
         - config
       responses:
@@ -5675,9 +5675,9 @@ paths:
       operationId: config_llm_defaultprovider_put
       summary: Set the default provider
       description:
-        Replaces `llm.defaultProvider`. Strict-validates the body (unlike the generic config write paths, which
-        silently drop invalid values). Does not require the referenced connection to exist — a dangling name is allowed
-        by design and reported via the availability status.
+        Replaces the default provider stored in the `llm.default` blob. Strict-validates the body (unlike the
+        generic config write paths, which silently drop or clamp invalid values). Does not require the referenced
+        connection to exist — a dangling name is allowed by design and reported via the availability status.
       tags:
         - config
       requestBody:
@@ -39199,6 +39199,9 @@ components:
           type: object
           properties:
             autoArchive:
+              default:
+                enabled: false
+                afterDays: 7
               type: object
               properties:
                 enabled:
@@ -39358,6 +39361,7 @@ components:
                   type: boolean
                 provider_connection:
                   type: string
+                  minLength: 1
               additionalProperties: false
             defaultProvider:
               type: object

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycadet/assistant",
-  "version": "0.12.6-dev.202610091338.ee7f3e3",
+  "version": "0.12.7",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -20,7 +20,7 @@
     "probe:skill-retrieval": "bun run scripts/probe-skill-retrieval.ts",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "lint": "bun run lint:skills && bun run lint:openapi && eslint",
+    "lint": "bun run lint:skills && bun run lint:openapi && eslint --max-warnings 3033",
     "lint:unused": "knip --include files,dependencies,unlisted",
     "lint:circular": "bun run scripts/check-circular-deps.ts",
     "lint:unused:production": "knip --production --include exports",

package/scripts/run-tests.ts

@@ -84,5 +84,8 @@ await runIsolatedTests({
   bunTestArgs: EXCLUDE_EXPERIMENTAL
     ? ["--test-name-pattern", "^(?!.*\\[experimental\\])"]
     : [],
-  fixture: { script: "scripts/build-test-fixtures.ts", envVar: "CADET_TEST_FIXTURES_DIR" },
+  fixture: {
+    script: "scripts/build-test-fixtures.ts",
+    envVar: "CADET_TEST_FIXTURES_DIR",
+  },
 });

package/src/__tests__/app-builder-tool-scripts.test.ts

@@ -2,43 +2,9 @@ import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { describe, expect, mock, test } from "bun:test";
 
-import type { AppDefinition } from "../apps/app-store.js";
-import type { AppStore } from "../tools/apps/executors.js";
+import { initializeDb } from "../persistence/db-init.js";
 import type { ToolContext } from "../tools/types.js";
-
-// ---------------------------------------------------------------------------
-// Mock factory helpers
-// ---------------------------------------------------------------------------
-
-function makeApp(overrides: Partial<AppDefinition> = {}): AppDefinition {
-  return {
-    id: "app-1",
-    name: "Test App",
-    description: "A test app",
-    schemaJson: "{}",
-    htmlDefinition: "<h1>Hi</h1>",
-    createdAt: 1000,
-    updatedAt: 2000,
-    ...overrides,
-  };
-}
-
-function makeMockStore(overrides: Partial<AppStore> = {}): AppStore {
-  const files = new Set<string>();
-  return {
-    getApp: () => makeApp(),
-    listApps: () => [makeApp()],
-    appFileExists: (_appId: string, path: string) => files.has(path),
-    createApp: (params) =>
-      makeApp({ name: params.name, description: params.description }),
-    updateApp: (id, updates) => makeApp({ id, ...updates }),
-    deleteApp: () => {},
-    writeAppFile: (_appId: string, path: string) => {
-      files.add(path);
-    },
-    ...overrides,
-  };
-}
+import { seedApp } from "./helpers/seed-app.js";
 
 function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
   return {
@@ -50,25 +16,15 @@ function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
 }
 
 // ---------------------------------------------------------------------------
-// Mock the app-store module so that skill scripts import our controllable store
+// The skill scripts pass the REAL app-store module to the executors, so the
+// store runs on the per-process test workspace. `app-1` is re-seeded before
+// each test (the app-delete test really deletes it); per-conversation lookups
+// go through real rows seeded with conversationIds.
 // ---------------------------------------------------------------------------
 
-const mockStore = makeMockStore();
-
-// Mutable per-conversation app list backing `listAppsByConversation`, which
-// `resolveAppId` consults when a tool's app_id is omitted. Tests set it directly.
-let appsByConversation: AppDefinition[] = [];
-
-mock.module("../apps/app-store.js", () => ({
-  ...mockStore,
-  listAppsByConversation: (_conversationId: string) => appsByConversation,
-  getAppsDir: () => "/tmp/test-apps",
-  getAppDirPath: (appId: string) => `/tmp/test-apps/${appId}`,
-  resolveAppDir: (id: string) => ({
-    dirName: id,
-    appDir: `/tmp/test-apps/${id}`,
-  }),
-}));
+beforeAll(async () => {
+  await initializeDb();
+});
 
 // Mock compileApp for multifile scaffold path
 mock.module("../bundler/app-compiler.js", () => ({
@@ -84,6 +40,8 @@ mock.module("../bundler/app-compiler.js", () => ({
 // Import skill scripts (after mocking)
 // ---------------------------------------------------------------------------
 
+import { beforeAll, beforeEach } from "bun:test";
+
 import * as appCreateScript from "../config/bundled-skills/app-builder/tools/app-create.js";
 import * as appDeleteScript from "../config/bundled-skills/app-builder/tools/app-delete.js";
 import * as appOpenScript from "../config/bundled-skills/app-builder/tools/app-open.js";
@@ -95,6 +53,10 @@ import * as appUpdateScript from "../config/bundled-skills/app-builder/tools/app
 // ---------------------------------------------------------------------------
 
 describe("app-builder skill tool scripts", () => {
+  beforeEach(() => {
+    seedApp({ id: "app-1", name: "Test App", description: "A test app" });
+  });
+
   // ---- app-create --------------------------------------------------------
 
   describe("app-create", () => {
@@ -208,7 +170,11 @@ describe("app-builder skill tool scripts", () => {
     });
 
     test("resolves the active app when app_id is omitted", async () => {
-      appsByConversation = [makeApp({ id: "active-app" })];
+      seedApp({
+        id: "active-app",
+        name: "active-app",
+        conversationIds: ["conv-open-1"],
+      });
       const calls: Array<{ name: string; input: Record<string, unknown> }> = [];
       const proxy: ToolContext["proxyToolResolver"] = async (name, input) => {
         calls.push({ name, input });
@@ -217,7 +183,10 @@ describe("app-builder skill tool scripts", () => {
 
       const result = await appOpenScript.run(
         {},
-        makeContext({ proxyToolResolver: proxy }),
+        makeContext({
+          conversationId: "conv-open-1",
+          proxyToolResolver: proxy,
+        }),
       );
 
       expect(result.isError).toBe(false);
@@ -227,7 +196,6 @@ describe("app-builder skill tool scripts", () => {
     });
 
     test("forwards an explicit app_id unchanged", async () => {
-      appsByConversation = [makeApp({ id: "active-app" })];
       const calls: Array<{ input: Record<string, unknown> }> = [];
       const proxy: ToolContext["proxyToolResolver"] = async (_name, input) => {
         calls.push({ input });
@@ -243,7 +211,6 @@ describe("app-builder skill tool scripts", () => {
     });
 
     test("errors when app_id is omitted and no active app exists", async () => {
-      appsByConversation = [];
       const proxy: ToolContext["proxyToolResolver"] = async () => ({
         content: "opened",
         isError: false,
@@ -251,7 +218,10 @@ describe("app-builder skill tool scripts", () => {
 
       const result = await appOpenScript.run(
         {},
-        makeContext({ proxyToolResolver: proxy }),
+        makeContext({
+          conversationId: "conv-open-none",
+          proxyToolResolver: proxy,
+        }),
       );
 
       expect(result.isError).toBe(true);
@@ -259,10 +229,14 @@ describe("app-builder skill tool scripts", () => {
     });
 
     test("errors when no client proxy resolver is available", async () => {
-      appsByConversation = [makeApp({ id: "active-app" })];
+      seedApp({
+        id: "active-app",
+        name: "active-app",
+        conversationIds: ["conv-open-noproxy"],
+      });
       const result = await appOpenScript.run(
         { app_id: "app-1" },
-        makeContext(),
+        makeContext({ conversationId: "conv-open-noproxy" }),
       );
 
       expect(result.isError).toBe(true);

package/src/__tests__/app-bundler.test.ts

@@ -6,22 +6,14 @@ import {
   writeFileSync,
 } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
 
 import JSZip from "jszip";
 
-// Temp directory for fake app data used in packageApp tests
-const testAppsDir = join(tmpdir(), `app-bundler-test-${Date.now()}`);
-
-// Mock app-store so packageApp can find our test apps
-const mockApps = new Map<string, Record<string, unknown>>();
-mock.module("../apps/app-store.js", () => ({
-  getApp: (id: string) => mockApps.get(id) ?? null,
-  getAppsDir: () => testAppsDir,
-  getAppDirPath: (id: string) => join(testAppsDir, id),
-}));
+// Real apps dir inside the per-process test workspace; packageApp tests
+// write the store's on-disk format (<id>.json + <id>/src) directly.
+let testAppsDir: string;
 
 // Mock content-id to avoid pulling in crypto internals
 mock.module("../util/content-id.js", () => ({
@@ -79,6 +71,7 @@ mock.module("./bundle-signer.js", () => ({
   signBundle: async () => ({}),
 }));
 
+import { getAppsDir } from "../apps/app-store.js";
 import { packageApp } from "../bundler/app-bundler.js";
 import type { AppManifest } from "../bundler/manifest.js";
 
@@ -87,9 +80,12 @@ import type { AppManifest } from "../bundler/manifest.js";
 // ---------------------------------------------------------------------------
 
 describe("packageApp", () => {
+  beforeAll(() => {
+    testAppsDir = getAppsDir();
+  });
+
   afterEach(() => {
     compileAppOverride = undefined;
-    mockApps.clear();
     try {
       rmSync(testAppsDir, { recursive: true, force: true });
     } catch {
@@ -133,7 +129,6 @@ describe("packageApp", () => {
       formatVersion: 2,
     };
     writeFileSync(join(testAppsDir, `${appId}.json`), JSON.stringify(appDef));
-    mockApps.set(appId, appDef);
 
     return appDef;
   }
@@ -156,7 +151,6 @@ describe("packageApp", () => {
       updatedAt: Date.now(),
     };
     writeFileSync(join(testAppsDir, `${appId}.json`), JSON.stringify(appDef));
-    mockApps.set(appId, appDef);
 
     return appDef;
   }
@@ -238,7 +232,6 @@ describe("packageApp", () => {
       formatVersion: 2,
     };
     writeFileSync(join(testAppsDir, `${appId}.json`), JSON.stringify(appDef));
-    mockApps.set(appId, appDef);
 
     await expect(packageApp(appId)).rejects.toThrow(
       /Compilation failed for app "Broken App"/,
@@ -264,7 +257,6 @@ describe("packageApp", () => {
       formatVersion: 2,
     };
     writeFileSync(join(testAppsDir, `${appId}.json`), JSON.stringify(appDef));
-    mockApps.set(appId, appDef);
 
     await expect(packageApp(appId)).rejects.toThrow(
       /missing src\/index\.html and src\/main\.tsx/,
@@ -302,7 +294,6 @@ render(<App />, document.getElementById('app')!);
       formatVersion: 2,
     };
     writeFileSync(join(testAppsDir, `${appId}.json`), JSON.stringify(appDef));
-    mockApps.set(appId, appDef);
 
     await expect(packageApp(appId)).rejects.toThrow(
       /still has the default src\/main\.tsx scaffold/,

package/src/__tests__/app-routes-csp.test.ts

@@ -1,71 +1,30 @@
-import { describe, expect, mock, test } from "bun:test";
-
-// Fake app records keyed by ID
-const compiledApp = {
-  id: "app-1",
-  name: "Compiled App",
-  htmlDefinition: "",
-  schemaJson: "{}",
-  createdAt: 0,
-  updatedAt: 0,
-  formatVersion: 2,
-};
-
-const legacyApp = {
-  id: "legacy-1",
-  name: "Legacy App",
-  htmlDefinition: "<div>Hello</div>",
-  schemaJson: "{}",
-  createdAt: 0,
-  updatedAt: 0,
-};
-
-const apps = new Map<string, typeof compiledApp | typeof legacyApp>([
-  ["app-1", compiledApp],
-  ["legacy-1", legacyApp],
-]);
-
-const UNSUPPORTED_HTML = `<p>This app uses the retired single-file format and can no longer be opened.</p>`;
-
-mock.module("../apps/app-store.js", () => ({
-  resolveAppSource: (id: string) => {
-    const app = apps.get(id);
-    if (!app) {
-      return null;
-    }
-    return {
-      id,
-      name: app.name,
-      dirName: id,
-      sourceDir: `/fake/apps/${id}`,
-      origin: { kind: "workspace" as const },
-    };
-  },
-  readAppFileBytesFromDir: () => Buffer.from(""),
-  // Only the legacy app's directory has a root index.html and no src/.
-  isLegacySingleFileDir: (sourceDir: string) =>
-    sourceDir === "/fake/apps/legacy-1",
-  UNSUPPORTED_LEGACY_APP_HTML: UNSUPPORTED_HTML,
-}));
-
-// Mock shared-app-links-store (imported by app-routes but unused here)
-mock.module("../apps/shared-app-links-store.js", () => ({
-  createSharedAppLink: () => ({ shareToken: "tok" }),
-  getSharedAppLink: () => null,
-  incrementDownloadCount: () => {},
-  deleteSharedAppLinkByToken: () => false,
-}));
-
-// Stub fs so the serve path finds a fake dist/index.html for the compiled app
-mock.module("node:fs", () => ({
-  existsSync: (p: string) => p === "/fake/apps/app-1/dist/index.html",
-  readFileSync: (p: string, _enc?: string) => {
-    if (p === "/fake/apps/app-1/dist/index.html") {
-      return '<!DOCTYPE html><html><head></head><body><script src="main.js"></script></body></html>';
-    }
-    return "";
-  },
-}));
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeAll, describe, expect, test } from "bun:test";
+
+import {
+  getAppDirPath,
+  UNSUPPORTED_LEGACY_APP_HTML,
+} from "../apps/app-store.js";
+import { seedApp } from "./helpers/seed-app.js";
+
+beforeAll(() => {
+  // Real store rows written in the on-disk format. The compiled app carries
+  // a dist/index.html; the legacy app has only a root index.html and no src/.
+  seedApp({ id: "app-1", name: "Compiled App", schemaJson: "{}" });
+  const appDir = getAppDirPath("app-1");
+  mkdirSync(join(appDir, "dist"), { recursive: true });
+  writeFileSync(
+    join(appDir, "dist", "index.html"),
+    '<!DOCTYPE html><html><head></head><body><script src="main.js"></script></body></html>',
+  );
+  seedApp({
+    id: "legacy-1",
+    name: "Legacy App",
+    htmlDefinition: "<div>Hello</div>",
+    schemaJson: "{}",
+  });
+});
 
 import { ROUTES } from "../runtime/routes/app-routes.js";
 import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
@@ -155,7 +114,7 @@ describe("handleServePage", () => {
 
   test("serves the unsupported-format message for legacy single-file apps", () => {
     const html = pageHandler({ pathParams: { appId: "legacy-1" } }) as string;
-    expect(html).toContain(UNSUPPORTED_HTML);
+    expect(html).toContain(UNSUPPORTED_LEGACY_APP_HTML);
     expect(html).not.toContain("<div>Hello</div>");
   });
 

package/src/__tests__/approval-cascade.test.ts

@@ -6,8 +6,6 @@
  */
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { Minimatch } from "minimatch";
-
 import { CompactionCircuit } from "../agent/compaction-circuit.js";
 import type { AgentEvent } from "../agent/loop.js";
 import type { ConfirmationStateChangedEvent } from "../api/events/confirmation-state-changed.js";
@@ -38,26 +36,6 @@ mock.module("../config/skill-state.js", () => ({
   resolveSkillStates: () => [],
 }));
 
-// Trust store mock — uses real minimatch for patternMatchesCandidate so the
-// mock doesn't break trust-store-pattern-matches.test.ts when both files run
-// in the same Bun process (mock.module leaks across test files).
-mock.module("../permissions/trust-store.js", () => ({
-  addRule: () => {},
-  findHighestPriorityRule: () => null,
-  clearCache: () => {},
-  patternMatchesCandidate: (pattern: string, candidate: string): boolean => {
-    try {
-      return new Minimatch(pattern).match(candidate);
-    } catch {
-      return false;
-    }
-  },
-}));
-
-mock.module("../security/secret-allowlist.js", () => ({
-  resetAllowlist: () => {},
-}));
-
 mock.module("../persistence/conversation-crud.js", () => ({
   setConversationProcessingStartedAt: () => {},
   isConversationProcessing: () => false,

package/src/__tests__/approval-routes-http.test.ts

@@ -23,27 +23,6 @@ const addRuleCalls: Array<{
   priority?: number;
   options?: { executionTarget?: string };
 }> = [];
-mock.module("../permissions/trust-store.js", () => ({
-  addRule: (
-    tool: string,
-    pattern: string,
-    scope: string,
-    decision: string,
-    priority?: number,
-    options?: { executionTarget?: string },
-  ) => {
-    addRuleCalls.push({ tool, pattern, scope, decision, priority, options });
-    return {
-      id: "test-rule",
-      tool,
-      pattern,
-      scope,
-      decision,
-      priority: priority ?? 100,
-    };
-  },
-  getRules: () => [],
-}));
 
 // ---------------------------------------------------------------------------
 // Module mocks for direct-import deps used by conversation-routes ROUTES

package/src/__tests__/assistant-attachment-directive.test.ts

@@ -132,8 +132,7 @@ describe("parseDirectives", () => {
   });
 
   test("preserves non-self-closing tags as plain text", () => {
-    const text =
-      '<cadet-attachment path="file.txt">content</cadet-attachment>';
+    const text = '<cadet-attachment path="file.txt">content</cadet-attachment>';
     const result = parseDirectives(text);
 
     // The regex only matches self-closing tags, so non-self-closing is not matched

package/src/__tests__/assistant-attachments.test.ts

@@ -816,16 +816,14 @@ describe("drainDirectiveDisplayBuffer", () => {
   });
 
   test("does not insert space when stripped directive already has trailing whitespace", () => {
-    const input =
-      'sentence. <cadet-attachment path="out.png" />Next sentence.';
+    const input = 'sentence. <cadet-attachment path="out.png" />Next sentence.';
     const result = drainDirectiveDisplayBuffer(input);
     expect(result.emitText).toBe("sentence. Next sentence.");
     expect(result.bufferedRemainder).toBe("");
   });
 
   test("does not insert space when stripped directive already has leading whitespace on next char", () => {
-    const input =
-      'sentence.<cadet-attachment path="out.png" /> Next sentence.';
+    const input = 'sentence.<cadet-attachment path="out.png" /> Next sentence.';
     const result = drainDirectiveDisplayBuffer(input);
     expect(result.emitText).toBe("sentence. Next sentence.");
     expect(result.bufferedRemainder).toBe("");