@sema-agent/client-core 0.93.0 → 0.94.0

package/dist/adapt/arms.js

@@ -12,6 +12,8 @@ import { recordWorkflowAgentTaskId } from '../workflow.js';
 import { isTerminalStatus } from '../runTerminal.js';
 import { readToolHistoryMismatchKey } from '../toolHistoryMismatch.js';
 import { readProviderRejectionResendKey } from '../providerRejection.js';
+import { readFrameStringKey } from '../ownKey.js';
+import { washCredentials } from '../displayUntrusted.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
 import { fleetRowAgentType } from '../fleet/fleetRowAgentType.js';
 import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
@@ -126,12 +128,13 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
     }
     const textBlock = blocks.find(b => b?.type === 'text');
     if (textBlock && typeof textBlock.text === 'string' && textBlock.text.length > 0) {
-        text.appendAnswer(textBlock.text);
+        const rowText = m._sema_api_error_message === true ? washCredentials(textBlock.text) : textBlock.text;
+        text.appendAnswer(rowText);
         text.beginAssistantMessage();
         yield* text.takeThinking();
         yield transcript({
             type: 'assistant',
-            message: { role: 'assistant', content: [{ type: 'text', text: textBlock.text }], ...messageIdentityOf(m, ctx) },
+            message: { role: 'assistant', content: [{ type: 'text', text: rowText }], ...messageIdentityOf(m, ctx) },
             uuid: idOf(m),
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
@@ -139,7 +142,7 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
             ...toolHistoryKeyCarry(m),
             ...providerResendKeyCarry(m),
         }, ctx.now());
-        text.markEmittedText(textBlock.text);
+        text.markEmittedText(rowText);
     }
     const thinkingBlock = blocks.find(b => b?.type === 'thinking');
     if (thinkingBlock && typeof thinkingBlock.thinking === 'string') {
@@ -712,9 +715,9 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
         return lowerBound && ot === 0 ? undefined : ot;
     });
     yield* text.takeAnswerSegment();
-    const salvaged = m._sema_salvaged_result;
+    const salvaged = readFrameStringKey(m, '_sema_salvaged_result');
     const errorEnvelope = typeof m.subtype === 'string' && m.subtype.startsWith(ERROR_SUBTYPE_PREFIX);
-    const terminalText = typeof salvaged === 'string' ? salvaged : !errorEnvelope && typeof m.result === 'string' ? m.result : '';
+    const terminalText = salvaged !== undefined ? salvaged : !errorEnvelope && typeof m.result === 'string' ? m.result : '';
     const committed = text.lastCommittedAnswerText;
     const terminalIdentity = messageIdentityOf(m, ctx);
     const emitTerminal = function* (body, tag) {

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -1,6 +1,6 @@
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../../gateVocabulary.js';
 import { stamp } from '../types.js';
-import { putOwnKey } from '../../ownKey.js';
+import { putOwnKey, readFrameStringKey } from '../../ownKey.js';
 import { REDACTION_MARKER_PREFIX, washCredentials } from '../../displayUntrusted.js';
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
 import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalGateToolName, } from '../../runTerminal.js';
@@ -522,8 +522,7 @@ export function doneToSdkResult(ev, ctx, observed) {
     const durationMs = elapsedMs(ctx);
     const errorCode = runTerminalCode(terminal);
     const degraded = degradedOf(r);
-    const parkFailedRaw = ev._sema_park_failed_reason;
-    const parkFailedReason = typeof parkFailedRaw === 'string' && parkFailedRaw.length > 0 ? parkFailedRaw : undefined;
+    const parkFailedReason = readFrameStringKey(ev, '_sema_park_failed_reason');
     const errorBase = { durationMs, stats, model: r.model, errorCode, degraded, observed, facts: effectiveFactParts(rec), parkFailedReason, abortCause: abortCauseWordOf(ev) };
     if (terminal?.kind === 'failed') {
         const failedCode = terminal.code;

package/dist/agentSession/engineSessionBackgroundStop.js

@@ -3,6 +3,7 @@ import { isStatusDerivedCoarseCode } from '../engineErrorCodes.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
 import { engineWireDebugEnabled } from '../engineWireTarget.js';
 import { hostLog } from '../host.js';
+import { wireFailureTextsOf } from '../wireFailureShape.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 const NOTHING_SENT = ' — nothing sent';
 const DETAIL_BAD_SESSION = `the session id must be a non-empty string${NOTHING_SENT}`;
@@ -164,7 +165,7 @@ function classifyFailure(e) {
     try {
         if (typeof e !== 'object' || e === null) {
             note('error (non-object failure)');
-            return { kind: 'error', detail: `the stop request failed: ${String(e).slice(0, 200)}` };
+            return { kind: 'error', detail: `the stop request failed: ${wireFailureTextsOf(e).reason.slice(0, 200)}` };
         }
         const d = diagOf(e);
         if (d.status === undefined && d.errorCode === undefined) {

package/dist/agentsWireCaps.d.ts

@@ -1,5 +1,6 @@
 import { type EngineProbeOpts, type WireAuthTokenSource } from './engineWireSdk.js';
 import type { ReasoningEffort } from './effortWire.js';
+import type { ToolRosterView } from './toolRoster.js';
 export declare const MAX_TASK_AGENTS = 32;
 export declare const MAX_AGENT_NAME_CHARS = 64;
 export declare const MAX_AGENT_TEXT_CHARS = 4096;
@@ -56,11 +57,25 @@ export type ProjectAgentsDeps = {
     };
     effortToThinking: (effort: unknown) => WireThinkingLevel | undefined;
     skillSpecs?: TaskAgentWireSkill[];
+    toolRoster?: ToolRosterView | null;
+    withholdRefusedDenyLists?: boolean;
+    agentSourceLabel?: (agentName: string) => string | undefined;
 };
 export type ProjectAgentsResult = {
     agents: TaskAgentWireItem[] | undefined;
     warnings: string[];
+    toolListFlaws?: readonly AgentToolListFlaw[];
 };
+export type AgentToolListFlawKind = 'retired' | 'unprefixed_namespace' | 'case_twin';
+export interface AgentToolListFlaw {
+    readonly agent: string;
+    readonly list: 'tools' | 'disallowedTools';
+    readonly entry: string;
+    readonly kind: AgentToolListFlawKind;
+    readonly currentName?: string;
+    readonly toolName?: string;
+}
+export declare function agentToolListFlaws(agents: readonly TaskAgentWireItem[] | undefined, roster?: ToolRosterView | null): AgentToolListFlaw[];
 export declare function projectAgentsForWire(defs: readonly AgentDefLike[], deps: ProjectAgentsDeps): ProjectAgentsResult;
 export declare function engineSupportsTaskAgents(baseUrl: string, opts?: EngineProbeOpts): Promise<boolean | undefined>;
 export type WireConfig = {

package/dist/agentsWireCaps.js

@@ -2,6 +2,10 @@ import { hostEnv } from './hostEnv.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
 import { frozenSet } from './frozenSet.js';
 import { settleWithinDeadline } from './abortableSleep.js';
+import { isEngineRefusedToolName } from './engineRefusedToolName.js';
+import { CORE_PROTOCOL_PREFIXES, CORE_RETIRED_TOOL_CURRENT_NAMES } from './generated/toolNameTables.js';
+import { rosterMountedNames } from './rosterMountedNames.js';
+import { capForDisplay } from './fleetTaskDesc.js';
 export const MAX_TASK_AGENTS = 32;
 export const MAX_AGENT_NAME_CHARS = 64;
 export const MAX_AGENT_TEXT_CHARS = 4_096;
@@ -38,6 +42,82 @@ const SOURCE_RANK = {
 function sourceRank(source) {
     return SOURCE_RANK[source] ?? 5;
 }
+const RETIRED_TABLE_CURRENT_NAMES = frozenSet([...CORE_RETIRED_TOOL_CURRENT_NAMES.values()].filter((v) => typeof v === 'string'));
+function unescapedIndexOf(s, ch, last) {
+    for (let k = 0; k < s.length; k++) {
+        const i = last ? s.length - 1 - k : k;
+        if (s[i] !== ch)
+            continue;
+        let backslashes = 0;
+        for (let j = i - 1; j >= 0 && s[j] === '\\'; j--)
+            backslashes++;
+        if (backslashes % 2 === 0)
+            return i;
+    }
+    return -1;
+}
+function deniedEntryToolName(entry) {
+    if (entry !== entry.trim())
+        return undefined;
+    const open = unescapedIndexOf(entry, '(', false);
+    if (open === -1)
+        return entry;
+    const close = unescapedIndexOf(entry, ')', true);
+    if (close === -1 || close <= open || close !== entry.length - 1)
+        return entry;
+    const name = entry.substring(0, open);
+    return name.length === 0 ? entry : name.trim();
+}
+function toolNameFlawOf(entry, names, list) {
+    if (typeof entry !== 'string' || entry.length === 0 || entry === '*')
+        return undefined;
+    const name = list === 'disallowedTools' ? deniedEntryToolName(entry) : entry.includes('(') ? undefined : entry;
+    if (name === undefined || name.length === 0 || name === '*' || names.has(name))
+        return undefined;
+    const named = name !== entry ? { toolName: name } : {};
+    if (isEngineRefusedToolName(name)) {
+        const current = CORE_RETIRED_TOOL_CURRENT_NAMES.get(name);
+        if (current === undefined)
+            return { kind: 'unprefixed_namespace', ...named };
+        return typeof current === 'string' ? { kind: 'retired', currentName: current, ...named } : { kind: 'retired', ...named };
+    }
+    if (CORE_PROTOCOL_PREFIXES.some((prefix) => name.startsWith(prefix)))
+        return undefined;
+    const folded = name.toLowerCase();
+    for (const n of names)
+        if (n !== name && n.toLowerCase() === folded)
+            return { kind: 'case_twin', currentName: n, ...named };
+    return undefined;
+}
+export function agentToolListFlaws(agents, roster) {
+    if (!Array.isArray(agents) || agents.length === 0)
+        return [];
+    const mounted = rosterMountedNames(roster);
+    const names = typeof mounted === 'object' ? mounted : RETIRED_TABLE_CURRENT_NAMES;
+    const out = [];
+    for (const a of agents) {
+        if (a === null || typeof a !== 'object' || typeof a.name !== 'string')
+            continue;
+        for (const [list, entries] of [['disallowedTools', a.denyTools], ['tools', a.allowTools]]) {
+            if (!Array.isArray(entries))
+                continue;
+            for (const entry of entries) {
+                const f = toolNameFlawOf(entry, names, list);
+                if (f !== undefined)
+                    out.push({ agent: a.name, list, entry: entry, ...f });
+            }
+        }
+    }
+    return out;
+}
+function toolListFlawPhrase(f) {
+    const entry = f.toolName !== undefined ? `${JSON.stringify(f.entry)} names the tool ${JSON.stringify(f.toolName)}, which` : JSON.stringify(f.entry);
+    if (f.kind === 'retired')
+        return `${entry} is a retired tool name${f.currentName !== undefined ? ` (now ${JSON.stringify(f.currentName)})` : ' (no longer available under any name)'}`;
+    if (f.kind === 'unprefixed_namespace')
+        return `${entry} contains "__" but does not start with a tool protocol prefix`;
+    return `${entry} differs from the tool ${JSON.stringify(f.currentName ?? '')} only in letter case`;
+}
 export function projectAgentsForWire(defs, deps) {
     const warnings = [];
     const customs = defs
@@ -51,6 +131,7 @@ export function projectAgentsForWire(defs, deps) {
         warnings.push(`agents wire: ${customs.length} custom agents exceed the engine cap of ${MAX_TASK_AGENTS} — keeping the ${MAX_TASK_AGENTS} highest-precedence definitions, dropped: ${dropped.join(', ')}`);
     }
     const out = [];
+    const toolListFlaws = [];
     const seen = new Set();
     for (const def of capped) {
         const name = def.agentType;
@@ -94,6 +175,35 @@ export function projectAgentsForWire(defs, deps) {
         const denyTools = projectTools(def.disallowedTools, 'disallowedTools');
         if (denyTools)
             item.denyTools = denyTools;
+        const flaws = agentToolListFlaws([item], deps.toolRoster);
+        if (flaws.length > 0) {
+            let source;
+            try {
+                source = deps.agentSourceLabel?.(name);
+            }
+            catch {
+                source = undefined;
+            }
+            const who = `agent "${name}"${typeof source === 'string' && source.length > 0 ? ` (${capForDisplay(source, 120)})` : ''}`;
+            toolListFlaws.push(...flaws);
+            const denyFlaws = flaws.filter(f => f.list === 'disallowedTools');
+            const withhold = denyFlaws.length > 0 && deps.withholdRefusedDenyLists === true;
+            if (denyFlaws.length > 0) {
+                const what = `its disallowedTools ${denyFlaws.length === 1 ? 'entry' : 'entries'} ${denyFlaws.map(toolListFlawPhrase).join('; ')}`;
+                warnings.push(withhold
+                    ? `agents wire: ${who} is not sent to the engine — ${what}, and this engine refuses to start a run whose agent definitions name a tool that way. Fix the entry in the agent definition; until then this agent is not available.`
+                    : `agents wire: ${who}: ${what} — tool names are matched exactly, so ${denyFlaws.length === 1 ? 'this entry hides' : 'these entries hide'} nothing from the agent, and newer engines refuse to start a run with it. Fix the entry in the agent definition.`);
+            }
+            if (!withhold) {
+                for (const f of flaws) {
+                    if (f.list !== 'tools')
+                        continue;
+                    warnings.push(`agents wire: ${who}: its tools entry ${toolListFlawPhrase(f)} — tool names are matched exactly, so this entry does not give the agent that tool. Fix the entry in the agent definition.`);
+                }
+            }
+            if (withhold)
+                continue;
+        }
         if (def.memory !== undefined) {
             if (typeof def.memory === 'string' && AGENT_MEMORY_WORDS.has(def.memory)) {
                 item.memory = { scopes: [`agent:${name}`], writeScope: `agent:${name}` };
@@ -171,7 +281,7 @@ export function projectAgentsForWire(defs, deps) {
         }
         out.push(item);
     }
-    return { agents: out.length > 0 ? out : undefined, warnings };
+    return { agents: out.length > 0 ? out : undefined, warnings, ...(toolListFlaws.length > 0 ? { toolListFlaws } : {}) };
 }
 export async function engineSupportsTaskAgents(baseUrl, opts) {
     if (opts?.client !== undefined) {

package/dist/approvalReachWire.d.ts

@@ -0,0 +1,18 @@
+import { CORE_APPROVAL_REACH } from './generated/engineFactTables.js';
+export type ApprovalReachWord = (typeof CORE_APPROVAL_REACH)[number];
+export declare function refuseBadApprovalReach(v: unknown, who: string): void;
+export type ApprovalReachWithheldCause = 'not_reported' | 'unsupported' | 'unprobed' | 'unreadable';
+export type ApprovalReachDeclaration = {
+    readonly field: {
+        readonly approvalReach: Extract<ApprovalReachWord, 'none'>;
+    };
+    readonly withheld?: undefined;
+} | {
+    readonly field: Readonly<Record<string, never>>;
+    readonly withheld?: {
+        readonly cause: ApprovalReachWithheldCause;
+        readonly text: string;
+    };
+};
+export declare function approvalReachDeclaration(approverReachable: boolean | null | undefined, baseUrl: string | undefined): ApprovalReachDeclaration;
+export declare function approvalReachDeclarationSettled(approverReachable: boolean | null | undefined, baseUrl: string | undefined, withinMs: number): Promise<ApprovalReachDeclaration>;

package/dist/approvalReachWire.js

@@ -0,0 +1,58 @@
+import { CORE_APPROVAL_REACH } from './generated/engineFactTables.js';
+import { engineCapState, engineCapsSettled } from './engineCapsCache.js';
+const KEY = 'approvalReach';
+const APPROVAL_REACH_NONE = 'none';
+const WORDS = new Set(CORE_APPROVAL_REACH);
+const shapeOf = (v) => {
+    try {
+        return v === null ? 'null' : Array.isArray(v) ? 'typeof=object / array' : typeof v === 'string' ? `typeof=string(长 ${v.length})` : `typeof=${typeof v}`;
+    }
+    catch {
+        return `typeof=${typeof v} / unreadable`;
+    }
+};
+export function refuseBadApprovalReach(v, who) {
+    if (v === undefined || v === null)
+        return;
+    if (typeof v === 'string' && WORDS.has(v))
+        return;
+    throw new TypeError(`${who}: approvalReach 只接受引擎闭集里的词(${[...CORE_APPROVAL_REACH].join(' / ')})或缺席(undefined/null)—— 收到 ${shapeOf(v)}。` +
+        '这一位是「这条运行上没有人能答审批」的声明,值只经片段口 approvalReachDeclaration 铸;本层若把坏值折成缺席,这一发会照常发审批卡而声明方不会知道。' +
+        '上游对闭集外的值同样拒收。错误文本只报形状,不回显值。');
+}
+function refuseBadApproverReachable(v, who) {
+    if (v === undefined || v === null || v === true || v === false)
+        return;
+    throw new TypeError(`${who}: approverReachable 只接受布尔或缺席(undefined/null)—— 收到 ${shapeOf(v)}。` +
+        '这一位是「这一车道上有没有能答审批的面」这一事实:false = 没有(片段口据此声明),true / 缺席 = 有或没说(不声明,与今天的行为相同)。错误文本只报形状,不回显值。');
+}
+const WITHHELD_TEXT = Object.freeze({
+    not_reported: 'Approval requests on this run will still be sent to this session: the connected engine does not report that it can be told nobody here can answer them, and an engine that does not know this setting rejects the whole request, so the setting was left out.',
+    unsupported: 'Approval requests on this run will still be sent to this session: the connected engine reports that it cannot be told nobody here can answer them, so the setting was left out.',
+    unprobed: 'Approval requests on this run will still be sent to this session: what the connected engine supports has not been read yet, and an engine that does not know this setting rejects the whole request, so the setting was held back.',
+    unreadable: 'Approval requests on this run will still be sent to this session: the connected engine reported whether it can be told nobody here can answer them in a form this version cannot read, so the setting was left out.',
+});
+const WITHHELD_CAUSE_OF = {
+    absent: 'not_reported',
+    false: 'unsupported',
+    unprobed: 'unprobed',
+    non_boolean: 'unreadable',
+};
+const EMPTY = Object.freeze({ field: Object.freeze({}) });
+export function approvalReachDeclaration(approverReachable, baseUrl) {
+    refuseBadApproverReachable(approverReachable, 'approvalReachDeclaration');
+    if (approverReachable !== false)
+        return EMPTY;
+    const state = engineCapState(baseUrl, KEY);
+    if (state === 'true')
+        return Object.freeze({ field: Object.freeze({ approvalReach: APPROVAL_REACH_NONE }) });
+    const cause = WITHHELD_CAUSE_OF[state];
+    return Object.freeze({ field: Object.freeze({}), withheld: Object.freeze({ cause, text: WITHHELD_TEXT[cause] }) });
+}
+export async function approvalReachDeclarationSettled(approverReachable, baseUrl, withinMs) {
+    refuseBadApproverReachable(approverReachable, 'approvalReachDeclarationSettled');
+    if (approverReachable !== false)
+        return approvalReachDeclaration(approverReachable, baseUrl);
+    await engineCapsSettled(baseUrl, { withinMs: typeof withinMs === 'number' ? withinMs : 0 });
+    return approvalReachDeclaration(approverReachable, baseUrl);
+}

package/dist/approvalsStreamLiveCapability.js

@@ -1,18 +1,23 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 export function projectApprovalsStreamLiveCapability(caps) {
-    if (caps === null || typeof caps !== 'object')
-        return undefined;
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'approvalsStreamLive'))
-        return { kind: 'not_reported' };
-    const v = caps.approvalsStreamLive;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'boolean')
+    try {
+        if (caps === null || typeof caps !== 'object')
+            return undefined;
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        if (!Object.hasOwn(caps, 'approvalsStreamLive'))
+            return { kind: 'not_reported' };
+        const v = caps.approvalsStreamLive;
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'boolean')
+            return undefined;
+        return { kind: 'present', live: v };
+    }
+    catch {
         return undefined;
-    return { kind: 'present', live: v };
+    }
 }
 const reader = createEngineCapReader({
     name: 'approvalsStreamLive',

package/dist/callerCwdCapability.d.ts

@@ -0,0 +1,16 @@
+export type CallerCwdReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    value: boolean;
+};
+export declare function projectCallerCwdCapability(caps: unknown): CallerCwdReading | undefined;
+export declare function noteEngineCapsForCallerCwd(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedCallerCwd(baseUrl?: string | undefined): CallerCwdReading;
+export declare function callerCwdAdmitted(reading: CallerCwdReading | undefined): boolean;
+export declare function forgetCallerCwdReading(baseUrl: string | undefined): void;
+export declare function __resetCallerCwdReadingsForTests(): void;

package/dist/callerCwdCapability.js

@@ -0,0 +1,47 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { readOwnDataValue } from './ownKey.js';
+export function projectCallerCwdCapability(caps) {
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        if (!Object.hasOwn(caps, 'callerCwd'))
+            return { kind: 'not_reported' };
+        const v = caps.callerCwd;
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        return typeof v === 'boolean' ? { kind: 'present', value: v } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const reader = createEngineCapReader({
+    name: 'callerCwd',
+    project: projectCallerCwdCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForCallerCwd(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedCallerCwd(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function callerCwdAdmitted(reading) {
+    try {
+        if (reading === null || reading === undefined || typeof reading !== 'object' || Array.isArray(reading))
+            return false;
+        if (readOwnDataValue(reading, 'kind') !== 'present')
+            return false;
+        return readOwnDataValue(reading, 'value') === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function forgetCallerCwdReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetCallerCwdReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/controlRouter.js

@@ -90,12 +90,9 @@ export class ControlRouter {
             return await this.client.runs.cancel(this.taskId, opts?.signal !== undefined ? { signal: opts.signal } : undefined);
         }
         catch (e) {
-            if (cancelConflictFromError(e)?.kind === 'run_not_running') {
-                throw controlSafetyRefusal('cancel_run_not_running', 'runs.cancel 409 conflict.run_not_running', cancelConflictContent({ kind: 'run_not_running' }), e);
-            }
-            if (isCancelSuspendedConflict(e)) {
-                throw controlSafetyRefusal('cancel_lost_race', 'runs.cancel 409', 'the pending gate was decided or expired concurrently (lost CAS race); ' +
-                    'check what that decision did to the run before retrying the cancel', e);
+            const conflict = cancelConflictFromError(e);
+            if (conflict !== null) {
+                throw controlSafetyRefusal(conflict.kind === 'run_not_running' ? 'cancel_run_not_running' : 'cancel_lost_race', conflict.code === undefined ? 'runs.cancel 409' : `runs.cancel 409 ${conflict.code}`, cancelConflictContent(conflict), e);
             }
             if (isNotFound(e)) {
                 throw controlSafetyRefusal('not_found', 'runs.cancel 404', `${CANCEL_NOT_FOUND_COPY.happened} — ${CANCEL_NOT_FOUND_COPY.nextStep}`, e);
@@ -310,10 +307,6 @@ export function steerBodyOf(input, reading) {
         throw steerLocalRefusal('priority_not_applied', tierMode);
     return Object.freeze({ ...base, priority });
 }
-function isCancelSuspendedConflict(e) {
-    const { name, status } = errCodes(e);
-    return name === 'ConflictError' || status === 409;
-}
 function isNotFound(e) {
     const { name, status } = errCodes(e);
     return name === 'NotFoundError' || status === 404;

package/dist/coreValuePorts.d.ts

@@ -48,6 +48,49 @@ export interface ValidatePermissionRulesOptionsView {
         readonly [base: string]: string | undefined;
     };
 }
+export interface AllowListReadingView {
+    readonly inert: readonly {
+        readonly entry: string;
+        readonly reason: string;
+    }[];
+}
+export interface RouteModelView {
+    readonly id: string;
+    readonly baseUrl: string;
+}
+export interface RouteCredentialInputView {
+    optionsApiKey?: string;
+    optionsHeaders?: Record<string, string>;
+    modelHeaders?: Record<string, string>;
+    configApiKey?: string;
+    configHeaders?: Record<string, string>;
+}
+export interface RouteCredentialView {
+    source: 'per-model' | 'deployment-config' | 'absent' | (string & {});
+    apiKey?: string;
+    headersBorne?: boolean;
+    carrierBag?: 'options' | 'model' | 'config' | (string & {});
+}
+export type RouteAdjudicationView = {
+    ok: true;
+    posture: 'per-model' | 'paired' | 'unpinned' | 'keyless' | (string & {});
+} | {
+    ok: false;
+    code: 'route.credential_mismatch' | 'route.credential_missing' | (string & {});
+    detail: RouteRefusalDetailView;
+};
+export interface RouteRefusalDetailView {
+    modelId: string;
+    entryBaseUrl: string;
+    requestBaseUrl: string;
+    configBaseUrl?: string;
+    fixHint: string;
+}
+export type RoutePairingStatusView = `ok:${string}` | `broken:${string}` | 'unknown';
+export interface PerModelAuthView {
+    apiKey?: string;
+    headers?: Record<string, string>;
+}
 export interface CoreValuePorts {
     resolveAutonomousLoopPrompt: (prompt: string, opts?: AutonomousLoopPromptOptionsView) => string | null;
     loosenReasons: (prior: SessionPermissionRules, next: SessionPermissionRules) => string[];
@@ -60,8 +103,18 @@ export interface CoreValuePorts {
     validatePermissionRules: (rules: PermissionRuleView[], opts?: ValidatePermissionRulesOptionsView) => PermissionRuleIssueView[];
     DISCUSSION_WORKFLOW_NAME: string;
     mintNamespacePrefix(ns: CoreProtocolNamespaceView, peer: string): string;
+    compileAllowList(entries: readonly string[], behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): AllowListReadingView;
+    routeKeyOf(url: string | undefined): string;
+    joinRequestUrl(root: string | undefined, suffix: string): string;
+    resolveRouteCredential(input: RouteCredentialInputView): RouteCredentialView;
+    adjudicateModelRoute(model: RouteModelView, credential: RouteCredentialView, config: {
+        baseUrl?: string;
+    }): RouteAdjudicationView;
+    routePairingStatus(brain: {
+        adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
+    }, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView;
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "RETIRED_TOOL_NAMES", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "DISCUSSION_WORKFLOW_NAME", "mintNamespacePrefix"];
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "RETIRED_TOOL_NAMES", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "DISCUSSION_WORKFLOW_NAME", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -78,3 +131,13 @@ export declare function ruleToolGrammarOf(toolName: string): 'command' | 'path'
 export declare function validatePermissionRules(rules: PermissionRuleView[], opts?: ValidatePermissionRulesOptionsView): PermissionRuleIssueView[] | undefined;
 export declare function discussionWorkflowName(): string | undefined;
 export declare function mintNamespacePrefix(ns: CoreProtocolNamespaceView, peer: string): string | undefined;
+export declare function compileAllowList(entries: readonly string[], behavior: 'allow' | 'deny', roster?: ReadonlySet<string>): AllowListReadingView | undefined;
+export declare function routeKeyOf(url: string | undefined): string | undefined;
+export declare function joinRequestUrl(root: string | undefined, suffix: string): string | undefined;
+export declare function resolveRouteCredential(input: RouteCredentialInputView): RouteCredentialView | undefined;
+export declare function adjudicateModelRoute(model: RouteModelView, credential: RouteCredentialView, config: {
+    baseUrl?: string;
+}): RouteAdjudicationView | undefined;
+export declare function routePairingStatus(brain: {
+    adjudicateRoute?(model: RouteModelView, perModelAuth?: PerModelAuthView): RouteAdjudicationView | undefined;
+}, model: RouteModelView, perModelAuth?: PerModelAuthView): RoutePairingStatusView | undefined;

package/dist/coreValuePorts.js

@@ -10,6 +10,12 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'validatePermissionRules',
     'DISCUSSION_WORKFLOW_NAME',
     'mintNamespacePrefix',
+    'compileAllowList',
+    'routeKeyOf',
+    'joinRequestUrl',
+    'resolveRouteCredential',
+    'adjudicateModelRoute',
+    'routePairingStatus',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -72,3 +78,27 @@ export function mintNamespacePrefix(ns, peer) {
     const fn = port('mintNamespacePrefix');
     return fn === undefined ? undefined : fn(ns, peer);
 }
+export function compileAllowList(entries, behavior, roster) {
+    const fn = port('compileAllowList');
+    return fn === undefined ? undefined : fn(entries, behavior, roster);
+}
+export function routeKeyOf(url) {
+    const fn = port('routeKeyOf');
+    return fn === undefined ? undefined : fn(url);
+}
+export function joinRequestUrl(root, suffix) {
+    const fn = port('joinRequestUrl');
+    return fn === undefined ? undefined : fn(root, suffix);
+}
+export function resolveRouteCredential(input) {
+    const fn = port('resolveRouteCredential');
+    return fn === undefined ? undefined : fn(input);
+}
+export function adjudicateModelRoute(model, credential, config) {
+    const fn = port('adjudicateModelRoute');
+    return fn === undefined ? undefined : fn(model, credential, config);
+}
+export function routePairingStatus(brain, model, perModelAuth) {
+    const fn = port('routePairingStatus');
+    return fn === undefined ? undefined : fn(brain, model, perModelAuth);
+}

package/dist/detachWire.d.ts

@@ -10,10 +10,7 @@ export type DetachResolution = {
     on: false;
     reason: 'env-off';
 };
-export declare function resolveHeadlessDetach(_baseUrl: string, env?: EnvLike, _opts?: {
-    fetchImpl?: typeof fetch;
-    timeoutMs?: number;
-}): Promise<DetachResolution>;
+export declare function resolveHeadlessDetach(env?: EnvLike): Promise<DetachResolution>;
 export declare const DETACH_DURABLE_OFF_400_ANCHOR = "x-detach-on-disconnect requires a durable run";
 export declare function isDetachDurableOff400(err: unknown): boolean;
 export declare function detachDurableOffHint(err: unknown): string | null;

package/dist/detachWire.js

@@ -6,7 +6,7 @@ export const HEADLESS_DETACH_ENV = 'SEMA_HEADLESS_DETACH';
 export function headlessDetachDisabledByEnv(env = hostEnv()) {
     return envFlagOff(env[HEADLESS_DETACH_ENV]);
 }
-export async function resolveHeadlessDetach(_baseUrl, env = hostEnv(), _opts) {
+export async function resolveHeadlessDetach(env = hostEnv()) {
     if (headlessDetachDisabledByEnv(env))
         return { on: false, reason: 'env-off' };
     return { on: true, reason: 'default-on' };