@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/ruleRefusalSentence.js

@@ -10,6 +10,7 @@ const CLASS_OF_REASON = Object.freeze({
     home_relative_path: 'homePath',
     compile_refused: 'compile',
     paren_in_tool_name: 'compile',
+    content_form_never_matches: 'neverMatches',
 });
 function reasonOf(row, lang) {
     const cls = typeof row.reason === 'string' && Object.hasOwn(CLASS_OF_REASON, row.reason) ? CLASS_OF_REASON[row.reason] : undefined;
@@ -17,6 +18,8 @@ function reasonOf(row, lang) {
         return renderMessage(msg('rules.refusal.reason.toolName'), lang);
     if (cls === 'homePath')
         return renderMessage(msg('rules.refusal.reason.homePath'), lang);
+    if (cls === 'neverMatches')
+        return renderMessage(msg('rules.refusal.reason.neverMatches'), lang);
     if (cls === 'compile')
         return permissionRuleIssueDetail(row.code, row.message, row.rule, lang);
     return undefined;
@@ -48,11 +51,14 @@ export function ruleRefusalSentence(rows, lang) {
     }
     if (items.length === 0)
         return undefined;
+    const listText = ruleRefusalListText(items, lang);
+    return renderMessage(items.length === 1 ? msg('rules.refusal.sentence.one', { list: listText }) : msg('rules.refusal.sentence.other', { count: items.length, list: listText }), lang);
+}
+export function ruleRefusalListText(items, lang) {
     const shown = items.slice(0, RULE_REFUSAL_NAMED_MAX);
     const separator = renderMessage(msg('rules.refusal.itemSeparator'), lang);
-    const named = shown.map((it) => renderMessage(msg('rules.refusal.item', { rule: nameOf(it.rule), reason: it.reason }), lang)).join(separator);
+    const named = shown.map((it) => (it.rule === undefined ? it.reason : renderMessage(msg('rules.refusal.item', { rule: nameOf(it.rule), reason: it.reason }), lang))).join(separator);
     const rest = items.length - shown.length;
     const list = rest > 0 ? msg('rules.refusal.list.more', { shown: named, count: rest }) : named;
-    const listText = typeof list === 'string' ? list : renderMessage(list, lang);
-    return renderMessage(items.length === 1 ? msg('rules.refusal.sentence.one', { list: listText }) : msg('rules.refusal.sentence.other', { count: items.length, list: listText }), lang);
+    return typeof list === 'string' ? list : renderMessage(list, lang);
 }

package/dist/runCancelContext.d.ts

@@ -30,7 +30,6 @@ export type RunAbortCause = {
 };
 export declare const RUN_CANCELLED_CODE: "cancelled";
 export declare function classifyRunAbortCause(record: unknown): RunAbortCause;
-export declare const ABORT_CAUSES: readonly ["client_disconnected", "ask_park_grace_exhausted", "cancel_verb"];
 export type { AbortCause };
 export type AbortCauseReading = {
     readonly kind: 'known';

package/dist/runCancelContext.js

@@ -57,7 +57,6 @@ export function classifyRunAbortCause(record) {
         return { kind: 'run_still_live', status };
     return { kind: 'unknown', ...(read !== null ? { terminal: read.kind } : {}) };
 }
-export const ABORT_CAUSES = SDK_ABORT_CAUSES;
 const _abortCauseTablePin = true;
 void _abortCauseTablePin;
 function ownDataOf(o, key) {
@@ -85,7 +84,7 @@ function abortCauseIn(holder) {
     const raw = ownDataOf(holder, 'abortCause');
     if (typeof raw !== 'string' || raw.length === 0)
         return undefined;
-    return ABORT_CAUSES.includes(raw) ? { kind: 'known', cause: raw } : { kind: 'unrecognized', word: raw };
+    return SDK_ABORT_CAUSES.includes(raw) ? { kind: 'known', cause: raw } : { kind: 'unrecognized', word: raw };
 }
 export function readAbortCause(frame) {
     try {

package/dist/runTerminal.d.ts

@@ -27,6 +27,9 @@ export type RunTerminalFailureDetail = RunTerminalProviderRejectedDetail | {
 export type RunTerminalJsonValue = string | number | boolean | null | readonly RunTerminalJsonValue[] | {
     readonly [key: string]: RunTerminalJsonValue;
 };
+export type RunTerminalCodedDetail = {
+    readonly [key: string]: RunTerminalJsonValue;
+};
 export interface RunTerminalOutputLimit {
     capStop: boolean;
     outputTokens?: number;
@@ -94,6 +97,8 @@ type RunTerminalReadArm = {
     code?: string;
     message?: string;
 };
+export declare function runTerminalCodedDetail(read: RunTerminalRead | null | undefined): RunTerminalCodedDetail | undefined;
+export declare function terminalCodedDetailOf(carrier: {} | null | undefined): RunTerminalCodedDetail | undefined;
 export declare function readRunTerminal(result: unknown): RunTerminalRead | null;
 export declare const REVIEW_PARK_GATE_KINDS: readonly string[];
 export declare function runTerminalGateKind(read: RunTerminalRead | null): string | undefined;

package/dist/runTerminal.js

@@ -2,6 +2,7 @@ import { CORE_PROMPT_BLOCK_CAUSES } from './generated/engineFactTables.js';
 import { isSdkRunParked } from './terminalStatuses.js';
 import { readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 import { doneResultView } from './replayBody.js';
+import { washCredentials } from './displayUntrusted.js';
 export const PROMPT_BLOCK_CAUSES = CORE_PROMPT_BLOCK_CAUSES;
 const _promptBlockTablePin = true;
 void _promptBlockTablePin;
@@ -39,7 +40,7 @@ void _modelOutputInvalidCausePin;
 const CODED_DETAIL_MAX_DEPTH = 40;
 function ownData(o, k) {
     const d = Object.getOwnPropertyDescriptor(o, k);
-    return d !== undefined && 'value' in d ? d.value : undefined;
+    return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
 }
 function isPlainRecord(v) {
     if (typeof v !== 'object' || v === null || Array.isArray(v))
@@ -53,8 +54,10 @@ function jsonSnapshot(v, depth, ctx) {
     ctx.budget -= 1;
     if (ctx.budget < 0)
         throw CODED_DETAIL_OVER_BUDGET;
-    if (v === null || typeof v === 'string' || typeof v === 'boolean')
+    if (v === null || typeof v === 'boolean')
         return v;
+    if (typeof v === 'string')
+        return ctx.leaf === undefined ? v : ctx.leaf(v);
     if (typeof v === 'number')
         return Number.isFinite(v) ? v : undefined;
     if (depth >= CODED_DETAIL_MAX_DEPTH)
@@ -148,6 +151,51 @@ function requestRouteOf(d) {
         return undefined;
     }
 }
+function codedBodySnapshot(inner, washLeaves = false) {
+    if (!isPlainRecord(inner))
+        return undefined;
+    let snap;
+    try {
+        snap = jsonSnapshot(inner, 0, { budget: CODED_DETAIL_BUDGET, path: new Set(), ...(washLeaves ? { leaf: washCredentials } : {}) });
+    }
+    catch (e) {
+        if (e === CODED_DETAIL_OVER_BUDGET)
+            return undefined;
+        throw e;
+    }
+    if (snap === undefined || snap === null || typeof snap !== 'object' || Array.isArray(snap))
+        return undefined;
+    return snap;
+}
+export function runTerminalCodedDetail(read) {
+    try {
+        if (typeof read !== 'object' || read === null)
+            return undefined;
+        if (ownData(read, 'kind') !== 'failed')
+            return undefined;
+        const detail = ownData(read, 'detail');
+        if (typeof detail !== 'object' || detail === null)
+            return undefined;
+        if (ownData(detail, 'kind') !== CODED_DETAIL_KIND)
+            return undefined;
+        const body = codedBodySnapshot(ownData(detail, 'detail'), true);
+        return body !== undefined && Object.keys(body).length > 0 ? body : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function terminalCodedDetailOf(carrier) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null || Array.isArray(carrier))
+            return undefined;
+        const body = codedBodySnapshot(ownData(carrier, '_sema_coded_detail'), true);
+        return body !== undefined && Object.keys(body).length > 0 ? body : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function failureDetailOf(cause) {
     try {
         const own = ownValueOf;
@@ -185,21 +233,8 @@ function failureDetailOf(cause) {
             };
         }
         if (kind === CODED_DETAIL_KIND) {
-            const inner = ownData(v, 'detail');
-            if (!isPlainRecord(inner))
-                return undefined;
-            let snap;
-            try {
-                snap = jsonSnapshot(inner, 0, { budget: CODED_DETAIL_BUDGET, path: new Set() });
-            }
-            catch (e) {
-                if (e === CODED_DETAIL_OVER_BUDGET)
-                    return undefined;
-                throw e;
-            }
-            if (snap === undefined || snap === null || typeof snap !== 'object' || Array.isArray(snap))
-                return undefined;
-            return { kind: CODED_DETAIL_KIND, detail: snap };
+            const snap = codedBodySnapshot(ownData(v, 'detail'));
+            return snap === undefined ? undefined : { kind: CODED_DETAIL_KIND, detail: snap };
         }
         if (kind === MODEL_OUTPUT_INVALID_DETAIL_KIND) {
             const c = ownData(v, 'cause');

package/dist/sandboxWire.d.ts

@@ -14,7 +14,7 @@ export type SandboxParseResult = {
     ok: false;
     error: string;
 };
-export declare function parseSandboxArgv(argv: readonly string[]): SandboxParseResult;
+export declare function sandboxFromFlag(value?: string): SandboxParseResult;
 export declare function sandboxRequestFields(sel: SandboxSelection | undefined): {
     sandboxImageProfile?: string;
 };

package/dist/sandboxWire.js

@@ -1,4 +1,3 @@
-import { lastFlagValue } from './argvFlagValue.js';
 import { CAPABILITY_IMAGE_INDEX_REQUIRED, CAPABILITY_K8S_LANE_REQUIRED, isStatusDerivedCoarseCode, NOT_FOUND_IMAGE, REQUEST_FIELD_CONFLICT, REQUEST_PRECONDITION_UNMET } from './engineErrorCodes.js';
 import { THROWN_SLOT_UNREADABLE, readThrownSlot } from './wireFailureShape.js';
 const MAX_PROFILE_LEN = 128;
@@ -6,13 +5,12 @@ const USAGE_HINT = "sema: --sandbox expects a profile name or 'auto'.\n" +
     '  --sandbox <profile>  run on that sandbox image profile (k8s-lane workers; list: sema cloud images list)\n' +
     '  --sandbox auto       let the model pick via its SelectEnvironment tool (advisory — choice + reason shown in the reply)\n' +
     '  (no flag)            the worker default image';
-export function parseSandboxArgv(argv) {
-    const flag = lastFlagValue(argv, '--sandbox');
-    if (!flag.present)
+export function sandboxFromFlag(value) {
+    if (value === undefined)
         return { ok: true, sel: { mode: 'default' } };
-    if (flag.raw === undefined)
+    if (typeof value !== 'string')
         return { ok: false, error: USAGE_HINT };
-    const v = flag.raw.trim();
+    const v = value.trim();
     if (v.length === 0)
         return { ok: false, error: USAGE_HINT };
     if (/\s/.test(v)) {

package/dist/scenarioRefusal.js

@@ -34,7 +34,7 @@ export function scenarioRefusalOf(body) {
         const d = Object.getOwnPropertyDescriptor(body, 'scenarioRefusal');
         if (d === undefined)
             return undefined;
-        raw = 'value' in d ? d.value : undefined;
+        raw = Object.hasOwn(d, 'value') ? d.value : undefined;
     }
     catch {
         return null;

package/dist/scenarioSkills.d.ts

@@ -0,0 +1,20 @@
+type ScenarioCardSkillSource = 'factory' | 'center' | 'unknown-source';
+export interface ScenarioCardSkill {
+    readonly name: string;
+    readonly description: string;
+    readonly source: ScenarioCardSkillSource;
+}
+export declare function scenarioSkillsOf(card: object | null | undefined): readonly ScenarioCardSkill[] | undefined;
+export type ScenarioSkillsCapabilityReading = {
+    readonly kind: 'confirmed';
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'declined';
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'unobserved';
+};
+export declare function observedScenarioSkillsCapability(baseUrl?: string | undefined): ScenarioSkillsCapabilityReading;
+export {};

package/dist/scenarioSkills.js

@@ -0,0 +1,72 @@
+import { engineCapValue } from './engineCapsCache.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
+import { appendOwnElement, guardedRead, readOwnDataValue } from './ownKey.js';
+const SKILLS_READ_BUDGET = 100_000;
+function skillOfEntry(raw) {
+    try {
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+            return undefined;
+        const name = readOwnDataValue(raw, 'name');
+        if (typeof name !== 'string' || name.length === 0)
+            return undefined;
+        const description = readOwnDataValue(raw, 'description');
+        if (typeof description !== 'string')
+            return undefined;
+        const source = guardedRead(() => readOwnDataValue(raw, 'source'));
+        return Object.freeze({
+            name,
+            description,
+            source: source === 'factory' || source === 'center' ? source : 'unknown-source',
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function scenarioSkillsOf(card) {
+    try {
+        if (typeof card !== 'object' || card === null)
+            return undefined;
+        const list = readOwnDataValue(card, 'skills');
+        if (!Array.isArray(list))
+            return undefined;
+        const lengthDesc = Object.getOwnPropertyDescriptor(list, 'length');
+        const length = lengthDesc !== undefined && Object.hasOwn(lengthDesc, 'value') ? lengthDesc.value : undefined;
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0 || length > SKILLS_READ_BUDGET)
+            return undefined;
+        const out = [];
+        for (let i = 0; i < length; i++) {
+            const entry = guardedRead(() => skillOfEntry(readOwnDataValue(list, String(i))));
+            if (entry !== undefined)
+                appendOwnElement(out, entry);
+        }
+        if (length > 0 && out.length === 0)
+            return undefined;
+        return Object.freeze(out);
+    }
+    catch {
+        return undefined;
+    }
+}
+const SCENARIO_SKILLS_CAPABILITY_KEY = 'scenarioSkills';
+export function observedScenarioSkillsCapability(baseUrl) {
+    try {
+        const base = baseUrl === undefined ? engineWireTargetBaseUrl() : baseUrl;
+        const slot = engineCapValue(typeof base === 'string' ? base : undefined, SCENARIO_SKILLS_CAPABILITY_KEY);
+        switch (slot.kind) {
+            case 'unobserved':
+                return Object.freeze({ kind: 'unobserved' });
+            case 'not_reported':
+                return Object.freeze({ kind: 'absent' });
+            case 'unreadable':
+                return Object.freeze({ kind: 'unreadable' });
+            case 'null':
+                return Object.freeze({ kind: 'declined' });
+            case 'value':
+                return slot.value === true ? Object.freeze({ kind: 'confirmed' }) : Object.freeze({ kind: 'declined' });
+        }
+    }
+    catch {
+        return Object.freeze({ kind: 'unobserved' });
+    }
+}

package/dist/scenarioWire.d.ts

@@ -8,6 +8,9 @@ export type ScenarioParseResult = {
     ok: false;
     error: string;
 };
-export declare function parseScenarioArgv(argv: readonly string[]): ScenarioParseResult;
+export interface ScenarioFlag {
+    readonly flag?: string;
+    readonly missing?: true;
+}
 export declare function headlessScenarioFromEnv(env?: EnvLike): string | undefined;
-export declare function scenarioForPrint(argv: string[], env?: EnvLike): ScenarioParseResult;
+export declare function scenarioForPrint(flag: ScenarioFlag | undefined, env?: EnvLike): ScenarioParseResult;

package/dist/scenarioWire.js

@@ -1,18 +1,18 @@
 import { hostEnv } from './hostEnv.js';
-import { lastFlagValue } from './argvFlagValue.js';
+import { flagIsWronglyTyped, flagString, flagTrue } from './flagInput.js';
 export const SCENARIO_NAME_RE = /^[a-z][a-z0-9-]{1,31}$/;
 export const HEADLESS_SCENARIO_ENV = 'SEMA_HEADLESS_SCENARIO';
 const USAGE_HINT = "sema: --scenario expects a scenario name (lowercase letters/digits/hyphens, starting with a letter, ≤32 chars).\n" +
     '  --scenario <name>    route this run through the named engine scenario (deployment-defined tool\n' +
     '                       roster + system prompt; unknown names are refused by the engine (scenario_unknown))\n' +
     '  (no flag)            the default scenario — today\'s behaviour';
-export function parseScenarioArgv(argv) {
-    const flag = lastFlagValue(argv, '--scenario');
-    if (!flag.present)
-        return { ok: true };
-    if (flag.raw === undefined)
+function parseScenarioFlag(input) {
+    if (flagIsWronglyTyped(input, 'flag'))
         return { ok: false, error: USAGE_HINT };
-    const v = flag.raw.trim();
+    const value = flagString(input, 'flag');
+    if (value === undefined)
+        return flagTrue(input, 'missing') ? { ok: false, error: USAGE_HINT } : { ok: true };
+    const v = value.trim();
     if (/\s/.test(v)) {
         return {
             ok: false,
@@ -36,8 +36,8 @@ export function headlessScenarioFromEnv(env = hostEnv()) {
     }
     return v;
 }
-export function scenarioForPrint(argv, env = hostEnv()) {
-    const parsed = parseScenarioArgv(argv);
+export function scenarioForPrint(flag, env = hostEnv()) {
+    const parsed = parseScenarioFlag(flag);
     if (!parsed.ok)
         return parsed;
     if (parsed.scenario)

package/dist/sealedKeyCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 function ownNonEmpty(seg, key) {
@@ -29,6 +29,6 @@ const reader = createEngineCapReader({
     name: 'sealedKey',
     project: projectSealedKeyCapability,
 });
-export function observedSealedKey(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSealedKey(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }

package/dist/seam.d.ts

@@ -7,6 +7,7 @@ import type { WiringManifestFleetView } from './adapter/downstream/wiringManifes
 import type { SuspendedReopenReading } from './hitl/suspendedReopen.js';
 import type { ToolKillCause } from './toolResult.js';
 import type { HumanInputAttachmentView } from './ownKey.js';
+import type { TaskNotificationFields } from './notifications.js';
 export interface AbortSignalLike {
     readonly aborted: boolean;
 }
@@ -115,6 +116,7 @@ export type ChromeEvent = {
     status: 'completed' | 'failed';
     summary: string;
     message: string;
+    notification: Readonly<TaskNotificationFields>;
 } | {
     kind: 'task_ledger_sync';
     laneProof: LaneProof;

package/dist/seam.js

@@ -201,14 +201,14 @@ export function terminalOwnerOf(row) {
         if (typeof row !== 'object' || row === null)
             return undefined;
         const d = Object.getOwnPropertyDescriptor(row, SEMA_TERMINAL_OWNER_KEY);
-        if (d === undefined || !('value' in d))
+        if (d === undefined || !Object.hasOwn(d, 'value'))
             return undefined;
         const v = d.value;
         if (typeof v !== 'object' || v === null)
             return undefined;
         const own = (k) => {
             const pd = Object.getOwnPropertyDescriptor(v, k);
-            return pd !== undefined && 'value' in pd && typeof pd.value === 'string' && pd.value.length > 0 ? pd.value : undefined;
+            return pd !== undefined && Object.hasOwn(pd, 'value') && typeof pd.value === 'string' && pd.value.length > 0 ? pd.value : undefined;
         };
         const kind = own('kind');
         if (kind === 'request-not-sent') {

package/dist/seatContract.d.ts

@@ -79,7 +79,52 @@ export interface ToolPermissionRequest {
 declare const SEAT_EVENT_TYPE_TUPLE: readonly ["start", "close", "session_updated", "message", "stream_event", "chrome_event", "error", "tool_permission_resolved", "subagent_content"];
 export type SeatEventType = (typeof SEAT_EVENT_TYPE_TUPLE)[number];
 export declare const SEAT_EVENT_TYPES: readonly SeatEventType[];
-declare const CHROME_EVENT_KIND_TUPLE: readonly ["panel_task", "notification_terminal", "prompt_suggestions", "subagent_lifecycle", "text_segment_end", "thinking_segment_end", "retry_status", "context_usage", "last_turn_usage", "bgshell_register", "bgshell_settle", "memory_saved", "result_replayed", "tool_parked"];
+declare const CHROME_ARM_SEAT_ROUTE: {
+    readonly panel_task: "seat";
+    readonly notification_terminal: "seat";
+    readonly prompt_suggestions: "seat";
+    readonly subagent_lifecycle: "seat";
+    readonly text_segment_end: "seat";
+    readonly thinking_segment_end: "seat";
+    readonly retry_status: "seat";
+    readonly context_usage: "seat";
+    readonly last_turn_usage: "seat";
+    readonly bgshell_register: "seat";
+    readonly bgshell_settle: "seat";
+    readonly memory_saved: "seat";
+    readonly result_replayed: "seat";
+    readonly tool_parked: "seat";
+    readonly compaction_started: "seat";
+    readonly compaction_outcome: "seat";
+    readonly engine_notice: "seat";
+    readonly workflow_notification_enqueue: "host";
+    readonly plan_review_park: "host";
+    readonly approval_request: "host";
+    readonly approval_revoke: "host";
+    readonly task_ledger_sync: "host";
+    readonly inline_task_stats: "host";
+    readonly stream_delta: "host";
+    readonly thinking_activity: "host";
+    readonly request_start: "host";
+    readonly response_metrics: "host";
+    readonly attachment: "host";
+    readonly subagent_turn_usage: "host";
+    readonly run_cost_reconciled: "host";
+    readonly message_committed: "host";
+    readonly human_input: "host";
+    readonly tool_roster_delta: "host";
+    readonly subagent_started: "host";
+    readonly prompt_assembled: "host";
+    readonly tool_disclosure: "host";
+    readonly tool_progress: "host";
+    readonly wiring_manifest: "host";
+    readonly suspended_reopened: "host";
+    readonly result_text_diverged: "host";
+};
+type SeatRoutedKind = {
+    [K in keyof typeof CHROME_ARM_SEAT_ROUTE]: (typeof CHROME_ARM_SEAT_ROUTE)[K] extends "seat" ? K : never;
+}[keyof typeof CHROME_ARM_SEAT_ROUTE];
+declare const CHROME_EVENT_KIND_TUPLE: readonly SeatRoutedKind[];
 export type ChromeEventKind = Extract<ChromeArmKind, (typeof CHROME_EVENT_KIND_TUPLE)[number]>;
 export declare const CHROME_EVENT_KINDS: readonly ChromeEventKind[];
 export interface SeatChromeEnvelopeBase {

package/dist/seatContract.js

@@ -62,7 +62,7 @@ const firstAccessorPath = (root) => {
             const at = path === "" ? k : `${path}.${k}`;
             if (!Object.hasOwn(d, "value"))
                 return at;
-            stack.push([d.value, at]);
+            Object.defineProperty(stack, stack.length, { value: [d.value, at], writable: true, enumerable: true, configurable: true });
         }
     }
     return undefined;
@@ -197,7 +197,7 @@ const firstSecretKeyPath = (root, allow) => {
             const at = isArr && /^[0-9]+$/.test(k) ? `${path}[${k}]` : pathAt(path, k);
             if (isSecretKeyName(k) && !allow.has(at))
                 return at;
-            stack.push([d.value, at]);
+            Object.defineProperty(stack, stack.length, { value: [d.value, at], writable: true, enumerable: true, configurable: true });
         }
     }
     return undefined;
@@ -251,22 +251,49 @@ const SEAT_EVENT_TYPE_TUPLE = [
     "subagent_content",
 ];
 export const SEAT_EVENT_TYPES = Object.freeze(SEAT_EVENT_TYPE_TUPLE);
-const CHROME_EVENT_KIND_TUPLE = [
-    "panel_task",
-    "notification_terminal",
-    "prompt_suggestions",
-    "subagent_lifecycle",
-    "text_segment_end",
-    "thinking_segment_end",
-    "retry_status",
-    "context_usage",
-    "last_turn_usage",
-    "bgshell_register",
-    "bgshell_settle",
-    "memory_saved",
-    "result_replayed",
-    "tool_parked",
-];
+const CHROME_ARM_SEAT_ROUTE = {
+    panel_task: "seat",
+    notification_terminal: "seat",
+    prompt_suggestions: "seat",
+    subagent_lifecycle: "seat",
+    text_segment_end: "seat",
+    thinking_segment_end: "seat",
+    retry_status: "seat",
+    context_usage: "seat",
+    last_turn_usage: "seat",
+    bgshell_register: "seat",
+    bgshell_settle: "seat",
+    memory_saved: "seat",
+    result_replayed: "seat",
+    tool_parked: "seat",
+    compaction_started: "seat",
+    compaction_outcome: "seat",
+    engine_notice: "seat",
+    workflow_notification_enqueue: "host",
+    plan_review_park: "host",
+    approval_request: "host",
+    approval_revoke: "host",
+    task_ledger_sync: "host",
+    inline_task_stats: "host",
+    stream_delta: "host",
+    thinking_activity: "host",
+    request_start: "host",
+    response_metrics: "host",
+    attachment: "host",
+    subagent_turn_usage: "host",
+    run_cost_reconciled: "host",
+    message_committed: "host",
+    human_input: "host",
+    tool_roster_delta: "host",
+    subagent_started: "host",
+    prompt_assembled: "host",
+    tool_disclosure: "host",
+    tool_progress: "host",
+    wiring_manifest: "host",
+    suspended_reopened: "host",
+    result_text_diverged: "host",
+};
+const CHROME_EVENT_KIND_TUPLE = Object.keys(CHROME_ARM_SEAT_ROUTE).filter((k) => CHROME_ARM_SEAT_ROUTE[k] === "seat");
 export const CHROME_EVENT_KINDS = Object.freeze(CHROME_EVENT_KIND_TUPLE);
 const LANE_PROOF_LANE_TUPLE = ["main", "subagent", "workflow"];
 export const SEAT_CHROME_ENVELOPE_KEYS = ["kind", "laneProof"];
@@ -340,7 +367,7 @@ export function seatCapability(state, name) {
         const desc = Object.getOwnPropertyDescriptor(state, name);
         if (desc === undefined)
             return notReported();
-        if (!("value" in desc))
+        if (!Object.hasOwn(desc, "value"))
             return malformedReading();
         const v = desc.value;
         if (v === undefined)
@@ -1084,9 +1111,11 @@ const SEAT_CHROME_PAYLOAD_SPECS = {
         registration: reqF(shapeRule("registration", {
             kind: reqF(oneOfRule("registration kind", ["register"])),
             taskId: reqF(R_NONEMPTY),
+            toolUseId: optF(R_NONEMPTY),
             command: reqF(R_STR),
             description: optF(R_STR),
             receipt: reqF(R_STR),
+            outputFile: optF(R_NONEMPTY),
             source: reqF(oneOfRule("registration source", ["bash", "monitor"])),
         })),
     },
@@ -2021,5 +2050,6 @@ const _seatContractPins = [
     true, true, true,
     true,
     true, true, true,
+    true, true,
 ];
 void _seatContractPins;

package/dist/selfOrchestrationDenial.js

@@ -43,7 +43,7 @@ function ownRead(o, key) {
         const d = Object.getOwnPropertyDescriptor(o, key);
         if (d === undefined)
             return ABSENT;
-        if ('get' in d || 'set' in d)
+        if (Object.hasOwn(d, 'get') || Object.hasOwn(d, 'set'))
             return ACCESSOR;
         return { kind: 'data', value: d.value };
     }

package/dist/sessionPolicyCapability.js

@@ -1,4 +1,4 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { ownDataField } from './ownKey.js';
@@ -22,7 +22,7 @@ const reader = createEngineCapReader({
     name: 'sessionPolicy',
     project: projectSessionPolicyCapability,
 });
-export function observedSessionPolicy(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSessionPolicy(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function sessionPolicyFaceAvailable(reading) {

package/dist/sessionRulesChildrenReadLive.d.ts

@@ -0,0 +1,6 @@
+export interface SessionRulesManifestSeat {
+    readonly sessionRules?: {
+        readonly childrenReadLive?: boolean;
+    };
+}
+export declare function sessionRulesChildrenReadLiveOf(manifest: SessionRulesManifestSeat | null | undefined): boolean | undefined;

package/dist/sessionRulesChildrenReadLive.js

@@ -0,0 +1,5 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+export function sessionRulesChildrenReadLiveOf(manifest) {
+    const raw = guardedRead(() => readOwnDataValue(readOwnDataValue(manifest, 'sessionRules'), 'childrenReadLive'));
+    return typeof raw === 'boolean' ? raw : undefined;
+}

package/dist/sessionRulesNamespaceFormsCapability.d.ts

@@ -0,0 +1,12 @@
+export type SessionRulesNamespaceFormsReading = {
+    readonly kind: 'confirmed';
+} | {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'declined';
+} | {
+    readonly kind: 'unreadable';
+} | {
+    readonly kind: 'unobserved';
+};
+export declare function observedSessionRulesNamespaceForms(baseUrl?: string | undefined): SessionRulesNamespaceFormsReading;