@intentic/sandbox-contract 1.299.0 → 1.300.1

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

@@ -171,11 +171,14 @@ describe(`WORKSPACE_STATE_FILES`, () => {
     });
 
     it(`splits a nested entry from its parent for a reason the parent doesn't already carry`, () => {
-        // A nest agreeing with its parent is dead weight: stateFileFor resolves to the same answer either way.
+        // A nest agreeing with its parent is dead weight: stateFileFor resolves to the same answer either way. Three
+        // answers can differ, and a nest earns its place by moving any one of them.
         for (const file of WORKSPACE_STATE_FILES) {
             for (const parent of WORKSPACE_STATE_FILES.filter((other) => other !== file && file.path.startsWith(other.path))) {
                 expect(
-                    parent.portability === file.portability && parent.invalidates.join(",") === file.invalidates.join(","),
+                    parent.portability === file.portability &&
+                        parent.invalidates.join(",") === file.invalidates.join(",") &&
+                        (parent.backup ?? true) === (file.backup ?? true),
                     `${file.path} says nothing its parent ${parent.path} doesn't already say`,
                 ).toBe(false);
             }
@@ -499,9 +502,12 @@ describe(`BACKED_UP_STATE_PATHS`, () => {
         }
     });
 
-    it(`copies down everything a person wrote and everything that happened`, () => {
+    // Opting out is per entry and by hand: the class still decides for everything that says nothing, so a new record
+    // store is backed up until somebody writes down why it shouldn't be.
+    it(`copies down everything a person wrote and everything that happened, bar the entries that opt out`, () => {
         for (const path of [...stateGroupPaths(`config`), ...stateGroupPaths(`records`)]) {
-            expect([path, BACKED_UP_STATE_PATHS.includes(path)]).toEqual([path, true]);
+            const optedOut = WORKSPACE_STATE_FILES.find((file) => file.path === path)?.backup === false;
+            expect([path, BACKED_UP_STATE_PATHS.includes(path)]).toEqual([path, !optedOut]);
         }
     });
 
@@ -526,8 +532,10 @@ describe(`BACKED_UP_STATE_PATHS`, () => {
 
     it(`still withholds the tokens that authenticate against this sandbox`, () => {
         expect(BACKED_UP_STATE_PATHS).not.toContain(`.intentic/identity/control-tokens.json`);
-        // The only entry that opts out by hand; everything else follows from its class alone.
+        // The whole hand-written list, in declaration order: one credential that would admit its holder to the source
+        // sandbox, and one tree of page captures nothing reads after its own turn. Everything else follows from class.
         expect(WORKSPACE_STATE_FILES.filter((file) => file.backup === false).map((file) => file.path)).toEqual([
+            `.intentic/records/artifacts/browser/`,
             `.intentic/identity/control-tokens.json`,
         ]);
     });

package/src/state/workspace-state.ts

@@ -323,6 +323,17 @@ const STATE_FILES = [
         why: "Durable outputs owned by conversations and extension runs: attachments, browser captures, generated images, acceptance reports, workflow step reports, voice transcripts, and loop ledgers.",
         portability: "carry",
     },
+    // Nested under the artifacts above for one difference: this is the only member of that tree with no reader once the
+    // turn that wrote it has ended, and it is most of its bytes. Still `carry` (an export takes the whole history), but
+    // the desktop backup declines it: measured on a dogfooding machine as 1.1 GB across 6,315 files, re-scanned on every
+    // poll of a one-way session whose siblings — attachments above all — are the owner's own uploads and do come down.
+    {
+        path: ".intentic/records/artifacts/browser/",
+        invalidates: [],
+        why: "Page snapshots, screenshots and console logs a turn's browser wrote while looking at a site; read back by that turn and by nothing after it.",
+        portability: "carry",
+        backup: false,
+    },
     {
         path: ".intentic/local/cache/",
         invalidates: [],

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

@@ -201,23 +201,6 @@ describe("foldTurn", () => {
         });
     });
 
-    it("writes down a turn that ran on a cheaper model, and nothing for a verdict that moved nothing", () => {
-        const routed: AgentEvent[] = [
-            { kind: "tier", tier: "fast", score: 0.1, rules: ["easy-words"], model: "claude-haiku-4-5", routed: true },
-            { kind: "delta", text: "a closure is…" },
-        ];
-        expect(foldOf("what is a closure?", routed)).toEqual([
-            { role: "user", text: "what is a closure?", sentAt: SENT_AT },
-            { role: "notice", text: "This turn looked simple, so it ran on claude-haiku-4-5 instead of your pick.", noticeAction: "tierHold" },
-            { role: "assistant", text: "a closure is…" },
-        ]);
-        const held: AgentEvent[] = [
-            { kind: "tier", tier: "fast", score: 0.1, rules: ["easy-words"], model: "claude-haiku-4-5", routed: false, held: true },
-            { kind: "delta", text: "sure" },
-        ];
-        expect(foldOf("go", held).map((message) => message.role)).toEqual(["user", "assistant"]);
-    });
-
     it("writes the turn's own events down as notices", () => {
         const events: AgentEvent[] = [
             { kind: "worktree", branch: "agent/x", base: "abc1234", sync: { commits: 2, blocked: [] } },

package/src/text/transcript-fold.ts

@@ -259,11 +259,6 @@ export class TranscriptFold {
             case "error":
                 // Keeps a refusal (no prose from the provider) from reading as a session that ended mid-question.
                 return this.pushRow(errorRow(event));
-            case "tier":
-                // Notes a turn served on a cheaper model than requested, only when it actually routed.
-                return event.routed && event.model !== undefined
-                    ? this.pushRow({ role: "notice", text: `This turn looked simple, so it ran on ${event.model} instead of your pick.`, noticeAction: "tierHold" })
-                    : [];
             case "plan": {
                 // Folds a plan into an identical retired prose bubble instead of drawing the same markdown twice.
                 const adjacent = this.rows.at(-1);

package/dist/models/fast-tier.d.ts

@@ -1,9 +0,0 @@
-import type { AgentProvider } from "../schemas/agent.js";
-export interface FastTierInput {
-    readonly provider: AgentProvider;
-    readonly model: string;
-    readonly models: readonly string[];
-    readonly pinned: readonly string[];
-}
-export declare const fastTierModel: (input: FastTierInput) => string | undefined;
-//# sourceMappingURL=fast-tier.d.ts.map

package/dist/models/fast-tier.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fast-tier.d.ts","sourceRoot":"","sources":["../../src/models/fast-tier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAMzD,MAAM,WAAW,aAAa;IAC1B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;IAEjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAEnC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAID,eAAO,MAAM,aAAa,UAAW,aAAa,KAAG,MAAM,GAAG,SAe7D,CAAC"}

package/dist/models/fast-tier.js

@@ -1,19 +0,0 @@
-import { compareCheapestFirst, isCheaperRung } from "./model-order.js";
-import { parsePinned } from "./model-pins.js";
-export const fastTierModel = (input) => {
-    if (input.model === "") {
-        return undefined;
-    }
-    const pinned = input.pinned
-        .flatMap((key) => {
-        const choice = parsePinned(key);
-        return choice === undefined || choice.provider !== input.provider ? [] : [choice.model];
-    })
-        .find((model) => isCheaperRung(model, input.model));
-    if (pinned !== undefined) {
-        return pinned;
-    }
-    const cheapest = input.models.toSorted(compareCheapestFirst)[0];
-    return cheapest !== undefined && isCheaperRung(cheapest, input.model) ? cheapest : undefined;
-};
-//# sourceMappingURL=fast-tier.js.map

package/dist/models/fast-tier.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fast-tier.js","sourceRoot":"","sources":["../../src/models/fast-tier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAmB9C,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAoB,EAAsB,EAAE;IACtE,IAAI,KAAK,CAAC,KAAK,KAAK,EAAE,EAAE,CAAC;QACrB,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM;SACtB,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;QACb,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;QAChC,OAAO,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5F,CAAC,CAAC;SACD,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;IACxD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,MAAM,CAAC;IAClB,CAAC;IACD,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC;IAChE,OAAO,QAAQ,KAAK,SAAS,IAAI,aAAa,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;AACjG,CAAC,CAAC"}

package/dist/models/prompt-complexity.d.ts

@@ -1,27 +0,0 @@
-export type ComplexityRule = "images" | "plan-mode" | "unattended" | "code-block" | "stack-trace" | "hard-words" | "multi-step" | "cross-cutting" | "long-prompt" | "many-attachments" | "medium-prompt" | "attachment" | "editor-context" | "paths" | "many-verbs" | "after-hard-turn" | "short-prompt" | "easy-words" | "bare-question" | "no-workspace-reference";
-export type ComplexityTier = "fast" | "standard";
-export interface ComplexityInput {
-    readonly prompt: string;
-    readonly attachments: number;
-    readonly hasImages: boolean;
-    readonly editorContext: boolean;
-    readonly unattended: boolean;
-    readonly planMode: boolean;
-    readonly afterHardTurn: boolean;
-    readonly eagerness?: TierEagerness;
-}
-export interface ComplexityVerdict {
-    readonly tier: ComplexityTier;
-    readonly score: number;
-    readonly rules: readonly ComplexityRule[];
-    readonly ceiling: number;
-}
-export declare const FAST_CEILINGS: {
-    readonly cautious: 0;
-    readonly balanced: 0.25;
-    readonly eager: 0.4;
-};
-export type TierEagerness = keyof typeof FAST_CEILINGS;
-export declare const FAST_CEILING: 0.25;
-export declare const judgeComplexity: (input: ComplexityInput) => ComplexityVerdict;
-//# sourceMappingURL=prompt-complexity.d.ts.map

package/dist/models/prompt-complexity.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt-complexity.d.ts","sourceRoot":"","sources":["../../src/models/prompt-complexity.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,cAAc,GAEpB,QAAQ,GACR,WAAW,GACX,YAAY,GAEZ,YAAY,GACZ,aAAa,GACb,YAAY,GACZ,YAAY,GACZ,eAAe,GACf,aAAa,GACb,kBAAkB,GAElB,eAAe,GACf,YAAY,GACZ,gBAAgB,GAChB,OAAO,GACP,YAAY,GACZ,iBAAiB,GACjB,cAAc,GACd,YAAY,GACZ,eAAe,GACf,wBAAwB,CAAC;AAE/B,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,UAAU,CAAC;AAIjD,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAE7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAE5B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAEhC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAEhC,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC;CACtC;AAED,MAAM,WAAW,iBAAiB;IAC9B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAE9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAE1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC5B;AASD,eAAO,MAAM,aAAa;aAAK,QAAQ,EAAE,CAAC;aAAE,QAAQ,EAAE,IAAI;aAAE,KAAK,EAAE,GAAG;CAAW,CAAC;AAClF,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,aAAa,CAAC;AAGvD,eAAO,MAAM,YAAY,MAAyB,CAAC;AA6HnD,eAAO,MAAM,eAAe,UAAW,eAAe,KAAG,iBAgBxD,CAAC"}

package/dist/models/prompt-complexity.js

@@ -1,91 +0,0 @@
-const BASE_SCORE = 0.5;
-export const FAST_CEILINGS = { cautious: 0, balanced: 0.25, eager: 0.4 };
-export const FAST_CEILING = FAST_CEILINGS.balanced;
-const MEDIUM_PROMPT_CHARS = 600;
-const LONG_PROMPT_CHARS = 2400;
-const SHORT_PROMPT_CHARS = 140;
-const MANY_ATTACHMENTS = 3;
-const MANY_VERBS = 3;
-const EASY_WORDS = /\b(?:what(?:'s| is| are)|explain|describe|summari[sz]e|list|show me|where(?:'s| is| are)|rename|typo|reword|reformat|format this|tidy|define|translate|spell|abbreviat)/i;
-const HARD_WORDS = /\b(?:refactor|redesign|architect|architecture|migrat|root cause|debug|investigat|diagnos|optimi[sz]|race condition|deadlock|memory leak|regression|security|threat model|benchmark|profil|audit|design a|plan (?:a|the|out)|why (?:does|is|are|did|would|can't|cannot))/i;
-const MULTI_STEP = /\b(?:and then|after that|once (?:that|you)|followed by|as well as|then also)\b/i;
-const CROSS_CUTTING = /\b(?:across (?:the|all|every)|every(?: single)? (?:file|module|package|component|usage|call ?site)|all (?:the|of the) (?:files|usages|call ?sites|places)|everywhere|throughout the|codebase-wide|repo-wide)\b/i;
-const CODE_BLOCK = /```|^diff --git |^@@ .* @@|^[+-]{3} [ab]\//m;
-const STACK_TRACE = /(?:^|\n)\s*(?:at [\w$.<>]+ \(|Traceback \(most recent call last\)|Caused by:|panic:|thread '.*' panicked|Unhandled|[A-Z]\w*(?:Error|Exception): )/;
-const PATH_LIKE = /(?:^|\s)(?:@[\w./-]+|[\w-]+\/[\w./-]+\.[a-z]{1,5}\b|\b[\w-]+\.(?:ts|tsx|js|jsx|vue|py|go|rs|java|rb|css|scss|json|ya?ml|md|sql|sh)\b)/i;
-const BARE_QUESTION = /^[^.!?]{0,200}\?\s*$/;
-const VERBS = /\b(?:add|remove|delete|fix|write|create|make|update|change|move|rename|split|merge|extract|inline|wire|hook|test|check|run|build|deploy|document|implement|replace|convert|handle|support|expose|log|render|validate|parse|sort|filter|cache)\b/gi;
-const LIST_LINES = /^\s*(?:[-*+]\s|\d+[.)]\s)/gm;
-const forcing = (input, text) => {
-    const rules = [];
-    if (input.hasImages) {
-        rules.push("images");
-    }
-    if (input.planMode) {
-        rules.push("plan-mode");
-    }
-    if (input.unattended) {
-        rules.push("unattended");
-    }
-    if (CODE_BLOCK.test(text)) {
-        rules.push("code-block");
-    }
-    if (STACK_TRACE.test(text)) {
-        rules.push("stack-trace");
-    }
-    if (HARD_WORDS.test(text)) {
-        rules.push("hard-words");
-    }
-    if (MULTI_STEP.test(text) || (text.match(LIST_LINES)?.length ?? 0) >= 2) {
-        rules.push("multi-step");
-    }
-    if (CROSS_CUTTING.test(text)) {
-        rules.push("cross-cutting");
-    }
-    if (text.length > LONG_PROMPT_CHARS) {
-        rules.push("long-prompt");
-    }
-    if (input.attachments >= MANY_ATTACHMENTS) {
-        rules.push("many-attachments");
-    }
-    return rules;
-};
-const GRADED = [
-    { rule: "medium-prompt", weight: +0.2, of: (_input, text) => text.length > MEDIUM_PROMPT_CHARS },
-    { rule: "attachment", weight: +0.15, of: (input) => input.attachments > 0 },
-    { rule: "editor-context", weight: +0.1, of: (input) => input.editorContext },
-    { rule: "paths", weight: +0.15, of: (_input, text) => PATH_LIKE.test(text) },
-    {
-        rule: "many-verbs",
-        weight: +0.15,
-        of: (_input, text) => new Set((text.match(VERBS) ?? []).map((verb) => verb.toLowerCase())).size >= MANY_VERBS,
-    },
-    { rule: "after-hard-turn", weight: +0.25, of: (input) => input.afterHardTurn },
-    { rule: "short-prompt", weight: -0.1, of: (_input, text) => text.length <= SHORT_PROMPT_CHARS },
-    { rule: "easy-words", weight: -0.25, easing: true, of: (_input, text) => EASY_WORDS.test(text) },
-    { rule: "bare-question", weight: -0.15, easing: true, of: (_input, text) => BARE_QUESTION.test(text) },
-    {
-        rule: "no-workspace-reference",
-        weight: -0.1,
-        of: (input, text) => input.attachments === 0 && !input.editorContext && !PATH_LIKE.test(text),
-    },
-];
-const round3 = (value) => Math.round(value * 1000) / 1000;
-export const judgeComplexity = (input) => {
-    const ceiling = FAST_CEILINGS[input.eagerness ?? "balanced"];
-    const text = input.prompt.trim();
-    const forced = forcing(input, text);
-    if (forced.length > 0) {
-        return { tier: "standard", score: 1, rules: forced, ceiling };
-    }
-    const hits = GRADED.filter((feature) => feature.of(input, text));
-    const score = Math.min(1, Math.max(0, BASE_SCORE + hits.reduce((total, feature) => total + feature.weight, 0)));
-    const eased = hits.some((feature) => feature.easing === true);
-    return {
-        tier: eased && score <= ceiling ? "fast" : "standard",
-        score: round3(score),
-        rules: hits.map((feature) => feature.rule),
-        ceiling,
-    };
-};
-//# sourceMappingURL=prompt-complexity.js.map

package/dist/models/prompt-complexity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt-complexity.js","sourceRoot":"","sources":["../../src/models/prompt-complexity.ts"],"names":[],"mappings":"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"}

package/src/models/fast-tier.test.ts

@@ -1,77 +0,0 @@
-import { expect, test } from "vitest";
-import { fastTierModel } from "./fast-tier.js";
-
-// Whether a downgraded turn has anywhere cheaper to land on its current provider; a downgrade must be a genuinely
-// cheaper rung of the same catalog and never cross provider, since that retires the session.
-
-const CLAUDE = [`claude-opus-5`, `claude-sonnet-5`, `claude-haiku-4-5-20251001`];
-const GOOGLE = [`gemini-3-pro`, `gemini-3-flash`, `gemini-3-flash-lite`];
-
-const fastFor = (model: string, over: { models?: readonly string[]; pinned?: readonly string[]; provider?: string } = {}) =>
-    fastTierModel({ provider: over.provider ?? `claude`, model, models: over.models ?? CLAUDE, pinned: over.pinned ?? [] });
-
-// --- Auto: the cheapest rung the provider publishes ----------------------------------------------------
-
-test("sends a frontier turn to the provider's own cheap rung", () => {
-    expect(fastFor(`claude-opus-5`)).toBe(`claude-haiku-4-5-20251001`);
-});
-
-test("reads the cheap end the same way the quick model does, on every vendor's vocabulary", () => {
-    expect(fastFor(`gemini-3-pro`, { provider: `gemini`, models: GOOGLE })).toBe(`gemini-3-flash-lite`);
-});
-
-// --- the ceiling: the user's own pick -------------------------------------------------------------------
-
-test("a user already on the cheap rung has nowhere to be sent", () => {
-    // undefined means run the original pick: the safe default when nothing is cheaper.
-    expect(fastFor(`claude-haiku-4-5-20251001`)).toBeUndefined();
-});
-
-test("never swaps a model for an older build of the same tier", () => {
-    expect(fastFor(`claude-sonnet-5`, { models: [`claude-sonnet-5`, `claude-sonnet-4`] })).toBeUndefined();
-});
-
-test("never downgrades a model whose family this build does not recognise", () => {
-    // An id with no tier word is either the provider's own baseline or an unrecognised family.
-    expect(fastFor(`claude-opus-5`, { models: [`some-new-thing`] })).toBeUndefined();
-    expect(fastFor(`some-new-thing`, { models: CLAUDE })).toBeUndefined();
-});
-
-test("an unloaded catalog resolves to no downgrade rather than to a guess", () => {
-    expect(fastFor(`claude-opus-5`, { models: [] })).toBeUndefined();
-});
-
-test("no pick yet means nothing to be cheaper than", () => {
-    expect(fastFor(``)).toBeUndefined();
-});
-
-// --- pins -----------------------------------------------------------------------------------------------
-
-test("a pin on this provider wins over the catalog's own cheap end", () => {
-    expect(fastFor(`claude-opus-5`, { pinned: [`claude:claude-sonnet-5`] })).toBe(`claude-sonnet-5`);
-});
-
-test("takes a pinned id verbatim, so a model the static catalog has not caught up with is still pinnable", () => {
-    // Takes a pinned id verbatim: second-guessing it would run a different model than the settings row names.
-    expect(fastFor(`claude-opus-5`, { pinned: [`claude:claude-haiku-9`] })).toBe(`claude-haiku-9`);
-});
-
-test("drops a pin naming another provider rather than crossing to it", () => {
-    // Crossing provider retires the session (turnRequest.ts's resumes); the pin is ignored instead.
-    expect(fastFor(`claude-opus-5`, { pinned: [`gemini:gemini-3-flash-lite`] })).toBe(`claude-haiku-4-5-20251001`);
-});
-
-test("skips a pin that is not actually cheaper than what the user picked", () => {
-    // A pin picks which cheap rung, never licence to swap to an equal or better model.
-    expect(fastFor(`claude-sonnet-5`, { pinned: [`claude:claude-opus-5`] })).toBe(`claude-haiku-4-5-20251001`);
-});
-
-test("walks past an unusable pin to the next one that names this provider", () => {
-    const pinned = [`gemini:gemini-3-flash`, `claude:claude-opus-5`, `claude:claude-haiku-4-5`];
-
-    expect(fastFor(`claude-opus-5`, { pinned })).toBe(`claude-haiku-4-5`);
-});
-
-test("falls back to Auto when no pin survives, rather than to no downgrade at all", () => {
-    expect(fastFor(`claude-opus-5`, { pinned: [`nonsense`, `gemini:gemini-3-flash`] })).toBe(`claude-haiku-4-5-20251001`);
-});

package/src/models/fast-tier.ts

@@ -1,36 +0,0 @@
-import { compareCheapestFirst, isCheaperRung } from "./model-order.js";
-import { parsePinned } from "./model-pins.js";
-import type { AgentProvider } from "../schemas/agent.js";
-
-// Picks which model a downgraded turn runs on, once prompt-complexity.ts decides a turn could be cheaper. Only routes
-// down to a cheaper rung of the model the user already picked; ambiguous cases resolve to undefined, meaning run their
-// pick. Never crosses provider: that retires the session and loses the context that made the follow-up cheap.
-
-export interface FastTierInput {
-    readonly provider: AgentProvider;
-    // Empty means the composer has not resolved a pick yet; that resolves to no downgrade, not a guess.
-    readonly model: string;
-    // Empty is a real state (catalog not loaded yet), and resolves to no downgrade rather than a guess.
-    readonly models: readonly string[];
-    // settings.autoFastModels: ordered `${provider}:${modelId}` keys, empty for Auto; other providers drop.
-    readonly pinned: readonly string[];
-}
-
-// A pin is taken verbatim but must still be cheaper than the pick; Auto falls back to the cheapest rung, in the same
-// cheap-first order the quick model uses. Undefined means nothing is cheaper.
-export const fastTierModel = (input: FastTierInput): string | undefined => {
-    if (input.model === "") {
-        return undefined;
-    }
-    const pinned = input.pinned
-        .flatMap((key) => {
-            const choice = parsePinned(key);
-            return choice === undefined || choice.provider !== input.provider ? [] : [choice.model];
-        })
-        .find((model) => isCheaperRung(model, input.model));
-    if (pinned !== undefined) {
-        return pinned;
-    }
-    const cheapest = input.models.toSorted(compareCheapestFirst)[0];
-    return cheapest !== undefined && isCheaperRung(cheapest, input.model) ? cheapest : undefined;
-};

package/src/models/prompt-complexity.test.ts

@@ -1,177 +0,0 @@
-import { expect, test } from "vitest";
-import { type ComplexityInput, FAST_CEILING, judgeComplexity } from "./prompt-complexity.js";
-
-// Pins the asymmetry: the judge only ever routes down, so silence resolves to standard, any escalating rule or gate
-// wins regardless of order, and the weights (settings.autoTier "shadow") stay unpinned.
-
-const turn = (prompt: string, over: Partial<ComplexityInput> = {}): ComplexityInput => ({
-    prompt,
-    attachments: 0,
-    hasImages: false,
-    editorContext: false,
-    unattended: false,
-    planMode: false,
-    afterHardTurn: false,
-    ...over,
-});
-
-const tierOf = (prompt: string, over: Partial<ComplexityInput> = {}) => judgeComplexity(turn(prompt, over)).tier;
-
-test("a prompt matching nothing at all stays on the model the user picked", () => {
-    const verdict = judgeComplexity(turn(`Have another go at the thing we were discussing yesterday afternoon`));
-
-    expect(verdict.tier).toBe(`standard`);
-    expect(verdict.score).toBeGreaterThan(FAST_CEILING);
-    // Only the two absence features fire on this input; together they cannot reach the ceiling.
-    expect(verdict.rules).toEqual([`short-prompt`, `no-workspace-reference`]);
-});
-
-test("a short vague request is not read as an easy one", () => {
-    expect(tierOf(`fix the bug`)).toBe(`standard`);
-    expect(tierOf(`have a look at the thing we discussed`)).toBe(`standard`);
-});
-
-test("an empty-ish prompt is not mistaken for an easy one", () => {
-    expect(tierOf(`   `)).toBe(`standard`);
-});
-
-test("a short question about nothing in the workspace is the case this feature exists for", () => {
-    expect(tierOf(`what is a closure?`)).toBe(`fast`);
-});
-
-test("naming a file keeps an otherwise easy question on the user's own model", () => {
-    // Same easy word; naming a real file, not a concept, tips the verdict to standard.
-    expect(tierOf(`explain what is a closure`)).toBe(`fast`);
-    expect(tierOf(`explain what src/agent/turn-plan.ts does`)).toBe(`standard`);
-});
-
-test("a trivial aside inside a hard conversation still gets through", () => {
-    expect(tierOf(`what is a closure?`, { afterHardTurn: true })).toBe(`fast`);
-});
-
-test("a workspace-adjacent errand stops being cheap once the conversation has done hard work", () => {
-    expect(tierOf(`list the exports`, { afterHardTurn: false })).toBe(`fast`);
-    expect(tierOf(`list the exports`, { afterHardTurn: true })).toBe(`standard`);
-});
-
-test("a screenshot is never sent to the cheap rung, however simple the question about it", () => {
-    expect(tierOf(`what is this?`, { hasImages: true, attachments: 1 })).toBe(`standard`);
-});
-
-test("plan mode is a request to think, so it is never answered by the model that thinks least", () => {
-    expect(tierOf(`what is a closure?`, { planMode: true })).toBe(`standard`);
-});
-
-test("a surface-started run is never downgraded, because nobody is watching it fail", () => {
-    expect(tierOf(`what is a closure?`, { unattended: true })).toBe(`standard`);
-});
-
-test("a gate reports itself and scores 1, so the ledger can tell a gate from a hard sentence", () => {
-    const verdict = judgeComplexity(turn(`hi`, { unattended: true }));
-
-    expect(verdict.score).toBe(1);
-    expect(verdict.rules).toContain(`unattended`);
-});
-
-test.each([
-    [`pasted code`, "explain this\n```ts\nconst x = 1;\n```"],
-    [`a stack trace`, "it broke\n  at Object.run (/work/x.ts:12:3)"],
-    [`a thrown error`, "help\nTypeError: cannot read properties of undefined"],
-    [`a hard word`, `why does the picker reset`],
-    [`another hard word`, `refactor this`],
-    [`a second job`, `rename it and then update the tests`],
-    [`a checklist`, `- rename it\n- update the tests`],
-    [`a cross-cutting scope`, `rename it across the codebase`],
-])("%s forces the user's own model even in an otherwise tiny prompt", (_name, prompt) => {
-    expect(tierOf(prompt)).toBe(`standard`);
-});
-
-test("an escalating rule beats every easing feature at once, so rule order cannot change an answer", () => {
-    // This prompt trips every easing weight in the file, plus one escalating rule; escalation still wins.
-    const verdict = judgeComplexity(turn(`what is a race condition?`));
-
-    expect(verdict.tier).toBe(`standard`);
-    expect(verdict.score).toBe(1);
-    expect(verdict.rules).toEqual([`hard-words`]);
-});
-
-test("a long brief is standard on its length alone, whatever words it happens to use", () => {
-    expect(tierOf(`explain `.repeat(400))).toBe(`standard`);
-});
-
-test("three files in, the job is about a shape rather than about a file", () => {
-    expect(tierOf(`have a look`, { attachments: 3 })).toBe(`standard`);
-    expect(tierOf(`have a look`, { attachments: 1 })).toBe(`standard`);
-});
-
-test("names every rule that fired, because a score alone cannot say which feature did the work", () => {
-    const verdict = judgeComplexity(turn(`what is this?`));
-
-    expect(verdict.rules).toEqual([`short-prompt`, `easy-words`, `bare-question`, `no-workspace-reference`]);
-});
-
-test("scores are rounded, so two turns the same rules judged compare equal on the ledger", () => {
-    const score = judgeComplexity(turn(`what is this?`)).score;
-
-    expect(score).toBe(Number(score.toFixed(3)));
-});
-
-test("the score never leaves 0..1, so a stored row is always comparable against the ceiling", () => {
-    const floor = judgeComplexity(turn(`what is this?`));
-    const ceiling = judgeComplexity(turn(`refactor everything`));
-
-    expect(floor.score).toBeGreaterThanOrEqual(0);
-    expect(ceiling.score).toBeLessThanOrEqual(1);
-});
-
-// eagerness moves only the cutoff; a downgrade still needs a positive easy signal at any setting.
-
-test("the dial widens what counts as simple, in the direction it says", () => {
-    // Eased by its words, held back by naming a real file; balanced keeps it standard, eager lets it through.
-    const aboutAFile = `explain what src/app.ts does`;
-
-    expect(tierOf(aboutAFile, { eagerness: `balanced` })).toBe(`standard`);
-    expect(tierOf(aboutAFile, { eagerness: `eager` })).toBe(`fast`);
-});
-
-test("the cautious stop wants every easing signal at once, not merely an easy word", () => {
-    // "explain closures" fails the cautious stop (not a bare question); only a bare question clears every stop.
-    expect(tierOf(`explain closures`, { eagerness: `balanced` })).toBe(`fast`);
-    expect(tierOf(`explain closures`, { eagerness: `cautious` })).toBe(`standard`);
-    expect(tierOf(`what is a closure?`, { eagerness: `cautious` })).toBe(`fast`);
-});
-
-test("an absent dial is the balanced stop, so every row recorded before it existed still compares", () => {
-    const bare = judgeComplexity(turn(`what is this?`));
-
-    expect(bare.ceiling).toBe(FAST_CEILING);
-    expect(bare.tier).toBe(judgeComplexity(turn(`what is this?`, { eagerness: `balanced` })).tier);
-});
-
-test("no setting of the dial can downgrade a short vague request", () => {
-    for (const eagerness of [`cautious`, `balanced`, `eager`] as const) {
-        expect(tierOf(`fix the bug`, { eagerness })).toBe(`standard`);
-        expect(tierOf(`have a look at the thing we discussed`, { eagerness })).toBe(`standard`);
-    }
-});
-
-test("the deceptive follow-up is standard at every stop, because it never says anything easy", () => {
-    for (const eagerness of [`cautious`, `balanced`, `eager`] as const) {
-        expect(tierOf(`now do the same for the other file`, { eagerness, afterHardTurn: true })).toBe(`standard`);
-    }
-});
-
-test("a turn following hard work has to clear a higher bar, and at the default an eased one no longer does", () => {
-    expect(tierOf(`explain closures`)).toBe(`fast`);
-    expect(tierOf(`explain closures`, { afterHardTurn: true })).toBe(`standard`);
-});
-
-test("the verdict carries the cutoff it was judged against, because a score alone stopped being an answer", () => {
-    const cautious = judgeComplexity(turn(`explain closures`, { eagerness: `cautious` }));
-    const eager = judgeComplexity(turn(`explain closures`, { eagerness: `eager` }));
-
-    expect(cautious.ceiling).toBeLessThan(FAST_CEILING);
-    expect(eager.ceiling).toBeGreaterThan(FAST_CEILING);
-    expect(cautious.score).toBe(eager.score);
-    expect([cautious.tier, eager.tier]).toEqual([`standard`, `fast`]);
-});