@sema-agent/core 7.35.1 → 7.36.0

package/dist/core/tool-registry.d.ts

@@ -52,36 +52,6 @@ export interface ToolCallLike {
     } | undefined;
 }
 type CallPathTarget = ToolCallPathTarget;
-/**
- * The names a tool-name rule may spell this call's tool by — the face's `names` when they include the call's name,
- * else the call's name alone (a bare request, or a face minted for another name). Every name-keyed matcher and the
- * protective path floor read a rule's tool name against THIS list, which is the roster's one canonicalization seen
- * from the call's side: a rule written against an alias and one written against the wire name reach the same calls.
- */
-export declare function ruleNamesOf(req: Pick<ToolCallLike, "toolName" | "face">): readonly string[];
-/** Does the call answer to `name` — is it one of the call's names ({@link ruleNamesOf})? The engine's TIGHTENS keyed on
- *  one of its own tool names read this, so a tool that wears the name under any of its names is tightened (the
- *  fail-safe direction); a grant or a routing keyed on an engine tool name reads the wire name. */
-export declare function callAnswersTo(req: Pick<ToolCallLike, "toolName" | "face">, name: string): boolean;
-/** Does a set of rule tool names name this call's tool ({@link ruleNamesOf})? */
-export declare function toolNameSetHas(set: {
-    has(name: string): boolean;
-}, req: Pick<ToolCallLike, "toolName" | "face">): boolean;
-/** Does `set` hold any of the call's names ({@link ruleNamesOf})? The read of a MEMBERSHIP tighten keyed on the engine's
- *  own tool names (the egress set, a read station's tools, the compliance veto): a tool is held under every name it
- *  answers to. A grant or a routing keyed on an engine tool name reads the wire name instead. */
-export declare function anyNamed(set: {
-    has(name: string): boolean;
-}, names: readonly string[]): boolean;
-/** The first of the call's names ({@link ruleNamesOf}, the spelling first) that `map` holds an entry for, with the entry.
- *  The read of a SEAT keyed on the engine's own tool names (a tier, a mark's sources): every key of one seat is read under
- *  the ONE name this returns — a seat is never assembled from two names' entries. */
-export declare function firstNamed<V>(map: {
-    get(name: string): V | undefined;
-}, names: readonly string[]): {
-    readonly name: string;
-    readonly value: V;
-} | undefined;
 /**
  * design/388 B6/B17 — the path target a PROTECTIVE fence reads (a deny-list judging a write's target: sensitive paths,
  * frozen paths, write protection, the transcript gate; edit tracking): the object face's own declaration first, the
@@ -89,7 +59,7 @@ export declare function firstNamed<V>(map: {
  * face that declares none. Reading the catalog for an undeclared same-name tool can only TIGHTEN a deny-list (it adds
  * a slot to judge — the pre-388 posture, never wider), which is exactly why this floor is wrong for a grant.
  *
- * The floor reads EVERY name the call answers to (`ruleNamesOf`: the face's `names`, else the call's name alone) in
+ * The floor is a `member` seat over every name the call answers to (the face's `names`, else the call's name alone) in
  * the face's order — the name the call was made under first, then the wire name, then the other aliases — and the
  * first name the catalog declares a target for wins: a call made under a catalog name and resolved to a tool that
  * declares none keeps THAT name's slot, also when the tool answers to a second catalog name with another slot.

package/dist/core/tool-registry.js

@@ -1,5 +1,6 @@
 import { TOOL_MOUNT_TAGS, pathTargetSlotOnly } from "./tool-face.js";
 import { ENGINE_CARDS, TOOL_CATALOG_ENTRIES } from "./tool-catalog-entries.js";
+import { seatOf } from "./tool-name-readings.js";
 export function describeToolCatalog() {
     return TOOL_CATALOG_ENTRIES;
 }
@@ -51,31 +52,10 @@ export function pathTargetValue(args, pt) {
     }
     return undefined;
 }
-export function ruleNamesOf(req) {
-    const names = req.face?.names;
-    return names !== undefined && names.includes(req.toolName) ? names : [req.toolName];
-}
-export function callAnswersTo(req, name) {
-    return ruleNamesOf(req).includes(name);
-}
-export function toolNameSetHas(set, req) {
-    return anyNamed(set, ruleNamesOf(req));
-}
-export function anyNamed(set, names) {
-    return names.some((n) => set.has(n));
-}
-export function firstNamed(map, names) {
-    for (const name of names) {
-        const value = map.get(name);
-        if (value !== undefined)
-            return { name, value };
-    }
-    return undefined;
-}
 export function protectivePathTargetOf(call) {
     if (call.face?.pathTarget !== undefined)
         return call.face.pathTarget;
-    const floor = ruleNamesOf(call).map((n) => pathTargetOf(n)).find((pt) => pt !== undefined);
+    const floor = seatOf("floor.protectivePathTarget", { get: pathTargetOf }, call)?.value;
     return floor === undefined || call.face === undefined ? floor : pathTargetSlotOnly(floor);
 }
 export const BARE_REQUEST_CODE = "policy.bare_request";

package/dist/core/tool-result-budget.d.ts

@@ -23,6 +23,9 @@ export interface AggregateBudgetOptions {
     budgetChars?: number;
     /** Tool names exempt from the budget (their own caps bound them) — e.g. read_file, read_tool_result. */
     exemptTools?: ReadonlySet<string>;
+    /** The wire name a result's recorded tool name resolves to on the leg's roster (an exemption is judged on the tool the
+     *  call ran, not the spelling the model used). Absent ⇒ the recorded name. */
+    toolNameOf?: (recorded: string) => string;
     /** design/30 store for offload+read-back. Absent ⇒ self-contained truncation preview. */
     store?: ToolResultStore;
     /** Namespaces the stable ref so an offloaded result is globally addressable. */

package/dist/core/tool-result-budget.js

@@ -1,6 +1,7 @@
 import { isToolResult } from "./message-utils.js";
 import { buildPreview, buildToolResultRef, PERSISTED_OUTPUT_PREFIX, toolResultContentSegment, toolResultProvenanceOf, } from "./tool-result-store.js";
 import { budgetExemptToolNames } from "./tool-registry.js";
+import { wireOf } from "./tool-name-readings.js";
 export const AGGREGATE_TOOL_RESULT_BUDGET_CHARS = 200_000;
 const HEAD = 1_000;
 const TAIL = 1_000;
@@ -38,6 +39,7 @@ const CATALOG_BUDGET_EXEMPT_TOOLS = budgetExemptToolNames();
 export async function capAggregateToolResults(messages, opts) {
     const budget = opts.budgetChars ?? AGGREGATE_TOOL_RESULT_BUDGET_CHARS;
     const exempt = opts.exemptTools ?? CATALOG_BUDGET_EXEMPT_TOOLS;
+    const exemptResult = (m) => m.toolName !== undefined && exempt.has(wireOf("budget.exemptResult", { toolName: opts.toolNameOf !== undefined ? opts.toolNameOf(m.toolName) : m.toolName }));
     let out;
     let i = 0;
     while (i < messages.length) {
@@ -52,7 +54,7 @@ export async function capAggregateToolResults(messages, opts) {
         let total = 0;
         for (let k = i; k < j; k++) {
             const m = arr[k];
-            if (m.toolName && exempt.has(m.toolName))
+            if (exemptResult(m))
                 continue;
             total += textChars(m.content);
         }
@@ -94,7 +96,7 @@ export async function capAggregateToolResults(messages, opts) {
             const cand = [];
             for (let k = i; k < j; k++) {
                 const m = out[k];
-                if (m.toolName && exempt.has(m.toolName))
+                if (exemptResult(m))
                     continue;
                 if (isOffloadedPreview(m.content))
                     continue;
@@ -112,7 +114,7 @@ export async function capAggregateToolResults(messages, opts) {
                 const cand2 = [];
                 for (let k = i; k < j; k++) {
                     const m = out[k];
-                    if (m.toolName && exempt.has(m.toolName))
+                    if (exemptResult(m))
                         continue;
                     if (isOffloadedPreview(messages[k].content))
                         continue;

package/dist/core/tool-roster.d.ts

@@ -257,11 +257,11 @@ export declare function rosterEntryNamed(roster: ToolRoster, toolName: string):
  * an alias and one written against the wire name are one rule.
  */
 export declare function rosterToolName(roster: ToolRoster | undefined, name: string): string;
-export { anyNamed, callAnswersTo, firstNamed, ruleNamesOf, toolNameSetHas } from "./tool-registry.js";
+export { ruleNamesOf } from "./tool-name-readings.js";
 /** design/388 B6 — the per-call face a gated request carries, read off a roster snapshot by name (aliases resolve).
  *  `names` leads with the name the face was minted under (the model's spelling at the gate), then the wire name and the
- *  other aliases: a reader that must pick ONE of the call's names (the protective path floor) picks the spelling first,
- *  as the same call was judged before name resolution. */
+ *  other aliases — the ONE order of a call's names: a reader that must pick one of them by position (a `member` seat)
+ *  picks the spelling first, as the same call was judged before name resolution. */
 export declare function toolCallFaceOf(roster: ToolRoster | undefined, toolName: string): import("./tool-policy.js").ToolCallFace | undefined;
 /** design/388 B18 — the identity members a park row carries, read off a roster snapshot by name; an empty object when
  *  the name is not on the snapshot (the row then reads pre-identity and the resume takes the name-only path). */
@@ -272,16 +272,30 @@ export declare function parkedToolIdentity(roster: ToolRoster | undefined, toolN
     implementationRevision?: string;
     rosterDigest?: string;
 };
-/** design/388 B6 × B18 (merge-seam adversarial round H1) — the FACE members a park row carries beside its identity:
- *  the display family and the declared path target the parked call was judged under. A recheck that runs before
- *  the leg's roster exists (the pre-CAS resume-edit re-adjudication) rebuilds the call face from the row through
- *  {@link parkedCallFaceOf}, so it judges the same object the live gate judged. An empty object when the name is
- *  not on the snapshot (the row then reads pre-face and the recheck falls to the catalog for the name). */
-export declare function parkedToolFace(roster: ToolRoster | undefined, toolName: string): {
+/** design/388 B6 × B18 — the FACE members a park row carries beside its identity: the display family, the declared
+ *  path target and the names the parked call was judged under. `names` is copied from the face the gate stamped on the
+ *  request (the model's spelling first — the row carries the judged fact, it is not re-derived); a request with no face
+ *  takes the roster's names for its row. A recheck that runs before the leg's roster exists (the pre-CAS resume-edit
+ *  re-adjudication) rebuilds the call face from the row through {@link parkedCallFaceOf}, so it judges the same object
+ *  the live gate judged. An empty object when the name is not on the snapshot (the row then reads pre-face and the
+ *  recheck falls to the catalog for the name). */
+export declare function parkedToolFace(roster: ToolRoster | undefined, req: {
+    readonly toolName: string;
+    readonly face?: {
+        readonly names?: readonly string[];
+    } | undefined;
+}): {
     family?: ToolFamily;
     pathTarget?: ToolRosterEntry["pathTarget"];
     names?: readonly string[];
 };
+/** The live face a resumed park row is re-judged under: minted under the row's recorded spelling (`names[0]`) when that
+ *  spelling still resolves to the row's own tool on this roster, else under the row's wire name — a spelling that no
+ *  longer resolves, or that another row now owns, never lends the row another tool's face. */
+export declare function parkedRowLiveFace(roster: ToolRoster | undefined, row: {
+    readonly toolName: string;
+    readonly names?: readonly string[];
+}): import("./tool-policy.js").ToolCallFace | undefined;
 /** The call face a park row carries — present iff the row was minted with BOTH its face members and its four
  *  identity members (one mint writes all of them; a row missing any is pre-388 and yields undefined, never a
  *  partial face). This is the face every recheck of the row judges under, roster or no roster. */
@@ -443,6 +457,13 @@ export declare class RosterBuilder {
      *  yielded instance's position and never a row per object. */
     snapshot(facts: RosterSnapshotFacts): ToolRoster;
 }
+/**
+ * The roster's one declaration rule on engine names: a row whose names (its wire name and the aliases that resolve to it,
+ * {@link namesResolvingTo}) belong to TWO or more engine tools is refused — one tool answering as two engine tools would
+ * have every per-call seat keyed on engine names choose between two definitions of the call. A row answering to one engine
+ * tool under several of that tool's names, and an alias another row owns, are not counted twice. Undefined ⇒ none.
+ */
+export declare function rosterEngineNamesProblem(roster: ToolRoster): string | undefined;
 /** Which source a `TaskSpec.tools` entry mounts as: a definition carrying a CORE contract is a built-in the host chose
  *  to mount; anything else is the caller's own tool. Identity follows the object, never the name. */
 export declare function callerMountSource(tool: AgentTool): RosterSource;

package/dist/core/tool-roster.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { Type } from "typebox";
 import { getToolContract } from "../prompt-assembly/tool-catalog.js";
 import { protocolOf } from "./protocol-table.js";
+import { describeToolCatalog } from "./tool-registry.js";
 import { RENDER_HINT_ACTIVITY_MAX_CHARS, RENDER_HINT_MAX_CHARS, RENDER_HINT_MAX_LIST, TOOL_APPROVAL_CARDS, TOOL_CARD_ID_MAX_CHARS, TOOL_CONTRACT_MAX_CHARS, TOOL_FAMILIES, TOOL_KEYS_MAX, TOOL_KEY_MAX_CHARS, TOOL_MOUNT_TAGS, TOOL_WIRE_NAME_MAX_CHARS, TOOL_PATH_ABSENCES, TOOL_PATH_BASES, } from "./tool-face.js";
 function lit(values) {
     return Type.Union(values.map((v) => Type.Literal(v)));
@@ -80,7 +81,7 @@ export function rosterToolName(roster, name) {
 function namesResolvingTo(roster, e) {
     return [e.name, ...e.aliases.filter((a) => a !== e.name && rosterToolName(roster, a) === e.name)];
 }
-export { anyNamed, callAnswersTo, firstNamed, ruleNamesOf, toolNameSetHas } from "./tool-registry.js";
+export { ruleNamesOf } from "./tool-name-readings.js";
 export function toolCallFaceOf(roster, toolName) {
     if (roster === undefined)
         return undefined;
@@ -106,13 +107,19 @@ export function parkedToolIdentity(roster, toolName) {
         return {};
     return { capabilityId: e.capabilityId, contractId: e.contract.contractId, shapeDigest: e.shapeDigest, implementationRevision: e.contract.implementationRevision, rosterDigest: roster.digest };
 }
-export function parkedToolFace(roster, toolName) {
+export function parkedToolFace(roster, req) {
     if (roster === undefined)
         return {};
-    const e = rosterEntryNamed(roster, toolName);
+    const e = rosterEntryNamed(roster, req.toolName);
     if (e === undefined)
         return {};
-    return { family: e.family, ...(e.pathTarget !== undefined ? { pathTarget: e.pathTarget } : {}), names: namesResolvingTo(roster, e) };
+    const judged = req.face?.names;
+    return { family: e.family, ...(e.pathTarget !== undefined ? { pathTarget: e.pathTarget } : {}), names: judged !== undefined && judged.includes(req.toolName) ? [...judged] : namesResolvingTo(roster, e) };
+}
+export function parkedRowLiveFace(roster, row) {
+    const spelled = row.names?.[0];
+    const under = spelled !== undefined && roster !== undefined && rosterToolName(roster, spelled) === row.toolName ? spelled : row.toolName;
+    return toolCallFaceOf(roster, under);
 }
 export function parkedCallFaceOf(pending) {
     if (pending.family === undefined || pending.capabilityId === undefined || pending.contractId === undefined || pending.shapeDigest === undefined || pending.implementationRevision === undefined)
@@ -369,8 +376,41 @@ export class RosterBuilder {
             const meta = this.#meta.get(survivor) ?? { source: "caller", mountedBy: "scenario" };
             entries.push(mintRosterEntry(survivor, meta, facts));
         }
-        return { schemaVersion: 1, count: entries.length, entries, digest: rosterDigestOf(entries) };
+        const roster = { schemaVersion: 1, count: entries.length, entries, digest: rosterDigestOf(entries) };
+        const worn = rosterEngineNamesProblem(roster);
+        if (worn !== undefined)
+            throw configError("config.tool_face_invalid", worn);
+        return roster;
+    }
+}
+let catalogOwners;
+function catalogOwnerOf(name) {
+    if (catalogOwners === undefined) {
+        const owners = new Map();
+        for (const e of describeToolCatalog()) {
+            owners.set(e.name, e.name);
+            for (const a of e.face.aliases ?? [])
+                if (!owners.has(a))
+                    owners.set(a, e.name);
+        }
+        catalogOwners = owners;
     }
+    return catalogOwners.get(name);
+}
+export function rosterEngineNamesProblem(roster) {
+    for (const e of roster.entries) {
+        const resolving = namesResolvingTo(roster, e);
+        const worn = new Map();
+        for (const n of resolving) {
+            const owner = catalogOwnerOf(n);
+            if (owner !== undefined && !worn.has(owner))
+                worn.set(owner, n);
+        }
+        if (worn.size >= 2) {
+            return `tool ${JSON.stringify(e.name)} answers to the names of ${worn.size} engine tools (${[...worn.values()].map((n) => JSON.stringify(n)).join(", ")}): a tool may answer to at most one engine tool's names — keep one of those aliases`;
+        }
+    }
+    return undefined;
 }
 export function callerMountSource(tool) {
     return getToolContract(tool, "caller").origin === "core" ? "builtin" : "caller";

package/dist/engine/llm/types.d.ts

@@ -242,6 +242,10 @@ export interface DocumentContent {
 export interface ToolCall {
     type: "toolCall";
     id: string;
+    /** The provider's own spelling of {@link id}, present only when the brain folded it (`brain/tool-call-id.ts`);
+     *  handed back to the provider for the call and its result, persisted with the message. Upstream bytes: render
+     *  {@link id}. */
+    wireId?: string;
     name: string;
     arguments: Record<string, unknown>;
     executionMode?: "sequential" | "parallel";

package/dist/tools/fs/file-read-check.d.ts

@@ -15,7 +15,7 @@
 import type { ExecutionEnv } from "../../internal/harness-types.js";
 import type { ContainmentFace } from "./containment-face.js";
 import { type ReadDenyMatcher } from "./read-deny.js";
-import type { ShellReadCheck } from "./shell-read-check.js";
+import { type ShellReadCheck } from "./shell-read-check.js";
 export interface FileReadStation {
     readonly check: ShellReadCheck;
     /** The station's membership: the tool names whose declared read target it judges. */

package/dist/tools/fs/file-read-check.js

@@ -1,7 +1,8 @@
 import { effectivePathSpellingOf } from "../../core/effective-path-target.js";
-import { firstNamed, pathTargetOf, ruleNamesOf } from "../../core/tool-registry.js";
+import { pathTargetOf } from "../../core/tool-registry.js";
 import { fitMiddle, READ_DENY_SENTENCE_PART_MAX } from "./read-deny.js";
 import { resolveKey, violationDetails } from "./safety.js";
+import { readStationMemberOf } from "./shell-read-check.js";
 import { grantOfferFor, parentDirLexically } from "./shell-read-judge.js";
 const ADMISSION_MAX = 1024;
 const VOUCH = { disposition: "vouch", finding: "none" };
@@ -17,7 +18,7 @@ export function createFileReadStation(opts) {
     };
     const check = {
         judge(call, args, cwd, signal, callOpts) {
-            const member = ruleNamesOf(call).find((n) => opts.tools.has(n));
+            const member = readStationMemberOf(call, opts.tools)?.name;
             if (member === undefined)
                 return null;
             const toolName = call.toolName;
@@ -71,7 +72,7 @@ export function composeReadChecks(stations) {
         for (const n of s.tools)
             if (!byName.has(n))
                 byName.set(n, s);
-    const stationOf = (call) => firstNamed(byName, ruleNamesOf(call))?.value;
+    const stationOf = (call) => readStationMemberOf(call, byName)?.value;
     return {
         judge: (call, args, cwd, signal, callOpts) => stationOf(call)?.check.judge(call, args, cwd, signal, callOpts) ?? null,
         unanswered: (call, cause) => (stationOf(call) ?? stations[0]).check.unanswered(call, cause),

package/dist/tools/fs/shell-read-check.d.ts

@@ -22,7 +22,7 @@ import { violationDetails } from "./safety.js";
 import { type ShellReadPlan } from "./shell-read-plan.js";
 import { type EstablishedRead, type ShellReadBoundary, type ShellReadDisposition, type ShellReadFinding, type ShellReadSeat } from "./shell-read-judge.js";
 import type { ReadRootGrantCandidate } from "../../core/tool-spec.js";
-import { type ToolCallLike } from "../../core/tool-registry.js";
+import type { ToolCallLike } from "../../core/tool-registry.js";
 /** The ONE mint of the containment card — the targets a finding established OUTSIDE the roots (an out-of-root read, a
  *  target that resolves elsewhere by the spawn). */
 declare function containmentDetails(paths: readonly string[]): {
@@ -105,6 +105,20 @@ export interface ShellReadCheck {
 }
 /** The call a read station judges: its wire name and the face the gate stamped (whose `names` the station reads). */
 export type ReadStationCall = Pick<ToolCallLike, "toolName" | "face">;
+/** The read station a call belongs to — the first of its names (the spelling first) a station's membership holds; every
+ *  station reads the call's slot and seat under that one name. */
+export declare function readStationMemberOf<V>(call: ReadStationCall, members: {
+    get(name: string): V | undefined;
+}): {
+    readonly name: string;
+    readonly value: V;
+} | undefined;
+export declare function readStationMemberOf(call: ReadStationCall, members: {
+    has(name: string): boolean;
+}): {
+    readonly name: string;
+    readonly value: true;
+} | undefined;
 /** The pre-spawn admission the shell tools call: re-establishes what the station established for this
  *  call and refuses when any canonical target moved. `undefined` ⇒ spawn. A call the station never judged
  *  (no gate ran) has nothing to re-establish and spawns. */

package/dist/tools/fs/shell-read-check.js

@@ -8,7 +8,7 @@ import { planShellReads } from "./shell-read-plan.js";
 import { createShellReadEstablisher, establishShellReadsLexically } from "./shell-read-establish.js";
 import { programArgs, spellsOption } from "./shell-read-write-targets.js";
 import { allFindings, decideShellRead, denyRowAtOrBelow, foldShellReadFindings, judgeEstablishedPlan, readRootGrantCandidateOf, } from "./shell-read-judge.js";
-import { ruleNamesOf } from "../../core/tool-registry.js";
+import { seatOf } from "../../core/tool-name-readings.js";
 import { normalizeReadRootCandidate } from "../../core/read-root-candidate.js";
 import { argvOf, lexShellText } from "../../shell/lex.js";
 function containmentDetails(paths) {
@@ -178,6 +178,9 @@ async function writeGuardsOf(judged, boundary, placed, env, signal) {
     }
     return { unplaced, writeProtected };
 }
+export function readStationMemberOf(call, members) {
+    return seatOf("fold.readStation", members, call);
+}
 const ADMISSION_MAX = 1024;
 function shellCommandOf(args) {
     const command = args?.command;
@@ -360,7 +363,7 @@ export function createShellReadStation(opts) {
         }
         admissions.set(toolCallId, a);
     };
-    const memberOf = (call) => ruleNamesOf(call).find((n) => opts.tools.has(n));
+    const memberOf = (call) => readStationMemberOf(call, opts.tools)?.name;
     const check = {
         judge(call, args, cwd, signal, callOpts) {
             const member = memberOf(call);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "7.35.1",
+  "version": "7.36.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",
@@ -83,6 +83,7 @@
     "gate:contract-sentences": "node scripts/verify-contract-sentences.mjs",
     "gate:tool-catalog": "node scripts/verify-tool-catalog.mjs",
     "gate:tool-names": "node scripts/verify-tool-name-tables.mjs",
+    "gate:name-readings": "node scripts/verify-name-readings.mjs",
     "gate:tool-docs": "node scripts/gen-tool-spec-fields.mjs --check",
     "gate:backlog-ledger": "node scripts/verify-backlog-ledger.mjs",
     "gate:child-clamp-seats": "node scripts/verify-child-clamp-seats.mjs",

package/wire-changes/core@7.35.2.json

@@ -0,0 +1,61 @@
+{
+  "repo": "core",
+  "version": "7.35.2",
+  "from": "47ed594ee8d729368c4be8d8a189d908b33e15e5",
+  "to": "v7.35.2",
+  "added": [],
+  "removed": [],
+  "changed": [],
+  "narrowed": [],
+  "closedSetMembers": [],
+  "closedSetsUnreadable": [],
+  "typeKeys": [],
+  "typeKeysUnreadableArms": [],
+  "typeKeysFlattenedCount": 219,
+  "declarationMoves": [],
+  "mintMoves": [],
+  "criteriaObserves": [
+    {
+      "kind": "typeMember",
+      "name": "BrainStatus.elapsedMs",
+      "assertions": [
+        "G1.a",
+        "G1.c"
+      ]
+    },
+    {
+      "kind": "typeMember",
+      "name": "BrainStatus.errClass",
+      "assertions": [
+        "G1.b"
+      ]
+    },
+    {
+      "kind": "typeMember",
+      "name": "BrainStatus.phase",
+      "assertions": [
+        "G1.a",
+        "G1.b",
+        "G1.c"
+      ]
+    },
+    {
+      "kind": "typeMember",
+      "name": "BrainStatus.timeoutMs",
+      "assertions": [
+        "G1.a",
+        "G1.b",
+        "G1.c"
+      ]
+    }
+  ],
+  "consumersHint": {
+    "cli": [],
+    "server": [],
+    "sdk": [],
+    "note": "scanned cli@6b6025f7 server@25d6b7a6 sdk@e8f6f0d — a name listed is MENTIONED there today, which is evidence of consumption, not proof of it"
+  },
+  "breakingCount": 0,
+  "breakingItems": [],
+  "toResolvedAt": "8a69688057ed91863f6574e06b9f4f83dfdcb7a6"
+}