@mycadet/assistant 0.12.9 → 0.12.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycadet/assistant",
-  "version": "0.12.9",
+  "version": "0.12.11",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -20,15 +20,11 @@
     "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 --max-warnings 2956",
+    "lint": "bun run lint:skills && bun run lint:openapi && eslint --max-warnings 2863",
     "lint:unused": "knip --include files,dependencies,unlisted",
     "lint:circular": "bun run scripts/check-circular-deps.ts",
     "lint:unused:production": "knip --production --include exports",
-    "sync:bundled-catalog": "cd .. && bun run meta/sync-bundled-copies.ts && bun run assistant/scripts/generate-bundled-plugin-packages.ts",
-    "pretypecheck": "bun run sync:bundled-catalog",
-    "typecheck": "bunx tsc --noEmit",
-    "pretypecheck:fast": "bun run sync:bundled-catalog",
-    "typecheck:fast": "bunx tsgo --noEmit",
+    "typecheck": "bunx tsgo --noEmit",
     "test": "bun run scripts/run-tests.ts",
     "test:coverage": "COVERAGE=true bun run scripts/run-tests.ts",
     "test:stable": "EXCLUDE_EXPERIMENTAL=true bun run scripts/run-tests.ts",

package/scripts/build-test-fixtures.ts

@@ -52,7 +52,7 @@ async function buildMigratedFixture(outWorkspaceDir: string): Promise<void> {
   const { initializeDb } = await import("../src/persistence/db-init.js");
   const { getSqlite, getLogsSqlite, getMemorySqlite, getTelemetrySqlite } =
     await import("../src/persistence/db-connection.js");
-  const { getDbPath } = await import("../src/util/platform.js");
+  const { getDbPath } = await import("../src/util/layout.js");
   const { getLogsDbPath } = await import("../src/util/logs-db-path.js");
   const { getMemoryDbPath } = await import("../src/util/memory-db-path.js");
   const { getTelemetryDbPath } =

package/scripts/generate-openapi.ts

@@ -31,13 +31,29 @@ import type {
 import { createDocument } from "zod-openapi";
 
 import { ROUTES } from "../src/runtime/routes/index.js";
-import { jsonValueSchema } from "../src/telemetry/telemetry-wire.generated.js";
 
-// The recursive wire JSON-value schema (`claims`/`suggestions` item type) must
-// be hoisted into a named component so it can `$ref` itself; without a
-// registered id zod-openapi falls back to an anonymous `__schema0`. Name it
-// explicitly so the spec + generated SDK read as `TelemetryJsonValue`.
-z.globalRegistry.add(jsonValueSchema, { id: "TelemetryJsonValue" });
+// The recursive JSON-value schema (`claims`/`suggestions` item type) must be
+// hoisted into a named component so it can `$ref` itself; without a registered
+// id zod-openapi falls back to an anonymous `__schema0`. Name it explicitly so
+// the spec + generated SDK read as `JsonValue`.
+type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+const jsonValueSchema: z.ZodType<JsonValue> = z.lazy(() =>
+  z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema),
+  ]),
+);
+z.globalRegistry.add(jsonValueSchema, { id: "JsonValue" });
 
 const ROOT = resolve(import.meta.dir, "..");
 const OUTPUT_PATH = join(ROOT, "openapi.yaml");

package/scripts/postinstall.ts

@@ -19,15 +19,9 @@ if (!run("git", ["config", "core.hooksPath"])) {
   run("git", ["config", "core.hooksPath", ".githooks"]);
 }
 
+// Keep the bundled feature-flag registry copies in sync with the canonical
+// source on fresh installs.
 const syncScript = join(repoRoot, "meta", "sync-bundled-copies.ts");
-if (existsSync(syncScript) && run(process.execPath, ["run", syncScript])) {
-  run(process.execPath, [
-    "run",
-    join(
-      repoRoot,
-      "assistant",
-      "scripts",
-      "generate-bundled-plugin-packages.ts",
-    ),
-  ]);
+if (existsSync(syncScript)) {
+  run(process.execPath, ["run", syncScript]);
 }

package/scripts/run-tests.ts

@@ -8,7 +8,6 @@
  * experimental file lists, and the pre-migrated DB fixture.
  */
 
-import { existsSync } from "node:fs";
 import { basename } from "node:path";
 
 import { runIsolatedTests } from "@mycadet/shared/scripts/run-isolated-tests";
@@ -46,27 +45,7 @@ const KNOWN_BROKEN_FILES = new Set<string>([
   "src/workflows/sandbox-cpu-guard-asyncify.test.ts",
 ]);
 
-// Ensure generated catalog inputs exist before tests. Locally, postinstall may
-// not run in worktrees that share node_modules, so the static JSON imports can
-// otherwise be missing.
-function syncBundledCatalog(): void {
-  if (!existsSync("../meta/sync-bundled-copies.ts")) {
-    return;
-  }
-  const result = Bun.spawnSync(["bun", "run", "sync:bundled-catalog"], {
-    stdout: "ignore",
-    stderr: "pipe",
-    windowsHide: true,
-  });
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `Failed to generate bundled catalog inputs: ${result.stderr.toString()}`,
-    );
-  }
-}
-
 await runIsolatedTests({
-  setup: syncBundledCatalog,
   filter: (file) => {
     const base = basename(file);
     // Always exclude benchmark files — run them with `bun run test:bench`.

package/src/__tests__/adaptive-thinking-repair.test.ts

@@ -10,8 +10,6 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { repairAdaptiveThinkingOnCloudProfiles } from "../workspace/adaptive-thinking-repair.js";
-import { enableAdaptiveThinkingCloudProfilesMigration } from "../workspace/migrations/097-enable-adaptive-thinking-managed-profiles.js";
-import { recheckAdaptiveThinkingModelImpliedAnthropicMigration } from "../workspace/migrations/104-recheck-adaptive-thinking-model-implied-anthropic.js";
 
 const ADAPTIVE = { enabled: true, streamThinking: true };
 
@@ -49,30 +47,14 @@ function profile(name: string): Record<string, unknown> {
   return profiles[name] as Record<string, unknown>;
 }
 
-// The startup repair, migration 097, and migration 104 keep frozen copies of
-// the same logic (migration modules must stay self-contained). Run every
-// scenario against all of them so the copies can't drift.
-const implementations: Array<[string, (dir: string) => void]> = [
-  ["startup repair", repairAdaptiveThinkingOnCloudProfiles],
-  [
-    "migration 097",
-    (dir) => enableAdaptiveThinkingCloudProfilesMigration.run(dir),
-  ],
-  [
-    "migration 104",
-    (dir) => recheckAdaptiveThinkingModelImpliedAnthropicMigration.run(dir),
-  ],
-];
-
-describe.each(implementations)("%s", (_label, run) => {
+describe("repairAdaptiveThinkingOnCloudProfiles", () => {
   test("patches managed Anthropic profiles missing thinking", () => {
     writeConfig({
       llm: {
         default: { provider: "anthropic", model: "claude-sonnet-4-6" },
         profiles: {
-          balanced: { source: "managed", provider: "anthropic" },
+          balanced: { provider: "anthropic" },
           "quality-optimized": {
-            source: "managed",
             provider: "anthropic",
             thinking: { enabled: false },
           },
@@ -80,14 +62,14 @@ describe.each(implementations)("%s", (_label, run) => {
       },
     });
 
-    run(workspaceDir);
+    repairAdaptiveThinkingOnCloudProfiles(workspaceDir);
 
     expect(profile("balanced").thinking).toEqual(ADAPTIVE);
     expect(profile("quality-optimized").thinking).toEqual(ADAPTIVE);
   });
 
-  test("skips source-less empty shells when llm.default.provider is non-Anthropic", () => {
-    // Migration 052 seeds empty {} shells (no source, no provider) on legacy
+  test("skips empty shells when llm.default.provider is non-Anthropic", () => {
+    // Migration 052 seeds empty {} shells (no provider) on legacy
     // non-Anthropic workspaces. They inherit the non-Anthropic provider from
     // llm.default and must stay off the Anthropic-specific repair.
     writeConfig({
@@ -100,13 +82,13 @@ describe.each(implementations)("%s", (_label, run) => {
       },
     });
 
-    run(workspaceDir);
+    repairAdaptiveThinkingOnCloudProfiles(workspaceDir);
 
     expect(profile("balanced")).toEqual({});
     expect(profile("quality-optimized")).toEqual({});
   });
 
-  test("treats absent llm.default.provider as Anthropic for source-less profiles", () => {
+  test("treats absent llm.default.provider as Anthropic", () => {
     writeConfig({
       llm: {
         default: { model: "claude-sonnet-4-6" },
@@ -116,7 +98,7 @@ describe.each(implementations)("%s", (_label, run) => {
       },
     });
 
-    run(workspaceDir);
+    repairAdaptiveThinkingOnCloudProfiles(workspaceDir);
 
     expect(profile("balanced").thinking).toEqual(ADAPTIVE);
   });
@@ -131,30 +113,27 @@ describe.each(implementations)("%s", (_label, run) => {
       },
     });
 
-    run(workspaceDir);
+    repairAdaptiveThinkingOnCloudProfiles(workspaceDir);
 
     expect(profile("balanced").thinking).toEqual(ADAPTIVE);
   });
 
-  test("patches source-less profiles pinning a known Claude model under a non-Anthropic default", () => {
-    // A managed/source-less profile that omits `provider` but pins a known
-    // Claude model is Anthropic via the resolver's model-implied provider, even
-    // when llm.default.provider is non-Anthropic. It must still get adaptive
+  test("patches profiles pinning a known Claude model under a non-Anthropic default", () => {
+    // A profile that omits `provider` but pins a known Claude model is
+    // Anthropic via the resolver's model-implied provider, even when
+    // llm.default.provider is non-Anthropic. It must still get adaptive
     // thinking rather than being skipped.
     writeConfig({
       llm: {
         default: { provider: "gemini", model: "gemini-2.5-pro" },
         profiles: {
           balanced: { model: "claude-sonnet-4-6" },
-          "quality-optimized": {
-            source: "managed",
-            model: "claude-opus-4-8",
-          },
+          "quality-optimized": { model: "claude-opus-4-8" },
         },
       },
     });
 
-    run(workspaceDir);
+    repairAdaptiveThinkingOnCloudProfiles(workspaceDir);
 
     expect(profile("balanced").thinking).toEqual(ADAPTIVE);
     expect(profile("quality-optimized").thinking).toEqual(ADAPTIVE);
@@ -170,41 +149,24 @@ describe.each(implementations)("%s", (_label, run) => {
       },
     });
 
-    run(workspaceDir);
-
-    expect(profile("balanced").thinking).toBeUndefined();
-  });
-
-  test("skips source: user profiles", () => {
-    writeConfig({
-      llm: {
-        default: { provider: "anthropic" },
-        profiles: {
-          balanced: { source: "user", provider: "anthropic" },
-        },
-      },
-    });
-
-    run(workspaceDir);
+    repairAdaptiveThinkingOnCloudProfiles(workspaceDir);
 
     expect(profile("balanced").thinking).toBeUndefined();
   });
 
   test("is idempotent when thinking is already enabled", () => {
-    const config = {
+    writeConfig({
       llm: {
         default: { provider: "anthropic" },
         profiles: {
           balanced: {
-            source: "managed",
             thinking: { enabled: true, streamThinking: false },
           },
         },
       },
-    };
-    writeConfig(config);
+    });
 
-    run(workspaceDir);
+    repairAdaptiveThinkingOnCloudProfiles(workspaceDir);
 
     expect(profile("balanced").thinking).toEqual({
       enabled: true,

package/src/__tests__/agent-loop.test.ts

@@ -181,82 +181,6 @@ describe("AgentLoop", () => {
     expect(calls[1].options?.config?.overrideProfile).toBe("quality-optimized");
   });
 
-  test("the auto origin follows the routed override and drops once a switch replaces it", async () => {
-    const toolCallId = "tool-1";
-    const { provider, calls } = createMockProvider([
-      toolUseResponse(toolCallId, "read_file", { path: "/tmp/test.txt" }),
-      textResponse("done"),
-    ]);
-    let overrideProfile = "quality-optimized";
-    const loop = new AgentLoop({
-      provider: provider,
-      systemPrompt: "system",
-      conversationId: "test-conversation",
-      tools: dummyTools,
-      toolExecutor: async () => {
-        // A confirmed profile session mid-turn: the user's pick, not Auto's.
-        overrideProfile = "cost-optimized";
-        return { content: "ok", isError: false };
-      },
-    });
-
-    await loop.run({
-      messages: [userMessage],
-      onEvent: collectEvents([]),
-      trust: { sourceChannel: "cadet", trustClass: "unknown" },
-      requestId: "req-1",
-      callSite: "mainAgent",
-      overrideProfile: "quality-optimized",
-      overrideProfileOrigin: "auto",
-      resolveOverrideProfile: () => overrideProfile,
-    });
-
-    expect(calls).toHaveLength(2);
-    expect(calls[0].options?.config?.overrideProfile).toBe("quality-optimized");
-    expect(calls[0].options?.config?.overrideProfileOrigin).toBe("auto");
-    expect(calls[1].options?.config?.overrideProfile).toBe("cost-optimized");
-    expect(calls[1].options?.config?.overrideProfileOrigin).toBeUndefined();
-  });
-
-  test("a pre-model-call hook keeps the auto origin unless it changes the profile", async () => {
-    let hookProfile: string | null | undefined;
-    registerPlugin({
-      manifest: { name: "profile-hook", version: "0.0.1" },
-      hooks: {
-        "pre-model-call": async (ctx) =>
-          hookProfile === undefined
-            ? ctx
-            : { ...ctx, modelProfile: hookProfile },
-      },
-    });
-    const run = async () => {
-      const { provider, calls } = createMockProvider([textResponse("ok")]);
-      const loop = new AgentLoop({
-        provider: provider,
-        systemPrompt: "system",
-        conversationId: "test-conversation",
-        tools: dummyTools,
-      });
-      await loop.run({
-        messages: [userMessage],
-        onEvent: collectEvents([]),
-        trust: { sourceChannel: "cadet", trustClass: "unknown" },
-        requestId: "req-1",
-        callSite: "mainAgent",
-        overrideProfile: "quality-optimized",
-        overrideProfileOrigin: "auto",
-      });
-      return calls[0].options?.config;
-    };
-
-    hookProfile = undefined;
-    expect((await run())?.overrideProfileOrigin).toBe("auto");
-    hookProfile = "cost-optimized";
-    expect((await run())?.overrideProfileOrigin).toBeUndefined();
-    hookProfile = null;
-    expect((await run())?.overrideProfileOrigin).toBeUndefined();
-  });
-
   test("re-resolves max input tokens before truncating tool results", async () => {
     const toolCallId = "tool-1";
     const toolOutput = "x".repeat(2_500);

package/src/__tests__/anthropic-provider.test.ts

@@ -2960,13 +2960,13 @@ describe("AnthropicProvider — Cloud Proxy Fallback", () => {
 
   test("constructor passes baseURL to Anthropic SDK when provided", () => {
     new AnthropicProvider("managed-key", "claude-sonnet-4-6", {
-      baseURL: "https://platform.example.com/v1/runtime-proxy/anthropic",
+      baseURL: "https://test-cloud.mycadet.ai/v1/runtime-proxy/anthropic",
     });
 
     expect(lastConstructorArgs).not.toBeNull();
     expect(lastConstructorArgs!.apiKey).toBe("managed-key");
     expect(lastConstructorArgs!.baseURL).toBe(
-      "https://platform.example.com/v1/runtime-proxy/anthropic",
+      "https://test-cloud.mycadet.ai/v1/runtime-proxy/anthropic",
     );
   });
 
@@ -2980,7 +2980,7 @@ describe("AnthropicProvider — Cloud Proxy Fallback", () => {
 
   test("managed mode provider preserves tool-pairing behavior", async () => {
     const provider = new AnthropicProvider("managed-key", "claude-sonnet-4-6", {
-      baseURL: "https://platform.example.com/v1/runtime-proxy/anthropic",
+      baseURL: "https://test-cloud.mycadet.ai/v1/runtime-proxy/anthropic",
     });
 
     const messages: Message[] = [
@@ -3003,7 +3003,7 @@ describe("AnthropicProvider — Cloud Proxy Fallback", () => {
 
   test("managed mode provider preserves cache-control behavior", async () => {
     const provider = new AnthropicProvider("managed-key", "claude-sonnet-4-6", {
-      baseURL: "https://platform.example.com/v1/runtime-proxy/anthropic",
+      baseURL: "https://test-cloud.mycadet.ai/v1/runtime-proxy/anthropic",
     });
 
     await provider.sendMessage([userMsg("Hi")], {
@@ -3286,13 +3286,13 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
       "ast-key",
       "anthropic/claude-opus-4.6",
       {
-        baseURL: "https://platform.example.com/v1/runtime-proxy/openrouter/v1",
+        baseURL: "https://test-cloud.mycadet.ai/v1/runtime-proxy/openrouter/v1",
       },
     );
     await provider.sendMessage([userMsg("hi")]);
 
     expect(lastConstructorArgs).toMatchObject({
-      baseURL: "https://platform.example.com/v1/runtime-proxy/openrouter",
+      baseURL: "https://test-cloud.mycadet.ai/v1/runtime-proxy/openrouter",
     });
   });
 

package/src/__tests__/assert-not-live-db.ts

@@ -22,7 +22,7 @@
  * No source-module imports — only node stdlib. Helpers in `__tests__/`
  * must not import from `src/` (see assistant/AGENTS.md). Callers pass
  * the resolved `dbPath` in so this file stays decoupled from
- * `src/util/platform.ts`.
+ * `src/util/layout.ts`.
  */
 
 import { realpathSync, rmSync } from "node:fs";

package/src/__tests__/assistant-id-boundary-guard.test.ts

@@ -110,8 +110,8 @@ describe("assistant ID boundary", () => {
     const repoRoot = getRepoRoot();
 
     // Scan all daemon/runtime source directories for any reference to
-    // normalizeAssistantId. The function is defined in util/platform.ts for
-    // gateway use — it must not appear in daemon scoping modules.
+    // normalizeAssistantId. The function is deleted — it must not be
+    // reintroduced in daemon scoping modules.
     let grepOutput = "";
     try {
       grepOutput = execFileSync(
@@ -134,7 +134,7 @@ describe("assistant ID boundary", () => {
       const message = [
         "Found daemon/runtime source files that reference `normalizeAssistantId`.",
         "Daemon code should use the `DAEMON_INTERNAL_ASSISTANT_ID` constant instead.",
-        "The `normalizeAssistantId` function is for gateway/platform use only (defined in util/platform.ts).",
+        "The `normalizeAssistantId` function is deleted and must not be reintroduced.",
         "",
         "Violations:",
         ...violations.map((f) => `  - ${f}`),

package/src/__tests__/attachments-store-heic-normalize.test.ts

@@ -75,7 +75,7 @@ import {
   ROUTES,
 } from "../runtime/routes/attachment-routes.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
-import { getWorkspaceDir } from "../util/platform.js";
+import { getWorkspaceDir } from "../util/layout.js";
 import { fakeHeifHeaderBytes, PNG_1PX_BYTES } from "./heic-fixture.js";
 
 const uploadRoute = ROUTES.find((r) => r.operationId === "attachment_upload")!;

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

@@ -34,7 +34,7 @@ import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { rawGet, rawRun } from "../persistence/raw-query.js";
 import { mediaSourceBytes } from "../providers/media-resolve.js";
-import { getConversationsDir } from "../util/platform.js";
+import { getConversationsDir } from "../util/layout.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // Disable memory so addMessage skips background indexing of test messages.

package/src/__tests__/audit-log-rotation.test.ts

@@ -9,7 +9,7 @@ import { initializeDb } from "../persistence/db-init.js";
 import {
   getRecentInvocations,
   rotateToolInvocations,
-} from "../telemetry/tool-usage-store.js";
+} from "../persistence/tool-usage-store.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 
 // ---------------------------------------------------------------------------

package/src/__tests__/btw-routes.test.ts

@@ -119,7 +119,7 @@ import {
   ServiceUnavailableError,
 } from "../runtime/routes/errors.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
-import { getWorkspaceDir } from "../util/platform.js";
+import { getWorkspaceDir } from "../util/layout.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // ---------------------------------------------------------------------------