@intentic/sandbox-contract 1.245.0 → 1.246.1

package/src/schemas/provider-oauth.ts

@@ -64,68 +64,65 @@ export const AccountListQuerySchema = z.object({
 });
 // Address one account of a provider (disconnect, and the turn's `account`).
 export const AccountIdSchema = z.object({ id: z.string().min(1).describe("Which account.") });
-// Rename one account of a provider whose credential the sandbox owns (Claude, Kimi). Blank ⇒ the daemon falls
-// back to the derived name, so clearing a label restores the sign-in identity rather than leaving a nameless
-// row. Grok is absent for the same reason it holds one account: OpenCode owns that credential, not this store.
+// Rename one account of a provider whose credential the sandbox owns. Blank ⇒ the daemon falls back to the
+// derived name, so clearing a label restores the sign-in identity rather than leaving a nameless row.
 export const AccountRenameSchema = z.object({
     id: z.string().min(1).describe("Which account."),
     label: z.string().max(80).describe("The new name. Blank restores the one derived from the sign-in, rather than leaving a nameless row."),
 });
-// The completing calls carry the user-chosen label (blank ⇒ the daemon derives one from the sign-in identity
-// or a provider default).
-export const OauthExchangeSchema = z.object({
-    code: z.string().min(1).describe("The code the sign-in handed back."),
-    verifier: z.string().min(1).describe("The proof from the start of the handshake, which is what stops somebody else's code being redeemed here."),
-    state: z.string().min(1).describe("The handshake this belongs to. A mismatch is refused."),
-    label: z.string().optional().describe("What to call the account. Blank derives one from the sign-in."),
-});
-export const AuthorizeChallengeSchema = z.object({
-    authorizeUrl: z.string().describe("Where to send somebody to sign in."),
-    verifier: z.string().describe("Keep this and send it back when finishing. It is what proves the code that comes back belongs to this handshake."),
-    state: z.string().describe("The handshake's own id, sent back with it."),
-});
-/* CURSOR'S SIGN-IN START. A third login shape, and the reason it is not one of the two above is where the
- * SECRET lives during the handshake.
+/* ONE SIGN-IN SHAPE FOR EVERY ACCOUNT THE SANDBOX ITSELF HOLDS, whatever the vendor's mechanism underneath.
  *
- * Claude's is paste-back: the browser receives a code and the caller hands it plus its verifier to `exchange`,
- * so the handshake's proof has to travel on the wire and AuthorizeChallengeSchema carries it. Cursor's PKCE
- * verifier must never leave the process that generated it, anyone holding it can redeem the login and mint a
- * durable key, so the daemon starts the whole flow, keeps the verifier in memory, polls Cursor itself, and
- * writes the account when it lands. Nothing redeemable is on this shape at all.
- *
- * Which makes it behave like a DEVICE flow from the caller's side (open the page, then watch the account list),
- * except that there is no one-time code to display: the login page is addressed to this handshake already. So
- * DeviceStartSchema's `code` would be a permanently blank field on every card, and TranslatorStartSchema's
- * `state` a value nothing sends back. `handshake` is neither, it is a cancellation handle. */
-export const CursorLoginStartSchema = z.object({
-    url: z.string().describe("The page to open and sign in on. It is already addressed to this attempt, so there is no code to type."),
+ * Four handshakes used to answer four shapes, and the shapes differed in where the SECRET lived during the
+ * handshake. Anthropic's is paste-back: the browser shows a code and the user brings it here. Cursor's PKCE
+ * verifier must never leave the process that generated it (anyone holding it can redeem the login and mint a
+ * durable key), so the daemon runs the whole flow and the caller only watches the account list. xAI's is a
+ * device code. Meta's and Z.ai's mint the vendor's own key, by a device poll or by a redirect that dead-ends in
+ * the user's address bar. Every one of them is now the daemon's to hold: nothing redeemable is on this shape,
+ * and the one thing the caller can hand back (a code off a page, or the address a redirect landed on) goes to
+ * `complete` with the attempt's handshake. `flow` says how the attempt ENDS, which is the only thing a card
+ * cannot infer from the fields: a device sign-in finishes upstream and the account appears on its own; a
+ * redirect needs the landing address brought back; a paste needs the code the page showed. */
+export const LoginFlowSchema = z.enum(["device", "redirect", "paste"]);
+export type LoginFlow = z.infer<typeof LoginFlowSchema>;
+export const LoginStartSchema = z.object({
+    url: z.string().describe("The page to open and sign in on."),
+    code: z.string().describe("The one-time code the page will ask for, where the vendor issues one. Blank when the page is already addressed to this attempt."),
+    state: z
+        .string()
+        .describe("For a redirect sign-in, the marker in the address the browser lands on, so a pasted URL can be recognised as this attempt's. Blank otherwise."),
+    flow: LoginFlowSchema.describe(
+        "How this attempt ends. A device sign-in finishes by itself and you watch the account list; a redirect needs the address it landed on handed back; a paste needs the code the page showed.",
+    ),
+    variant: z.string().describe("Which of the provider's estates this attempt signs in to. Blank for a provider with one."),
     handshake: z
         .string()
-        .describe(
-            "This attempt's id, for abandoning it. Not a credential and not redeemable: the proof that finishes the sign-in never leaves the sandbox.",
-        ),
+        .describe("This attempt's id, for finishing or abandoning it. Not a credential and not redeemable: the proof that completes the sign-in never leaves the sandbox."),
     expiresAt: z.number().describe("When this attempt stops being answerable, in milliseconds, so a card can stop waiting instead of spinning."),
 });
-export type CursorLoginStart = z.infer<typeof CursorLoginStartSchema>;
-// Abandon a sign-in nobody completed, so the daemon stops polling Cursor for it. Ordinary tidiness rather than
-// a security boundary: an unanswered attempt also times out on its own (see `expiresAt`).
-export const CursorLoginCancelSchema = z.object({ handshake: z.string().min(1).describe("Which attempt to stop waiting on.") });
-// xAI Grok (via OpenCode) uses subscription OAuth via the headless device-code method. `start` returns the
-// `url` the user opens (xAI's verification_uri_complete, which pre-fills the code) and `code`, the same
-// one-time code, surfaced so the card matches x.ai exactly. There is no paste-back: OpenCode polls to
-// completion and the UI polls `/grok/accounts`.
-// ponytail: OpenCode holds one xAI auth per data dir, so Grok stays single-account, the list is 0 or 1. Per
-// account would need an OpenCode server per data dir; add when there's demand.
-// A device-code login start: the verification URL + the one-time code the user enters there. The native Grok
-// flow (via OpenCode), see TranslatorStartSchema for the routed-provider connect, which adds `state`.
-export const DeviceStartSchema = z.object({
-    url: z.string().describe("The page to open, which already has the code in it."),
-    code: z
-        .string()
-        .describe(
-            "The one-time code, shown as well so the page and the card say the same thing. Nothing is pasted back: the sandbox waits for the sign-in to complete on its own.",
-        ),
+export type LoginStart = z.infer<typeof LoginStartSchema>;
+// The estate to sign in to, where a provider has more than one (Z.ai's international and mainland plans). Absent
+// takes the provider's default, which is what a provider with a single estate always sends.
+export const LoginRequestSchema = z.object({
+    variant: z.string().min(1).optional().describe("Which estate to sign in to. Absent takes the provider's default."),
+});
+/* The half a person brings back, for the two flows that have one: the code the page showed (a paste), or the
+ * whole address a redirect landed on. Not the handshake's state, unlike the translator's version below: that
+ * one addresses a session CLIProxyAPI holds, so the state has to travel, while this handshake is held right
+ * here and taking the caller's word for its own state would be checking a claim against itself. */
+export const LoginCompleteSchema = z.object({
+    handshake: z.string().min(1).describe("Which attempt this belongs to."),
+    code: z.string().optional().describe("The code the sign-in page showed, for a paste sign-in."),
+    redirectUrl: z.string().optional().describe("The address the browser was sent to, whole, for a redirect sign-in. The grant is inside it."),
+    label: z.string().optional().describe("What to call the account. Blank derives one from the sign-in."),
+});
+// What finishing hands back: the account, where the exchange answers with one at once (a paste); absent where
+// the daemon still has a mint to do behind the answer and the row lands in the account list minutes later.
+export const LoginCompletedSchema = z.object({
+    account: OauthAccountSchema.optional().describe("The account it connected, where the sign-in ends here. Absent means keep watching the account list."),
 });
+// Abandon a sign-in nobody completed, so the daemon stops polling the vendor for it. Ordinary tidiness rather
+// than a security boundary: an unanswered attempt also times out on its own (see `expiresAt`).
+export const LoginCancelSchema = z.object({ handshake: z.string().min(1).describe("Which attempt to stop waiting on.") });
 // A routed-provider subscription login start (codex/grok/kimi/gemini via CLIProxyAPI). Device flows poll to
 // completion after the user approves upstream; redirect flows need the browser's landing URL pasted back. The
 // explicit flow discriminator matters even when a provider's verification URL already embeds its optional code.

package/src/schemas/settings.ts

@@ -251,8 +251,6 @@ export const SkillRemoveSchema = z.object({
 //                        tool is one daemon-side registry entry, not a new settings field.
 //   hashlineEdits    , swaps the native Read/Edit/Write for hash-anchored edits on the Claude path (stale-file
 //                        guard + fewer output tokens); off ⇒ the native file tools.
-//   terseOutput      , appends a concise-response steer to the end of the system prompt (a stable suffix, so it
-//                        composes with stableSystemPrompt) to cut the model's OWN output tokens.
 //   systemPromptMode , which base the agent's prompt is: "intentic" (default), "claude", or "custom".
 //   systemPrompt     , the owner's own prompt text, used only by "custom" mode, where it is the ENTIRE system
 //                        prompt and nothing the daemon would otherwise append rides with it, see its own note.
@@ -306,28 +304,24 @@ export const SandboxSettingsSchema = z.object({
             "Keep the instructions identical between turns so the provider can cache them, moving anything that varies into the message instead. Cheaper, at the cost of some flexibility.",
         ),
     skills: z.array(z.string()).default(["lsp", "fileq"]).describe("Which skills are switched on."),
+    /* WHICH CONTEXT SHELF A CONVERSATION OPENS ON when nothing closer to it says (schemas/context.ts). A persona
+     * card's own `context` wins where a turn wears one; this is the sandbox's answer for the turns that do not.
+     * Empty means no shelf, so a conversation carries every repository the workspace has, which is what every
+     * conversation did before shelves existed. Empty rather than optional because a settings object is parsed
+     * from `{}` until the owner first changes something, and every field here has to answer to that. */
+    contextShelf: z
+        .string()
+        .max(60)
+        .default("")
+        .describe(
+            "Which context shelf a conversation opens on when its persona names none: the part of the workspace it carries. Empty means every repository, as before shelves existed.",
+        ),
     hashlineEdits: z
         .boolean()
         .default(false)
         .describe(
             "Have the agent edit files by line number rather than by quoting the text it wants replaced. Cheaper on large files, and less forgiving of a stale read.",
         ),
-    terseOutput: z.boolean().default(false).describe("Ask the agent to say less. It changes how much it narrates, not how much it does."),
-    /* Measurement control for the terse steer, at TURN level, the same trick `outputHoldout` plays over
-     * commands, one layer up. A fraction [0,1] of otherwise-eligible turns run WITHOUT the steer and record
-     * which arm they ran on (UsageTurn.terse), so the savings report can compare two real populations.
-     *
-     * It has to be an experiment: unlike a cleaned command, which yields its own raw baseline in the same
-     * event, a turn cannot be re-run to see what it would have said unsteered. 0 ⇒ no measurement (every
-     * eligible turn is steered), which is the default because the control costs the very tokens it measures. */
-    terseHoldout: z
-        .number()
-        .min(0)
-        .max(1)
-        .default(0)
-        .describe(
-            "What share of turns to run without that instruction, so the two can be compared honestly. It has to be measured this way, because a turn cannot be re-run to see what it would have said. Zero means no measurement, which is the default, since the comparison costs the very tokens it is measuring.",
-        ),
     /* WHICH SYSTEM PROMPT THE AGENT RUNS ON, the base, before anything this turn composes.
      *
      *   intentic. Intentic's own prompt, tuned for this harness (intentic-prompt.ts). The default.
@@ -337,15 +331,14 @@ export const SandboxSettingsSchema = z.object({
      *
      * The first two are peers: both get the harness's own guidance appended (the AskUserQuestion/plan blocks
      * the chat's cards need, the checklist guidance behind the todo panel, the browser-tool guidance), plus the
-     * delegation note and the terse steer. `custom` is the one that does not, by the owner's explicit choice,
-     * see the field below. */
+     * delegation note. `custom` is the one that does not, by the owner's explicit choice, see the field below. */
     systemPromptMode: SystemPromptModeSchema.default("intentic").describe(
         "Which instructions the agent starts from: intentic's own, the ones the installed Claude Code carries, or your own. The first two both get this product's own guidance added on top; your own gets nothing added, which is the point of it.",
     ),
     /* The owner's own prompt, used only when `systemPromptMode` is "custom". Then it is the ENTIRE system
-     * prompt: both built-in bases are gone and so is everything the daemon would otherwise append, the widget
-     * guidance the chat's cards are driven by, and the terse-output steer (whose toggle goes inert). That is
-     * the price of total control, and the UI states it at the moment of the edit rather than letting the
+     * prompt: both built-in bases are gone and so is everything the daemon would otherwise append, including
+     * the widget guidance the chat's cards are driven by. That is the price of total control, and the UI states
+     * it at the moment of the edit rather than letting the
      * widgets go quietly dark. Only the cross-provider delegation note survives, because it has a home outside
      * the system prompt already (the user-message preamble stableSystemPrompt puts it in).
      *
@@ -777,7 +770,7 @@ export const SandboxSettingsSchema = z.object({
      * The refusal an agent sees names the env var (`ask them to raise CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS`),
      * which is why these three exist as settings at all: without them the only answer to that ask is editing
      * the container's environment and restarting the daemon. */
-    subagentsAtOnce: z.number().min(1).max(200).default(20).describe("How many helper agents may work at the same time."),
+    subagentsAtOnce: z.number().min(1).max(200).default(20).describe("How many subagents may work at the same time."),
     subagentsPerTurn: z.number().min(1).max(2000).default(200).describe("How many a single turn may start in total."),
     // Depth 1 = an agent may delegate, but its children may not. The CLI's own default is 3, and it is the one
     // of the three whose runaway case is unbounded rather than merely wide, each level multiplies the last.
@@ -786,7 +779,7 @@ export const SandboxSettingsSchema = z.object({
         .min(1)
         .max(10)
         .default(3)
-        .describe("How many levels deep the delegation may go, since a helper can start helpers of its own."),
+        .describe("How many levels deep the delegation may go, since a subagent can start subagents of its own."),
 });
 export type SandboxSettings = z.infer<typeof SandboxSettingsSchema>;
 // One of the two built-in bases, as text: Intentic's own prompt, or Claude Code's preset read out of the CLI
@@ -800,19 +793,9 @@ export const BuiltinPromptTextSchema = z.object({ text: z.string(), version: z.s
 export type BuiltinPromptText = z.infer<typeof BuiltinPromptTextSchema>;
 /* ---- savings report: what each token-reduction mechanism actually saved ----
  *
- * TWO FAMILIES, deliberately never one list of bars. They are measured differently, and a chart that ranks
- * them side by side claims a confidence and a denominator that only one of them has:
- *
- *   input , shell output the cleaners trimmed before the model ever saw it. Both sides of the comparison come
- *            off the SAME command (raw in, emitted out), so the counterfactual is observed rather than
- *            estimated: exact, per command, no sample size to argue about.
- *   output, the model's own tokens under the terse steer. There is no second run of the same turn to compare
- *            against, so the only honest number is an experiment: a turn-level holdout, an n per arm, and a
- *            margin. It is absent entirely until both arms are large enough for the delta to mean anything.
- *
- * The two are also in different units of value, a saved tool-output token is saved again on every later
- * request of that conversation, an output token is saved once but costs several times as much, which is the
- * other reason they are separate sections with separate totals rather than one number.
+ * Input-side savings: shell output the cleaners trimmed before the model ever saw it. Both sides of the
+ * comparison come off the SAME command (raw in, emitted out), so the counterfactual is observed rather than
+ * estimated: exact, per command, no sample size to argue about.
  */
 
 // One mechanism's realized saving, biggest first. `savedTokens` is what THIS stage removed from what reached
@@ -851,15 +834,12 @@ export const SavingsArmSchema = z.object({ turns: z.number(), mean: z.number() }
  * stand behind. An experiment can carry several, see TurnExperimentSchema.
  *
  * `metric` says what `mean` counts and what `deltaPct` is a delta in, and choosing it is most of the work.
- *   proseChars     , the terse steer: the thing it steers, and the only part of the model's output that
- *                     responds to being asked to be brief (UsageTurn.proseChars has why output tokens cannot).
  *   searchCalls    , the search teaching: the searches a turn ran, which the teaching directly changes.
  *   openingSearches, the same, narrower: the searches before the turn first touched a file.
  * Search mechanisms must not be judged on COST. Cost is a whole turn's work, a search mechanism moves one part
- * of it, and the part sits inside the noise of the rest exactly as the steer's effect once sat inside its
- * tool-call arguments. */
+ * of it, and the part sits inside the noise of the rest. */
 export const TurnMetricReadingSchema = z.object({
-    metric: z.enum(["proseChars", "searchCalls", "openingSearches"]),
+    metric: z.enum(["searchCalls", "openingSearches"]),
     on: SavingsArmSchema,
     off: SavingsArmSchema,
     /* HOW MUCH LONGER, when the margin spans zero and the honest answer is "keep collecting": the additional
@@ -886,23 +866,20 @@ export const TurnMetricReadingSchema = z.object({
     /* THE CLAIM, present only once there is one. Both together, and only when the margin does NOT span zero.
      *
      * A schema that can't express a half-measured experiment is how a 34%-that-becomes-8%-tomorrow never
-     * reaches the screen, and clearing `minTurns` turned out not to be enough to buy that. The terse steer
-     * crossed its thirtieth control turn and immediately reported +31.2% ± 35.1pp: a confidence interval
+     * reaches the screen, and clearing `minTurns` turned out not to be enough to buy that. An early search
+     * teaching run crossed its thirtieth control turn and immediately reported +31.2% ± 35.1pp: a confidence interval
      * running from −3.4% to +66.7%, which is to say no effect was measured at all, rendered as an alarming
      * number pointing the wrong way. Thirty turns is where the normal approximation starts to hold, not where
      * this much per-turn spread resolves an effect; requiring the interval to exclude zero is the same
      * withhold-until-it-means-something rule applied to the thing that actually decides whether it does.
      *   deltaPct, change in the metric's mean per turn under the mechanism; negative is a saving.
      *   saved   , what the delta is worth over the turns that actually ran with it, in this window, in the
-     *              metric's own unit (characters, or searches). */
+     *              metric's own unit (searches). */
     deltaPct: z.number().optional(),
     saved: z.number().optional(),
 });
 export type TurnMetricReading = z.infer<typeof TurnMetricReadingSchema>;
-/* A turn-level A/B, the one shape both of this sandbox's turn experiments report in, because they differ in
- * nothing but which flag flips and what the turns are judged on. Only turns the mechanism was ELIGIBLE for are
- * counted: a turn under a custom system prompt drops the terse steer along with everything else the daemon
- * appends, so it belongs to neither arm.
+/* A turn-level A/B, the shape the iq search teaching experiment reports in.
  *
  * ONE COIN FLIP, SEVERAL READINGS. `metrics` is a list because the search teaching is judged on two, the
  * searches a turn ran, and the ones it ran before touching a file, and they are two readings of the SAME
@@ -927,9 +904,9 @@ export const TurnExperimentSchema = z.object({
     cohort: z.string().optional(),
 });
 export type TurnExperiment = z.infer<typeof TurnExperimentSchema>;
-// `output`/`search` are absent when that experiment isn't running at all (its flag off, or no holdout set), a
-// section that isn't there reads as "not measured", which is the truth, while zeros would read as "measured,
-// worth nothing".
+// `search` is absent when that experiment isn't running at all (its flag off, or no holdout set), a section
+// that isn't there reads as "not measured", which is the truth, while zeros would read as "measured, worth
+// nothing".
 /* WHAT THE COMPLEXITY JUDGE HAS BEEN SAYING, read back off the spend ledger's tier fields (UsageTurn.tierScore
  * and friends) over the requested window. The three numbers docs/model-routing-design.md §4 says the feature
  * cannot be defended without, plus the veto count, and nothing else: no counterfactual "you would have saved
@@ -964,7 +941,6 @@ export const TierReportSchema = z.object({
 export type TierReport = z.infer<typeof TierReportSchema>;
 export const SavingsReportSchema = z.object({
     input: InputSavingsSchema,
-    output: TurnExperimentSchema.optional(),
     search: TurnExperimentSchema.optional(),
     // Automatic tier selection's readout, see TierReportSchema. Absent ⇒ nothing was judged in the window.
     tier: TierReportSchema.optional(),

package/src/schemas/terminal.ts

@@ -194,14 +194,14 @@ export type SubagentKind = z.infer<typeof SubagentKindSchema>;
 // an operator acts on differently from "the child is working".
 export const SubagentStatusSchema = z.enum(["pending", "running", "blocked", "completed", "failed", "killed", "paused"]);
 export type SubagentStatus = z.infer<typeof SubagentStatusSchema>;
-/* WHETHER ANYTHING CHECKED WHAT THE HELPER DID, carried beside its report rather than left for the reader to
- * assume. Computed from the helper's own tool calls, the files it edited against the checks that ran after
+/* WHETHER ANYTHING CHECKED WHAT THE SUBAGENT DID, carried beside its report rather than left for the reader to
+ * assume. Computed from the subagent's own tool calls, the files it edited against the checks that ran after
  * them (the daemon's child-verification.ts), so it holds on every provider rather than only where the Claude
  * hooks reach.
  *
  * The four states are deliberately not two. `verified` and `failing` each name the command that spoke, so a
  * targeted test is never read as the suite; `unproven` is the one that matters most, work changed and nothing
- * ran; and `no-code` says the helper edited nothing, which is the honest answer for a research helper and
+ * ran; and `no-code` says the subagent edited nothing, which is the honest answer for a research subagent and
  * must not be rendered as approval. Absent ⇒ the daemon saw no tool calls from it at all. */
 export const SubagentVerificationSchema = z.object({
     state: z
@@ -222,10 +222,10 @@ export const SubagentSessionSchema = z.object({
     id: z
         .string()
         .describe(
-            "The id of the tool call that started it (an SDK child) or the child's own conversation id (a spawned one); either way both sides already hold it, so a card links to its helper with the id it has and the helper points back the same way.",
+            "The id of the tool call that started it (an SDK child) or the child's own conversation id (a spawned one); either way both sides already hold it, so a card links to its subagent with the id it has and the subagent points back the same way.",
         ),
     kind: SubagentKindSchema.describe(
-        "What sort of helper: one the runtime's own Task tool spawned in-process, or a full agent the daemon started for the turn. It changes only how you watch it.",
+        "What sort of subagent: one the runtime's own Task tool spawned in-process, or a full child agent the daemon started for the turn. It changes only how you watch it.",
     ),
     // The conversation whose turn spawned this, what the area groups its rows by, and the way back to the chat
     // the card lives in.
@@ -233,19 +233,19 @@ export const SubagentSessionSchema = z.object({
     // What it is and what it was asked to do: the subagent type (`Explore`, `general-purpose`) or a spawned
     // child's provider label, and the caller's one-line description. The area's row and the card's title read
     // as `Explore · Locate claimIndexer definition`.
-    agentType: z.string().optional().describe("What kind of helper it is."),
+    agentType: z.string().optional().describe("What kind of subagent it is."),
     description: z.string().optional().describe("What it was asked to do, in one line."),
     model: z.string().optional().describe("Which model it runs on."),
     // Which provider serves a `spawned` child (its AgentProvider id), so the row can wear the right logo. An
     // SDK subagent implies its own: it runs on its parent's provider.
-    provider: z.string().optional().describe("Which provider serves it, for a helper spawned across providers."),
+    provider: z.string().optional().describe("Which provider serves it, for a child agent spawned across providers."),
     // How deep in the spawn tree (1 = spawned by the turn itself). From the SDK's meta.json; a subagent may
     // itself delegate, and a flat list that cannot say so reads as though the turn started all of them.
     spawnDepth: z
         .number()
         .optional()
         .describe(
-            "How deep in the chain it sits, where one means the turn itself started it. A helper can start helpers, and a flat list that could not say so would read as though the turn started all of them.",
+            "How deep in the chain it sits, where one means the turn itself started it. A subagent can start subagents, and a flat list that could not say so would read as though the turn started all of them.",
         ),
     // Backgrounded: the parent went on working instead of waiting for it. This is the whole reason the list
     // exists, a backgrounded child used to be invisible until its result landed, sometimes minutes later.
@@ -253,7 +253,7 @@ export const SubagentSessionSchema = z.object({
         .boolean()
         .optional()
         .describe(
-            "The parent carried on working instead of waiting for it. This is the whole reason the list exists: such a helper used to be invisible until its result landed, sometimes minutes later.",
+            "The parent carried on working instead of waiting for it. This is the whole reason the list exists: such a subagent used to be invisible until its result landed, sometimes minutes later.",
         ),
     status: SubagentStatusSchema.describe(
         "How it is going. Blocked means it needs an answer, which a parent and an operator act on differently from it simply working.",
@@ -266,7 +266,7 @@ export const SubagentSessionSchema = z.object({
     tokens: z
         .number()
         .optional()
-        .describe("What it has spent. Its own, so a parent's cost and the sum of its helpers' are two different true numbers."),
+        .describe("What it has spent. Its own, so a parent's cost and the sum of its subagents' are two different true numbers."),
     toolUses: z.number().optional().describe("How many tools it has used."),
     lastTool: z.string().optional().describe("The last one it reached for."),
     // Its report, the last assistant message (SubagentStop) or the task summary. The answer to "what did it
@@ -274,7 +274,7 @@ export const SubagentSessionSchema = z.object({
     summary: z
         .string()
         .optional()
-        .describe("Its report: what it concluded, without opening its record. The question a finished helper gets read for."),
+        .describe("Its report: what it concluded, without opening its record. The question a finished subagent gets read for."),
     error: z.string().optional().describe("Why it failed, when it did."),
     // Whether anything checked the work behind that report (SubagentVerificationSchema). Filled once it ends:
     // a standing read while it is still working would be a verdict on a job half done.
@@ -282,7 +282,7 @@ export const SubagentSessionSchema = z.object({
 });
 export type SubagentSession = z.infer<typeof SubagentSessionSchema>;
 export const SubagentsListSchema = z.object({
-    sessions: z.array(SubagentSessionSchema).describe("Every helper this sandbox's conversations have started."),
+    sessions: z.array(SubagentSessionSchema).describe("Every subagent and child agent this sandbox's conversations have started."),
 });
 export type SubagentsList = z.infer<typeof SubagentsListSchema>;
 export const SubagentIdParamSchema = z.object({ id: z.string() });

package/src/schemas/usage.ts

@@ -83,14 +83,6 @@ export const UsageTurnSchema = z.object({
     cacheCreationTokens: z.number().describe("Tokens written to cache, which cost more up front and less afterwards."),
     costUsd: z.number().describe("What it cost, in dollars."),
     durationMs: z.number().describe("How long it took, in milliseconds."),
-    /* Which arm of the terse experiment this turn ran on (settings.terseHoldout), the only record of it, and
-     * the reason the savings report can say what the steer is worth instead of guessing.
-     *
-     * ABSENT means "not part of the experiment", not "off": a turn under a custom system prompt drops the
-     * steer along with everything else the daemon appends, and a turn run with the experiment switched off has
-     * no control to be compared against. Pooling those into the off-arm would compare steered turns against a
-     * population selected by something other than the coin flip, which is not a control at all. */
-    terse: z.boolean().optional(),
     /* Which arm of the iq SEARCH-TEACHING experiment this conversation runs on
      * (settings.iqSearchHoldout). Stable for every turn in one conversation: the treatment is instruction
      * loaded into a provider session, so flipping it per turn would call a remembered treatment a control.
@@ -99,25 +91,9 @@ export const UsageTurnSchema = z.object({
     // Hash of the plugin nudge + skill body used for this arm. Control turns carry it too, so a report can keep
     // both sides of one treatment revision together and exclude older wording after an upgrade.
     iqSearchCohort: z.string().optional(),
-    /* Characters of the model's own PROSE this turn, the `delta` frames only, so no tool-call arguments and no
-     * thinking. What the terse steer is judged on, and the reason it can be judged at all.
-     *
-     * `outputTokens` cannot serve: measured over a day of real turns it is 91.6% tool-call arguments (an Edit's
-     * old_string and new_string, a Write's whole file body) and 7.8% prose. The steer moves prose. So a fifth
-     * off the model's narration moves the total by 1.6%, against a margin of ±35 points, which is to say the
-     * experiment was structurally unable to see its own treatment, and the number it printed instead was
-     * whichever arm happened to draw the bigger tasks.
-     *
-     * CHARACTERS, not tokens, because the provider bills a total and never breaks it down, a token figure here
-     * would be chars÷4 wearing a unit it had not earned. For a comparison of two arms the constant cancels
-     * anyway, and the honest unit is the one actually counted.
-     *
-     * Absent ⇒ the turn predates this being measured; `armOf` drops it from the population rather than reading
-     * it as a silent turn. */
-    proseChars: z.number().optional(),
     /* SEARCHES THIS TURN RAN, every tool call that went looking for code, the dedicated search tools and the
      * CLI searches alike (isSearchCall owns the rule; `iq q` is Bash and would otherwise not be counted at all).
-     * What the search teaching is judged on, and the same correction `proseChars` is to the terse steer.
+     * What the search teaching is judged on.
      *
      * COST PER TURN CANNOT SERVE: cost is a whole turn's worth of work, a search mechanism touches one part of
      * it, and the part lives inside the noise of the rest, exactly the shape that made output tokens unable to
@@ -128,8 +104,8 @@ export const UsageTurnSchema = z.object({
      * rather than being filtered out, they dilute both arms equally, while selecting on "did it search" would
      * select on the treatment itself.
      *
-     * Absent ⇒ the turn predates this being measured; `armOf` drops it rather than reading it as a turn that
-     * searched nothing. */
+     * Absent ⇒ the turn predates this being measured; the arm's mean drops it (turn-experiments.ts, the filter
+     * inside `conversationExperimentOf`) rather than reading it as a turn that searched nothing. */
     searchCalls: z.number().optional(),
     /* …and how many of them came BEFORE the turn first opened or changed a file, the orientation burst. A turn
      * that already knows where to look starts working; one that doesn't goes hunting first.

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

@@ -15,7 +15,6 @@ test("a payload from a build that predates a toggle parses, with the new toggle
         stableSystemPrompt: false,
         skills: [],
         hashlineEdits: false,
-        terseOutput: true,
         iqSearch: true,
         outputCleaners: "-cap",
         outputHoldout: 0.1,