@intentic/sandbox-contract 1.226.1 → 1.227.0

package/dist/starter.d.ts

@@ -0,0 +1,3 @@
+export declare const STARTER_REPO = "site";
+export declare const STARTER_APP = "landing";
+//# sourceMappingURL=starter.d.ts.map

package/dist/starter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starter.d.ts","sourceRoot":"","sources":["../src/starter.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY,SAAS,CAAC;AACnC,eAAO,MAAM,WAAW,YAAY,CAAC"}

package/dist/starter.js

@@ -0,0 +1,3 @@
+export const STARTER_REPO = "site";
+export const STARTER_APP = "landing";
+//# sourceMappingURL=starter.js.map

package/dist/starter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"starter.js","sourceRoot":"","sources":["../src/starter.ts"],"names":[],"mappings":"AAWA,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC;AACnC,MAAM,CAAC,MAAM,WAAW,GAAG,SAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentic/sandbox-contract",
-  "version": "1.226.1",
+  "version": "1.227.0",
   "description": "oRPC wire contract for the intentic sandbox daemon, shared by the daemon and its browser client",
   "license": "MIT",
   "type": "module",
@@ -89,14 +89,15 @@
     "@orpc/contract": "1.14.13",
     "tslib": "2.8.1",
     "zod": "4.4.3",
-    "@intentic/constants": "1.226.1",
-    "@intentic/extension-manifest": "1.226.1",
-    "@intentic/registry": "1.226.1"
+    "@intentic/constants": "1.227.0",
+    "@intentic/registry": "1.227.0",
+    "@intentic/extension-manifest": "1.227.0"
   },
   "devDependencies": {
     "@types/node": "24.13.2",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
     "vitest": "4.1.10",
+    "@intentic/testing": "0.0.0",
     "@intentic/tsconfig": "0.0.0"
   },
   "scripts": {

package/src/contract-lock.test.ts

@@ -5,8 +5,14 @@ import { currentLock } from "./contract-lock.js";
 /* The committed lock and the code must say the same thing: see contract-lock.ts for what the pair buys.
  *
  * This is the HALF that runs everywhere the tests run; the other half (a shrunk lock needs a declared break)
- * lives in prepass.mjs, which has git and this suite does not. */
-test("contract.lock.json matches the schemas this package exports", () => {
+ * lives in prepass.mjs, which has git and this suite does not.
+ *
+ * ITS OWN BUDGET, because the default one is a HANG DETECTOR and this test does real work: it serializes every
+ * schema this package exports, ~500 of them, to JSON Schema. That is ~100ms with the machine to itself and it
+ * measured 8.8s on a runner running every package's suite at once, so vitest's 5s default failed it as a hang
+ * over a contract that had not moved: green on a box, red on a busy runner, the trap _tools/testing/src/vitest
+ * .ts is written against. 30s is well clear of the work and still reports a genuine hang inside half a minute. */
+test("contract.lock.json matches the schemas this package exports", { timeout: 30_000 }, () => {
     const committed: unknown = JSON.parse(readFileSync(new URL("../contract.lock.json", import.meta.url), "utf8"));
     expect(
         currentLock(),

package/src/contracts/logs.contract.ts

@@ -1,8 +1,10 @@
 import { oc } from "@orpc/contract";
-import { LogReadQuerySchema, LogReadSchema, LogsListSchema } from "../schemas.js";
+import { ClientDiagnosticsAcceptedSchema, ClientDiagnosticsReportSchema, LogReadQuerySchema, LogReadSchema, LogsListSchema } from "../schemas.js";
 
 // Daemon-owned debug logs (historyRoot/logs): terminal pipe-pane captures, intentic CLI run logs, daemon.log.
-// Read-only by design, the files are written by the daemon/tmux only, so the record stays trustworthy.
+// Reads are read-only by design, the files are written by the daemon/tmux only, so the record stays
+// trustworthy. `report` is the one write, and the exception that proves the rule: the browser is the only
+// witness to its own crashes, and a record it cannot reach is a record that has nothing to say about them.
 export const logsContract = {
     list: oc
         .route({
@@ -22,4 +24,23 @@ export const logsContract = {
         })
         .input(LogReadQuerySchema)
         .output(LogReadSchema),
+    /* What the browser saw. The counterpart to every other route here: those serve what the daemon wrote down,
+     * this accepts what only the browser could have known.
+     *
+     * A WRITE from the client, which every other log route deliberately is not, and the trust argument is the
+     * inverse of theirs: the reads are trustworthy because only the daemon writes them, and this is trustworthy
+     * only about ITSELF. So it lands in its own file, never daemon.log, and its lines say plainly that a browser
+     * said them. It floors at viewer rather than the maintainer the logs prefix takes, because a viewer whose
+     * page just white-screened is exactly who needs to be able to report it, and cannot raise their own role to
+     * do it. */
+    report: oc
+        .route({
+            method: "POST",
+            path: "/logs/client",
+            summary: "Report what the browser saw",
+            description:
+                "Errors the app caught, stalls it measured, and recoveries it performed, written to a log of their own. The browser is the only witness to these, so without it a bug someone hit in their own browser leaves no record at all.",
+        })
+        .input(ClientDiagnosticsReportSchema)
+        .output(ClientDiagnosticsAcceptedSchema),
 };

package/src/events.ts

@@ -387,6 +387,19 @@ export const RestoredMessageSchema = z.object({
         .describe(
             "A person wrote this in the agent's voice, with no turn behind it. Marked for the human re-reading the conversation months later, so their own words do not pass as the agent's. The agent itself never sees the mark.",
         ),
+    /* THE ONE-PRESS OFFER A RECORDED NOTICE CARRIES (notice rows only), named rather than inferred from its
+     * words. Only `tierHold` today: the line saying this turn ran on a cheaper model, whose offer is "keep this
+     * chat on my pick".
+     *
+     * It is on the wire because the offer has to survive a reopen, and a reopened tab has only the record. The
+     * chat's other one-press notices are drawn live and never recorded, so they never needed this; a routed turn
+     * is different precisely because the whole point of recording it is that somebody reads it LATER. A KIND, not
+     * a callback, exactly as the live ones are: the reader decides what the press does and whether the offer
+     * still stands (a chat already holding its pick shows a settled sentence, not a stale button). */
+    noticeAction: z
+        .enum(["tierHold"])
+        .optional()
+        .describe("A one-press follow-up this recorded notice offers, by name. The chat decides what it does and whether it still applies."),
 });
 export type RestoredMessage = z.infer<typeof RestoredMessageSchema>;
 
@@ -667,6 +680,33 @@ export const AgentEventSchema = z.discriminatedUnion("kind", [
         // wasn't asked for.
         reason: z.string().optional(),
     }),
+    /* WHAT THE COMPLEXITY JUDGE MADE OF THIS TURN, emitted once at turn start on every judged turn (that is,
+     * whenever settings.autoTier is not "off"), for the same reason fast_mode exists: a mechanism that can
+     * change what a turn runs on fails silently unless the daemon says what it decided. One tiny frame per
+     * turn, deliberately on the standard verdicts too, because the client's composer preview needs the
+     * conversation's LAST verdict (prompt-complexity.ts `afterHardTurn`) and a frame only on the interesting
+     * turns would leave it guessing on the common ones.
+     *
+     * `tier`/`score`/`rules` are the verdict verbatim (judgeComplexity): the rules are the named-feature
+     * vocabulary of ComplexityRule, carried as strings so a frame from a build with a rule this client hasn't
+     * heard of still parses. `model` is present only when a substitution actually applies to THIS turn, which
+     * is `routed` (mode on, verdict fast, something cheaper published) or `held` (the same turn the user pinned
+     * to their pick, see AgentTurn.tierHold): measure mode never names one because naming it would cost the
+     * catalog read shadow mode exists to avoid.
+     *
+     * `routed` is what HAPPENED, never implied by the verdict: a fast verdict in measure mode, under a hold, or
+     * with nothing cheaper published all run the user's own pick and say `routed: false`. */
+    z.object({
+        kind: z.literal("tier"),
+        tier: z.enum(["fast", "standard"]),
+        score: z.number(),
+        rules: z.array(z.string()),
+        // The cheaper model this turn ran on (routed) or would have run on (held). Absent otherwise.
+        model: z.string().optional(),
+        routed: z.boolean(),
+        // The user pinned this turn to their pick (AgentTurn.tierHold), so a fast verdict moved nothing.
+        held: z.boolean().optional(),
+    }),
     /* The turn is alive but WAITING on the provider: a request failed transiently (5xx, 529, a dropped socket)
      * and the harness is retrying it inside this same turn. A status, not a failure, nothing has been lost and
      * the turn may still finish normally, so the client renders it where "thinking" goes rather than in the
@@ -677,7 +717,10 @@ export const AgentEventSchema = z.discriminatedUnion("kind", [
      * a hang. The one action a user takes against an apparent hang is Stop, which is the only action that
      * actually loses the work, so the wait has to be visible, with its own next-attempt clock.
      *
-     * `attempt`/`maxAttempts` are the harness's own counters; `nextAttemptAt` (epoch ms) is when it will try
+     * `attempt` is the harness's own counter and `maxAttempts` is the bound that will actually be honoured,
+     * which on the Claude path is the daemon's own cap on how deep a storm may get rather than the harness's
+     * far longer budget (MAX_IN_TURN_RETRIES in sdk-stream.ts, which ends the turn at the cap and hands the
+     * waiting to the outage breaker). `nextAttemptAt` (epoch ms) is when it will try
      * again, so the readout counts down instead of freezing on a number nobody can interpret. BOTH are optional
      * for the same reason, which is that each runtime publishes a different half of the wait and none of them
      * publishes all of it: Claude's harness reports the delay and the bound, Codex says which attempt it is on
@@ -855,6 +898,14 @@ export const AgentEventSchema = z.discriminatedUnion("kind", [
                 "unknown-command",
                 "grok-model-invalid",
                 "codex-model-invalid",
+                /* THE MODEL CANNOT HOLD A TURN OF THIS AGENT LOOP, so the daemon refused before sending
+                 * (agent/context-budget.ts). Its own code because none of the neighbours describes it: nothing is
+                 * disconnected, nothing is spent, nothing comes back on a clock, and re-sending the same request
+                 * at the same model fails identically forever. What changes the outcome is the model or the
+                 * server's context flag, so the message names both and the client HOLDS the words: they never
+                 * reached anything, and losing them to a configuration fact would be the one part of this that
+                 * was our fault. */
+                "context-window-too-small",
                 "subscription-required",
                 "agent-busy",
             ])

package/src/index.ts

@@ -60,6 +60,7 @@ export { hostContract } from "./contracts/host.contract.js";
 export { intenticContract } from "./contracts/intentic.contract.js";
 export { inventoryContract } from "./contracts/inventory.contract.js";
 export { logsContract } from "./contracts/logs.contract.js";
+export { REQUEST_ID_EVIDENCE_ROUTE, REQUEST_ID_HEADER } from "./request-id.js";
 export { loopsContract } from "./contracts/loops.contract.js";
 export { panelsContract } from "./contracts/panels.contract.js";
 export { portsContract } from "./contracts/ports.contract.js";
@@ -113,6 +114,7 @@ export * from "./output-fields.js";
 export * from "./publish-drafts.js";
 export * from "./schemas.js";
 export * from "./search-globs.js";
+export * from "./starter.js";
 export * from "./terminal-protocol.js";
 export * from "./title.js";
 export * from "./versions.js";

package/src/prompt-complexity.test.ts

@@ -158,3 +158,72 @@ test("the score never leaves 0..1, so a stored row is always comparable against
     expect(floor.score).toBeGreaterThanOrEqual(0);
     expect(ceiling.score).toBeLessThanOrEqual(1);
 });
+
+// --- the one dial, and the property it may not move ------------------------------------------------------
+
+/* The owner can move the cutoff (settings.autoTierEagerness) because "err toward my model or toward the cheap
+ * one" is a preference nobody else can hold for them. What these pin is that the dial moves the cutoff and
+ * NOTHING else, in particular not the rule that a downgrade needs something positively easy to have been said,
+ * which was the property the old ceiling held only by arithmetic coincidence. */
+
+test("the dial widens what counts as simple, in the direction it says", () => {
+    // A question about a real file: eased by its words, held back by naming a path. The middle stop keeps it on
+    // the user's pick, and the eager stop is precisely the choice to let 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", () => {
+    // Its whole content: leave no room for doubt. A statement in easy words still qualifies at the default,
+    // and does not here; only a short bare question naming no file survives 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", () => {
+    // The whole safety argument for offering an eager stop at all. Absence of complexity is not evidence of
+    // simplicity at ANY cutoff, so this is a rule in the judge rather than a sum that happens to clear it.
+    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", () => {
+    /* "now do the same for the other file" is the case the whole afterHardTurn signal was built for, and the
+     * easing rule turns out to answer it more strongly than any cutoff can: those words make no positive claim
+     * of ease, so no setting of the dial reaches them. The weight still does its own job one test down. */
+    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", () => {
+    // It raises the bar rather than locking the door (see ComplexityInput.afterHardTurn), so this is a shift of
+    // one stop's worth, not a gate: the same words that route in a fresh conversation stay put in a hard one.
+    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", () => {
+    // With the cutoff an owner setting, the same 0.35 is standard on one stop and fast on another. A ledger of
+    // bare scores could not tell those two rows apart; the ceiling beside each is what keeps a refit honest.
+    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);
+    // Same words, same score, opposite verdicts: the pair that a column of bare scores could not have told apart.
+    expect(cautious.score).toBe(eager.score);
+    expect([cautious.tier, eager.tier]).toEqual([`standard`, `fast`]);
+});

package/src/prompt-complexity.ts

@@ -89,6 +89,10 @@ export interface ComplexityInput {
      * or the feature switched off) says nothing about the difficulty of the work, and reading it as escalation
      * would make the sandbox's configuration leak into its opinion about a sentence. */
     readonly afterHardTurn: boolean;
+    /* HOW EAGER THE OWNER ASKED THIS TO BE (settings.autoTierEagerness), the one preference the judge takes.
+     * Absent ⇒ `balanced`, which is the stop every verdict recorded before the knob existed was judged
+     * against, so an absent value and an old row mean the same thing. See FAST_CEILINGS. */
+    readonly eagerness?: TierEagerness;
 }
 
 export interface ComplexityVerdict {
@@ -99,6 +103,10 @@ export interface ComplexityVerdict {
     // Every rule that fired, in declaration order. Empty is legal and means "nothing distinctive": the score is
     // the base, which sits above the fast ceiling, so an unremarkable turn stays on the user's own pick.
     readonly rules: readonly ComplexityRule[];
+    /* The cutoff this score was judged against, carried out so the caller can record it beside the score.
+     * A score is only half a verdict once the ceiling is a setting: 0.35 was standard yesterday and is fast
+     * today, and a refit reading a column of bare scores could not tell those rows apart. */
+    readonly ceiling: number;
 }
 
 /* WHERE AN UNREMARKABLE TURN STARTS, and it starts ABOVE the fast ceiling on purpose: a prompt that matches no
@@ -107,10 +115,35 @@ export interface ComplexityVerdict {
  * escalation, and a user who stops trusting the feature. */
 const BASE_SCORE = 0.5;
 
-// Fast iff the score lands at or below this. Exported because the shadow ledger's whole purpose is to let this
-// be re-fitted against real traffic rather than argued about, and a reader of a stored score needs the ceiling
-// that score was judged against.
-export const FAST_CEILING = 0.25;
+/* HOW EAGER THE JUDGE IS, the one knob this feature exposes, and deliberately the only one.
+ *
+ * The routing literature's own answer to "how do you tune a router in public" is a single aggressiveness
+ * threshold (RouteLLM ships it in the model name, `router-mf-0.3` against `router-mf-0.7`); everything else it
+ * learns stays inside. Same here: the weights below are a hypothesis with a ledger under them and are nobody's
+ * business, while "should this err toward my model or toward the cheap one" is a preference only the owner can
+ * hold, and the shadow numbers are useless without a way to act on what they say.
+ *
+ * THREE NAMED STOPS, not a slider, because the page has no slider idiom and, more to the point, a continuous
+ * control here invites fiddling with a number whose meaning nobody can feel. Each stop is a sentence about
+ * which turns move:
+ *   cautious — every easing signal at once and nothing pulling the other way: a short bare question, in easy
+ *              words, naming no file. "what is a closure?" and very little else. The zero is not a disabled
+ *              state, it is the floor the score clamps to, so it means exactly "leave no room for doubt".
+ *   balanced — the shipped default, and what every stored verdict before this knob existed was judged against.
+ *              Easy words carry a turn on their own; naming a file still holds it back.
+ *   eager    — an easy-worded question about real code goes too ("explain what this file does").
+ *
+ * NONE OF THEM CAN REACH THE ABSENCE FEATURES, at any setting, because that property is enforced structurally
+ * now rather than by the weights happening to sum above the ceiling (see `easing` below). That is what makes an
+ * eager stop safe to offer at all: raising a bare number would, at 0.3, have started downgrading every short
+ * vague request in the product, which is the single worst population to be wrong about. */
+export const FAST_CEILINGS = { cautious: 0, balanced: 0.25, eager: 0.4 } as const;
+export type TierEagerness = keyof typeof FAST_CEILINGS;
+
+// The stop a turn is judged against when nobody has chosen one, and the one every verdict recorded before the
+// knob existed was judged against. Exported because a reader of a stored score needs the ceiling behind it, and
+// a row written before ceilings were recorded was written against exactly this.
+export const FAST_CEILING = FAST_CEILINGS.balanced;
 
 // Characters, not tokens: nothing here can tokenize, and for a threshold the constant cancels. ~600 chars is
 // where a request stops being a sentence and starts being a brief; ~2400 is where it is carrying pasted
@@ -215,38 +248,56 @@ const forcing = (input: ComplexityInput, text: string): ComplexityRule[] => {
  * nothing, which is exactly why the mechanism ships in shadow first — see docs/model-routing-design.md §4. They
  * are not a claim, they are a hypothesis with a ledger under it.
  *
- * ONE PROPERTY IS NOT A HYPOTHESIS AND MUST SURVIVE ANY REFIT: the two ABSENCE features (`short-prompt`,
- * `no-workspace-reference`) are too light to reach the ceiling together. Absence of complexity is not evidence
- * of simplicity — "fix the bug" is four words naming no file and is not a cheap turn — so a downgrade always
- * requires something POSITIVE to have been said, which in practice means `easy-words` or `bare-question`
- * carrying it. Weighted the obvious way instead, the judge downgraded every short vague request in the
- * product, which is the single worst population to be wrong about. */
-const GRADED: readonly { readonly rule: ComplexityRule; readonly weight: number; readonly of: (input: ComplexityInput, text: string) => boolean }[] =
-    [
-        { 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 },
-        // Enough on its own to hold an easy-worded question at standard: "explain what this file does" is a
-        // question about real code in this repo, and the cheap rung's failures on real code are the silent kind.
-        { 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,
-        },
-        // The heaviest single weight, because it is the only feature that can see past the words. See
-        // ComplexityInput.afterHardTurn for why it is a weight rather than the gate it was designed as.
-        { rule: "after-hard-turn", weight: +0.25, of: (input) => input.afterHardTurn },
-        // The two absence features, deliberately light; see the note above the list.
-        { rule: "short-prompt", weight: -0.1, of: (_input, text) => text.length <= SHORT_PROMPT_CHARS },
-        { rule: "easy-words", weight: -0.25, of: (_input, text) => EASY_WORDS.test(text) },
-        { rule: "bare-question", weight: -0.15, 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),
-        },
-    ];
+ * ONE PROPERTY IS NOT A HYPOTHESIS AND MUST SURVIVE ANY REFIT, and it is a RULE here rather than an accident of
+ * arithmetic: absence of complexity is not evidence of simplicity. "fix the bug" is four words naming no file
+ * and is not a cheap turn, so a downgrade always requires something POSITIVE to have been said — an easy word,
+ * or a bare question. Those two are marked `easing`, and `judgeComplexity` refuses a fast verdict without one
+ * whatever the score says.
+ *
+ * It used to hold only because the two ABSENCE features (`short-prompt`, `no-workspace-reference`) summed to
+ * 0.3 against a ceiling of 0.25, which is a coincidence of two numbers rather than a property, and the moment
+ * the ceiling became a setting it was one click from being false. Weighted the obvious way, the judge
+ * downgraded every short vague request in the product, which is the single worst population to be wrong
+ * about. */
+interface GradedFeature {
+    readonly rule: ComplexityRule;
+    readonly weight: number;
+    readonly of: (input: ComplexityInput, text: string) => boolean;
+    // A POSITIVE reason to think this is easy, as opposed to the mere absence of reasons to think it is hard.
+    // At least one has to fire before any turn is called fast; see the note above.
+    readonly easing?: true;
+}
+
+const GRADED: readonly GradedFeature[] = [
+    { 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 },
+    // Enough on its own to hold an easy-worded question at standard on the middle stop: "explain what this file
+    // does" is a question about real code in this repo, and the cheap rung's failures on real code are the
+    // silent kind. The `eager` stop is precisely the choice to let that one through.
+    { 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,
+    },
+    // The heaviest single weight, because it is the only feature that can see past the words. See
+    // ComplexityInput.afterHardTurn for why it is a weight rather than the gate it was designed as. Heavy enough
+    // that even the eager stop cannot route a follow-up to hard work on easy words alone.
+    { rule: "after-hard-turn", weight: +0.25, of: (input) => input.afterHardTurn },
+    /* The easing half, in the order it has always been declared, because that order is the order a verdict
+     * lists its rules in and the ledger has rows written against it. `easing` marks the two POSITIVE ones, one
+     * of which every fast verdict must carry; the other two are the absence features, deliberately light and,
+     * by the rule above, never enough by themselves. */
+    { 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),
+    },
+];
 
 // Three places, so a stored score is a value rather than a float artefact and two rows written by the same
 // rules compare equal.
@@ -258,14 +309,26 @@ const round3 = (value: number): number => Math.round(value * 1000) / 1000;
  * up a tier, never silently move a different set of turns down.
  *
  * Only what survives all of that gets scored, which keeps the graded layer doing the one job it is good at:
- * separating "explain this" from "wire this up" among requests that look alike. */
+ * separating "explain this" from "wire this up" among requests that look alike.
+ *
+ * TWO CONDITIONS FOR FAST, not one, and the second is the one that does not move: the score has to clear the
+ * owner's chosen ceiling AND something POSITIVE has to have been said (a `easing` feature). The ceiling is a
+ * preference and belongs to whoever pays the bill; "we downgraded it because you didn't say much" is not a
+ * preference, it is a bug, and it stays impossible at every stop of the knob. */
 export const judgeComplexity = (input: ComplexityInput): ComplexityVerdict => {
+    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 };
+        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)));
-    return { tier: score <= FAST_CEILING ? "fast" : "standard", score: round3(score), rules: hits.map((feature) => feature.rule) };
+    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,
+    };
 };

package/src/request-id.ts

@@ -0,0 +1,41 @@
+/* THE ONE HEADER THAT JOINS A BROWSER CALL TO THE DAEMON LINE THAT SERVED IT.
+ *
+ * Both halves of a slow interaction were already measured and could not be put together. The browser times
+ * `rpc.request`, what the user actually waited for; the daemon times `http.request`, what it served; and on a
+ * sandbox answering several calls a second the only way to pair them was by timestamp and hope. So "the panel
+ * stuttered" stayed unattributable even with both numbers in hand, which is the gap the daemon's own perf module
+ * says it exists to close and could only close on its own side of the wire.
+ *
+ * Here rather than as a literal on each side, because a header name that disagrees across the wire fails
+ * SILENTLY: the browser sends a field nobody reads and the daemon logs nothing, which looks exactly like a quiet
+ * system. Both sides import this.
+ *
+ * The NAME only. The browser mints the value with the app's own `composables/uuid.ts`, which already solves the
+ * one hard part (`crypto.randomUUID` is a secure-context api and a self-hosted instance on a LAN address does
+ * not have it), and the daemon only ever reads what it is given. A generator here would be a second answer to a
+ * question that already has a better one. The value is a correlation token and never a security boundary: the
+ * daemon records it and decides nothing on it, so a caller repeating one confuses a log and nothing else. */
+export const REQUEST_ID_HEADER = "x-intentic-request-id";
+
+/* WHEN A BROWSER MAY SEND IT, and this is not the additive change it looks like.
+ *
+ * A custom request header is the one wire addition that is NOT backward compatible, because the browser does not
+ * get to decide it: a header outside the CORS safelist forces a preflight, and a daemon whose `allowHeaders`
+ * predates this name answers a preflight that omits it. The browser then fails the whole request rather than
+ * dropping the header. Sent unconditionally, this turns "one field the daemon never logs" into EVERY typed call
+ * to that daemon failing at the transport, `system.events` included, so the stream never opens, the connection
+ * never reaches `online`, and the app settles on "Busy, catching up" forever against a sandbox that is up and
+ * healthy and answering `/health` in a millisecond.
+ *
+ * That state is not exotic. A browser newer than its daemon is the NORMAL case and a supported one, both in
+ * production (every user's sandbox runs whatever image they last chose to pull, and COMPATIBILITY.md's second
+ * promise is that no update is ever forced) and in development (the web app runs from the working tree, the
+ * daemon is baked into the last `pnpm build:sandbox`). See the web app's useDaemonRoutes.ts, which exists to say
+ * exactly this.
+ *
+ * So the header ships gated on POSITIVE evidence, and this names the evidence: `logs.report` is the route that
+ * landed in the same commit as the `allowHeaders` entry, so a daemon advertising it on its hello frame is a
+ * daemon whose CORS accepts the header. Note the polarity is the opposite of `supportsRoute`'s: there, no
+ * evidence means assume-supported, because hiding a working feature is the greater harm; here, no evidence must
+ * mean DO NOT SEND, because sending costs the entire connection and the header buys a log field. */
+export const REQUEST_ID_EVIDENCE_ROUTE = "logs.report";