@sema-agent/client-core 0.105.0 → 0.106.0

package/dist/liveInitToolFace.js

@@ -40,7 +40,6 @@ export const ENGINE_RUNNER_FACE = [
     'SendMessage',
     'ListAgents',
     'Skill',
-    'TaskOutput',
     'TaskStop',
     'ToolSearch',
     'Workflow',

package/dist/liveModelCatalog.d.ts

@@ -22,6 +22,7 @@ export interface LiveModelCatalog {
     };
     droppedEntries?: readonly LiveModelDroppedEntry[];
     candidateRejected?: unknown;
+    modelPlane?: {} | null;
 }
 export declare function setLiveModelCatalog(next: LiveModelCatalog | null): void;
 export declare function setLiveModelCatalogRefresher(fn: (() => Promise<LiveModelCatalog | null>) | null): void;
@@ -103,6 +104,20 @@ export type ModelCandidateRejectedReading = {
     readonly kind: 'unreadable';
 };
 export declare function modelCandidateRejectedOf(catalog?: LiveModelCatalog | null): ModelCandidateRejectedReading;
+export declare const MODEL_PLANE_SERVED_TABLES: readonly ["env", "catalog"];
+export type ModelPlaneServedTable = (typeof MODEL_PLANE_SERVED_TABLES)[number];
+export declare const MODEL_PLANE_CATALOG_STANCES: readonly ["absent", "adopted", "refused"];
+export type ModelPlaneCatalogStance = (typeof MODEL_PLANE_CATALOG_STANCES)[number];
+export type ModelPlaneReading = {
+    readonly kind: 'not_reported';
+} | {
+    readonly kind: 'read';
+    readonly servedTable?: ModelPlaneServedTable;
+    readonly catalog?: ModelPlaneCatalogStance;
+} | {
+    readonly kind: 'unreadable';
+};
+export declare function modelPlaneOf(catalog?: LiveModelCatalog | null): ModelPlaneReading;
 export declare function modelCandidateRejectedContent(reading: ModelCandidateRejectedReading, lang?: UiLanguage): string | undefined;
 export interface RoutePairingVerdict {
     verdict: 'ok' | 'broken' | 'unknown';

package/dist/liveModelCatalog.js

@@ -383,6 +383,43 @@ export function modelCandidateRejectedOf(catalog = getLiveModelCatalog()) {
         return unreadable;
     }
 }
+export const MODEL_PLANE_SERVED_TABLES = Object.freeze(['env', 'catalog']);
+export const MODEL_PLANE_CATALOG_STANCES = Object.freeze(['absent', 'adopted', 'refused']);
+const inWords = (words, v) => typeof v === 'string' && words.includes(v);
+export function modelPlaneOf(catalog = getLiveModelCatalog()) {
+    const unreadable = Object.freeze({ kind: 'unreadable' });
+    try {
+        if (catalog === null || typeof catalog !== 'object' || Array.isArray(catalog))
+            return Object.freeze({ kind: 'not_reported' });
+        if (!Object.hasOwn(catalog, 'modelPlane'))
+            return Object.freeze({ kind: 'not_reported' });
+        const d = Object.getOwnPropertyDescriptor(catalog, 'modelPlane');
+        if (d === undefined || !(Object.hasOwn(d, 'value')))
+            return unreadable;
+        const v = d.value;
+        if (v === undefined)
+            return Object.freeze({ kind: 'not_reported' });
+        if (v === null || typeof v !== 'object' || Array.isArray(v))
+            return unreadable;
+        const proto = Object.getPrototypeOf(v);
+        if (proto !== Object.prototype && proto !== null)
+            return unreadable;
+        const dServed = Object.getOwnPropertyDescriptor(v, 'servedTable');
+        const dStance = Object.getOwnPropertyDescriptor(v, 'catalog');
+        if ((dServed !== undefined && !Object.hasOwn(dServed, 'value')) || (dStance !== undefined && !Object.hasOwn(dStance, 'value')))
+            return unreadable;
+        const servedTable = dServed?.value;
+        const stance = dStance?.value;
+        return Object.freeze({
+            kind: 'read',
+            ...(inWords(MODEL_PLANE_SERVED_TABLES, servedTable) ? { servedTable } : {}),
+            ...(inWords(MODEL_PLANE_CATALOG_STANCES, stance) ? { catalog: stance } : {}),
+        });
+    }
+    catch {
+        return unreadable;
+    }
+}
 const CONFIG_DOMAIN_WORD = /^[a-z][a-z0-9_.-]{0,63}$/;
 export function modelCandidateRejectedContent(reading, lang) {
     try {
@@ -429,6 +466,7 @@ export function readLiveModelCatalog(body) {
         const defaultModelKey = envelopeKey(body, 'defaultModel');
         const droppedKey = envelopeKey(body, 'droppedEntries');
         const candidateKey = envelopeKey(body, 'candidateRejected');
+        const planeKey = envelopeKey(body, 'modelPlane');
         const raw = modelsKey.present ? modelsKey.value : undefined;
         if (!Array.isArray(raw))
             return unreadableCatalog('models_not_array');
@@ -464,6 +502,8 @@ export function readLiveModelCatalog(body) {
         }
         if (candidateKey.present && candidateKey.value !== undefined)
             out.candidateRejected = frozenJsonCopyOf(candidateKey.value) ?? null;
+        if (planeKey.present && planeKey.value !== undefined)
+            out.modelPlane = frozenJsonCopyOf(planeKey.value) ?? null;
         return Object.freeze({ kind: 'read', catalog: Object.freeze(out), unreadableRows, ...(defaultModelMalformed ? { defaultModelMalformed: true } : {}) });
     }
     catch {

package/dist/mcpWireCaps.js

@@ -448,6 +448,6 @@ export function mcpAssertionHeaderNotSentNotice(specs) {
     const parts = distinct.slice(0, ASSERTION_NOTICE_NAMES_SHOWN).map((x) => `"${x}"`);
     if (distinct.length > ASSERTION_NOTICE_NAMES_SHOWN)
         parts.push(`+${distinct.length - ASSERTION_NOTICE_NAMES_SHOWN} more`);
-    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.139.0 accept this setting but do not send the header, ` +
+    return (`MCP servers that declare an assertion header (assertionHeader): ${parts.join(', ')} — server versions up to 7.144.0 accept this setting but do not send the header, ` +
         'and this client cannot tell whether the engine it uses sends it; a connector that requires the header will refuse requests from these servers');
 }

package/dist/modelCapabilityProbe.js

@@ -155,15 +155,48 @@ function isBusyStatus(status) {
 function looksBusyError(apiError) {
     return apiError !== undefined && /overload|rate.?limit|too many requests|too busy|server busy|capacity/i.test(apiError);
 }
-function apiErrorOf(parsed) {
-    const e = parsed?.error;
-    if (!e || typeof e !== 'object')
+function wordOf(v) {
+    if (typeof v === 'string')
+        return v.trim() === '' ? undefined : v;
+    return typeof v === 'number' && Number.isFinite(v) && v !== 0 ? String(v) : undefined;
+}
+function hasContent(v, depth = 0) {
+    if (typeof v === 'string')
+        return v.trim() !== '';
+    if (typeof v === 'number')
+        return Number.isFinite(v) && v !== 0;
+    if (v === true)
+        return true;
+    if (v === null || typeof v !== 'object')
+        return false;
+    if (depth >= 2)
+        return true;
+    return (Array.isArray(v) ? v : Object.values(v)).some((x) => hasContent(x, depth + 1));
+}
+function errorBodyOf(parsed) {
+    if (parsed === null || typeof parsed !== 'object')
         return undefined;
-    return [e.code ?? e.type, e.message].filter(Boolean).join(': ') || undefined;
+    const e = parsed.error;
+    const o = e;
+    if (o !== null && o !== undefined && typeof o === 'object' && !Array.isArray(o)) {
+        const legacy = [o.code ?? o.type, o.message].filter(Boolean).join(': ');
+        if (legacy !== '')
+            return { words: legacy, standard: true };
+    }
+    if (!hasContent(e))
+        return undefined;
+    if (typeof e !== 'object' || e === null) {
+        const words = wordOf(e);
+        return words === undefined ? { standard: false } : { words, standard: false };
+    }
+    if (Array.isArray(e))
+        return { standard: false };
+    const words = [wordOf(o?.code) ?? wordOf(o?.type) ?? wordOf(o?.status), wordOf(o?.message) ?? wordOf(o?.detail)].filter((x) => x !== undefined).join(': ');
+    return { ...(words !== '' ? { words } : {}), standard: false };
 }
-function extractApiError(body) {
+function extractErrorBody(body) {
     try {
-        return apiErrorOf(JSON.parse(body));
+        return errorBodyOf(JSON.parse(body));
     }
     catch {
         return undefined;
@@ -189,12 +222,10 @@ function shownApiError(raw, redact) {
     const shown = displayUntrusted(masked, { max: 200 });
     return shown.trim() === '' ? undefined : shown;
 }
-function looksLikeModelError(status, apiError) {
+function namesModel(status, apiError) {
     if (status !== 400 && status !== 404 && status !== 422)
         return false;
-    if (!apiError)
-        return status === 404;
-    return /model/i.test(apiError);
+    return apiError !== undefined && /model/i.test(apiError);
 }
 const MESSAGES_PATH = '/v1/messages';
 const COMPLETIONS_PATH = '/chat/completions';
@@ -204,33 +235,33 @@ function verdictRequestBody(modelId) {
     return JSON.stringify({ model: modelId ?? '', max_tokens: 1, messages: [{ role: 'user', content: 'hi' }], stream: true });
 }
 function judgeMessagesFailure(status, body, hasModelId, near, redact) {
-    if (status === 401 || status === 403)
-        return { verdict: 'auth', httpStatus: status, path: MESSAGES_PATH };
-    const apiError = extractApiError(body);
+    const eb = extractErrorBody(body);
+    const apiError = eb?.words;
+    const standard = eb?.standard === true;
     const shown = shownApiError(apiError, redact);
     const ev = { httpStatus: status, path: MESSAGES_PATH, ...(shown !== undefined ? { apiError: shown } : {}) };
+    if (status === 401 || status === 403)
+        return { verdict: 'auth', ...ev };
     if (isBusyStatus(status) || looksBusyError(apiError))
         return { verdict: 'busy', ...ev };
-    if (status === 404 && !apiError)
-        return { verdict: 'shape', httpStatus: status, path: MESSAGES_PATH };
-    if (looksLikeModelError(status, apiError)) {
-        if (!hasModelId)
-            return { verdict: 'ok', httpStatus: status, path: MESSAGES_PATH };
-        return { verdict: 'model', ...ev, ...(near !== undefined ? { nearModelId: near } : {}) };
-    }
-    if (!hasModelId && status >= 400 && status < 500 && apiError)
+    if (!hasModelId && standard && status >= 400 && status < 500)
         return { verdict: 'ok', httpStatus: status, path: MESSAGES_PATH };
+    if (hasModelId && namesModel(status, apiError))
+        return { verdict: 'model', ...ev, ...(near !== undefined ? { nearModelId: near } : {}) };
+    if (status === 404 && !standard)
+        return { verdict: 'shape', ...ev };
     return { verdict: 'other', ...ev };
 }
 function judgeCompletionsFailure(status, body, near, redact) {
-    if (status === 401 || status === 403)
-        return { verdict: 'auth', httpStatus: status, path: COMPLETIONS_PATH };
-    const apiError = extractApiError(body);
+    const eb = extractErrorBody(body);
+    const apiError = eb?.words;
     const shown = shownApiError(apiError, redact);
     const ev = { httpStatus: status, path: COMPLETIONS_PATH, ...(shown !== undefined ? { apiError: shown } : {}) };
+    if (status === 401 || status === 403)
+        return { verdict: 'auth', ...ev };
     if (isBusyStatus(status) || looksBusyError(apiError))
         return { verdict: 'busy', ...ev };
-    if (looksLikeModelError(status, apiError))
+    if (namesModel(status, apiError) || (status === 404 && eb?.standard !== true))
         return { verdict: 'model', ...ev, ...(near !== undefined ? { nearModelId: near } : {}) };
     return { verdict: 'other', ...ev };
 }
@@ -318,9 +349,9 @@ function judgeJsonBody(text, contentType, api) {
     if (obj === null || typeof obj !== 'object')
         return { kind: 'not_model', contentType };
     const o = obj;
-    const apiError = apiErrorOf(o);
-    if (apiError !== undefined || o.type === 'error')
-        return { kind: 'error', ...(apiError !== undefined ? { apiError } : {}) };
+    const eb = errorBodyOf(o);
+    if (eb !== undefined || o.type === 'error')
+        return { kind: 'error', ...(eb?.words !== undefined ? { apiError: eb.words } : {}) };
     const usage = (o.usage ?? null);
     if (api === 'anthropic-messages') {
         if (o.type !== 'message' && !Array.isArray(o.content))
@@ -365,9 +396,9 @@ function createAnswerScanner(contentType, api) {
         if (obj === null || typeof obj !== 'object')
             return;
         const o = obj;
-        const apiError = apiErrorOf(o);
-        if (ev === 'error' || o.type === 'error' || apiError !== undefined) {
-            settled = { kind: 'error', ...(apiError !== undefined ? { apiError } : {}) };
+        const eb = errorBodyOf(o);
+        if (ev === 'error' || o.type === 'error' || eb !== undefined) {
+            settled = { kind: 'error', ...(eb?.words !== undefined ? { apiError: eb.words } : {}) };
             return;
         }
         if (isTokenFrame(o, api))
@@ -667,8 +698,10 @@ async function livenessOf(input) {
         }
     }
     const gate = await getCatalogText(fetchIt, urlOf(MODELS_PATH_OPENAI), getHeaders, catalogBudget, input.signal);
-    if (gate.status === 401 || gate.status === 403)
-        return { verdict: 'auth', httpStatus: gate.status, path: '/models' };
+    if (gate.status === 401 || gate.status === 403) {
+        const shown = shownApiError(extractErrorBody(gate.text)?.words, redact);
+        return { verdict: 'auth', httpStatus: gate.status, path: '/models', ...(shown !== undefined ? { apiError: shown } : {}) };
+    }
     if (isBusyStatus(gate.status))
         return { verdict: 'busy', httpStatus: gate.status, path: '/models' };
     if (gate.status < 200 || gate.status >= 300)

package/dist/ownKey.d.ts

@@ -43,7 +43,6 @@ export interface PromptManifestSectionRow {
     locale?: string;
     variant?: string;
     contentHash?: string;
-    slot?: string;
 }
 export interface PromptManifestIdentityRow {
     readonly artifact: string;

package/dist/ownKey.js

@@ -221,7 +221,6 @@ export function promptManifestSectionViewOf(row) {
     const locale = str(o.locale);
     const variant = str(o.variant);
     const contentHash = band !== undefined ? str(o.contentHash) : undefined;
-    const slot = str(o.slot);
     return {
         id,
         chars,
@@ -229,7 +228,6 @@ export function promptManifestSectionViewOf(row) {
         ...(locale !== undefined ? { locale } : {}),
         ...(variant !== undefined ? { variant } : {}),
         ...(contentHash !== undefined ? { contentHash } : {}),
-        ...(slot !== undefined ? { slot } : {}),
     };
 }
 export function promptManifestIdentityOfFrame(frame) {

package/dist/permissionsDeclaration.d.ts

@@ -6,6 +6,7 @@ declare const SETTINGS_SOURCE_TIERS: Readonly<{
     readonly userSettings: "global";
     readonly localSettings: "project";
     readonly projectSettings: "project";
+    readonly foreignProjectSettings: "project";
 }>;
 declare const OFF_LADDER_ROWS: readonly [{
     readonly origin: "cliArg";
@@ -29,7 +30,6 @@ export interface PermissionsDeclarationInput {
     readonly cliDeny?: readonly string[];
     readonly settingsRead: 'clean' | 'partial' | 'unreadable';
     readonly clientOwnedServers?: readonly string[];
-    readonly serverVersion?: string;
 }
 export interface PermissionsDeclarationBuckets {
     deny?: string[];
@@ -57,7 +57,7 @@ export interface HostPermissionsBuckets {
 export interface HostPermissionsDeclaration {
     permissions?: HostPermissionsBuckets;
 }
-export declare const PERMISSIONS_KEPT_REASONS: readonly ["allow_capability_off", "settings_read_not_clean", "empty_rule", "paren_in_tool_name", "retired_tool_name", "unprefixed_namespaced_name", "incomplete_protocol_name", "unminted_protocol_segment", "home_relative_path", "compile_refused", "content_form_not_grantable", "content_form_never_matches", "judge_failed", "duplicate", "voids_allow_list"];
+export declare const PERMISSIONS_KEPT_REASONS: readonly ["allow_capability_off", "settings_read_not_clean", "empty_rule", "paren_in_tool_name", "retired_tool_name", "unprefixed_namespaced_name", "incomplete_protocol_name", "unminted_protocol_segment", "home_relative_path", "compile_refused", "content_form_not_grantable", "judge_failed", "duplicate", "voids_allow_list"];
 export type PermissionsKeptReason = (typeof PERMISSIONS_KEPT_REASONS)[number];
 export interface PermissionsKeptRule {
     rule: string;

package/dist/permissionsDeclaration.js

@@ -1,6 +1,6 @@
 import { compileAllowList, hasCoreValuePort, protocolOf, ruleToolGrammarOf } from './coreValuePorts.js';
 import { clientOwnedServerPrefix, ruleToolNameVerdictOf } from './protocolSegment.js';
-import { ruleCompileVerdict, tightenEntryNeverMatches } from './ruleCompileVerdict.js';
+import { ruleCompileVerdict } from './ruleCompileVerdict.js';
 import { allowRulesGate, allowWireForm } from './permissionsAllowGrantCapability.js';
 import { SETTINGS_IS_AT_LEAST } from './generated/settingsSchemaFns.js';
 import { THROWN_SLOT_UNREADABLE, asAssemblyRefusal, assemblyRefusalOf, isSlotCarrier, readThrownSlot, withAssemblyRefusal } from './wireFailureShape.js';
@@ -11,8 +11,9 @@ const SETTINGS_SOURCE_TIERS = Object.freeze({
     userSettings: 'global',
     localSettings: 'project',
     projectSettings: 'project',
+    foreignProjectSettings: 'project',
 });
-const SAME_TIER_ORDER = ['flagSettings', 'userSettings', 'localSettings', 'projectSettings'];
+const SAME_TIER_ORDER = ['flagSettings', 'userSettings', 'localSettings', 'projectSettings', 'foreignProjectSettings'];
 const OFF_LADDER_ROWS = Object.freeze([
     { origin: 'cliArg', after: 'policySettings' },
     { origin: 'session', after: 'flagSettings' },
@@ -47,7 +48,6 @@ export const PERMISSIONS_KEPT_REASONS = Object.freeze([
     'home_relative_path',
     'compile_refused',
     'content_form_not_grantable',
-    'content_form_never_matches',
     'judge_failed',
     'duplicate',
     'voids_allow_list',
@@ -154,7 +154,7 @@ function tighteningWholeName(name, check) {
     const next = nameCheck(successor);
     return 'retired' in next || 'issue' in next ? name : successor;
 }
-function judgeList(rules, behavior, allowForm = 'grant', serverVersion) {
+function judgeList(rules, behavior, allowForm = 'grant') {
     let portsChecked = false;
     return rules.map((rule) => {
         if (rule === '')
@@ -184,7 +184,7 @@ function judgeList(rules, behavior, allowForm = 'grant', serverVersion) {
         }
         const check = nameCheck(parsed.toolName);
         if (behavior !== 'allow')
-            return tightenEntryNeverMatches(rule, serverVersion) ? kept('content_form_never_matches') : { sent: true, wire: rule };
+            return { sent: true, wire: rule };
         if ('retired' in check)
             return kept('retired_tool_name');
         if ('issue' in check)
@@ -244,7 +244,7 @@ function allowListVoiders(sent) {
         return 'unknown';
     }
 }
-function judgeBucket(raw, behavior, originOf, cli, settingsGate, allowForm = 'grant', dropWire, owned = [], serverVersion, layeredFrom) {
+function judgeBucket(raw, behavior, originOf, cli, settingsGate, allowForm = 'grant', dropWire, owned = [], layeredFrom) {
     const firstSlot = new Map();
     for (const s of raw)
         if (!firstSlot.has(s.rule))
@@ -288,7 +288,7 @@ function judgeBucket(raw, behavior, originOf, cli, settingsGate, allowForm = 'gr
     };
     const appendGroup = (group, origin) => {
         const held = settingsGate !== undefined && !outsideSettingsFiles(origin);
-        const fates = held ? group.map(() => kept(settingsGate)) : judgeList(group, behavior, allowForm, serverVersion);
+        const fates = held ? group.map(() => kept(settingsGate)) : judgeList(group, behavior, allowForm);
         group.forEach((r, k) => {
             const f = place(firstSlot.get(r), fates[k], origin);
             if (!fateOfRule.has(r))
@@ -412,19 +412,17 @@ function readAssemblyInput(input, caps) {
         origins = { ...(od ? { deny: od } : {}), ...(oa ? { ask: oa } : {}), ...(ol ? { allow: ol } : {}) };
     }
     const gate = allowRulesGate(caps, ownField(input, 'settingsRead', ''));
-    const versionRaw = ownField(input, 'serverVersion', '');
-    const serverVersion = typeof versionRaw === 'string' ? versionRaw : undefined;
-    return { deny, ask, allow, cliDeny, ownedServers, origins, gate, serverVersion };
+    return { deny, ask, allow, cliDeny, ownedServers, origins, gate };
 }
 function judgeAssembly(read, caps, layered) {
-    const { deny, ask, allow, cliDeny, ownedServers, origins, gate, serverVersion } = read;
+    const { deny, ask, allow, cliDeny, ownedServers, origins, gate } = read;
     const cliSlots = slotsOf(cliDeny, 'cliDeny');
-    const cli = cliDeny === undefined ? undefined : { slots: cliSlots, fates: judgeList(cliDeny, 'deny', 'grant', serverVersion) };
+    const cli = cliDeny === undefined ? undefined : { slots: cliSlots, fates: judgeList(cliDeny, 'deny', 'grant') };
     const denySlots = slotsOf(deny, 'deny');
     const askSlots = slotsOf(ask, 'ask');
     const allowSlots = slotsOf(allow, 'allow');
-    const denyJ = judgeBucket(denySlots, 'deny', origins.deny, cli, undefined, 'grant', undefined, [], serverVersion, layered?.deny);
-    const askJ = judgeBucket(askSlots, 'ask', origins.ask, undefined, undefined, 'grant', undefined, [], serverVersion, layered?.ask);
+    const denyJ = judgeBucket(denySlots, 'deny', origins.deny, cli, undefined, 'grant', undefined, [], layered?.deny);
+    const askJ = judgeBucket(askSlots, 'ask', origins.ask, undefined, undefined, 'grant', undefined, [], layered?.ask);
     const allowForm = allowWireForm(caps) === 'layer' ? 'layer' : 'grant';
     const settingsGate = gate === 'settings_read_not_clean' ? 'settings_read_not_clean' : undefined;
     let allowJ = gate === 'capability_off'

package/dist/projectSeed.d.ts

@@ -0,0 +1,39 @@
+import { ATTACHMENT_BOUND_ELSEWHERE, ATTACHMENT_BUNDLE_INVALID, ATTACHMENT_BUNDLE_LANE_NOT_ISOLATED, ATTACHMENT_BUNDLE_SEED_FIXED } from './engineErrorCodes.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+export type ProjectSeedArm = 'handoff' | 'mirror' | 'sidecar';
+export type ProjectSeedGate = {
+    readonly kind: 'ready';
+    readonly attachmentIds: readonly [string];
+} | {
+    readonly kind: 'not_carried';
+} | {
+    readonly kind: 'lane_not_isolated';
+} | {
+    readonly kind: 'lane_unknown';
+} | {
+    readonly kind: 'seed_missing';
+};
+export interface ProjectSeedGateInput {
+    readonly arm: ProjectSeedArm;
+    readonly caps: {} | null | undefined;
+    readonly attachmentId?: string | null;
+}
+export declare function projectSeedGateOf(input: ProjectSeedGateInput): ProjectSeedGate;
+export type ProjectSeedRefusal = {
+    readonly code: typeof ATTACHMENT_BUNDLE_INVALID;
+    readonly reason?: string;
+    readonly path?: string;
+} | {
+    readonly code: typeof ATTACHMENT_BUNDLE_LANE_NOT_ISOLATED;
+    readonly id?: string;
+    readonly lane?: string;
+} | {
+    readonly code: typeof ATTACHMENT_BUNDLE_SEED_FIXED;
+    readonly id?: string;
+} | {
+    readonly code: typeof ATTACHMENT_BOUND_ELSEWHERE;
+    readonly id?: string;
+};
+export declare function projectSeedRefusalOf(err: {} | null | undefined): ProjectSeedRefusal | null;
+export declare function projectSeedRefusalContent(refusal: ProjectSeedRefusal, lang?: UiLanguage): string;
+export declare function projectSeedGateContent(gate: ProjectSeedGate, lang?: UiLanguage): string | undefined;

package/dist/projectSeed.js

@@ -0,0 +1,80 @@
+import { ATTACHMENT_BOUND_ELSEWHERE, ATTACHMENT_BUNDLE_INVALID, ATTACHMENT_BUNDLE_LANE_NOT_ISOLATED, ATTACHMENT_BUNDLE_SEED_FIXED } from './engineErrorCodes.js';
+import { projectExecutionLaneCapability } from './executionLaneCapability.js';
+import { capForDisplay } from './fleetTaskDesc.js';
+import { ownDataField } from './ownKey.js';
+import { isSlotCarrier, readErrorString } from './wireFailureShape.js';
+import { effectiveWireErrorCode } from './wireErrorTriage.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export function projectSeedGateOf(input) {
+    try {
+        if (ownDataField(input, 'arm') !== 'handoff')
+            return Object.freeze({ kind: 'not_carried' });
+        const reading = projectExecutionLaneCapability(ownDataField(input, 'caps'));
+        const isolated = reading?.kind === 'present' ? reading.view.isolated : undefined;
+        if (isolated === false)
+            return Object.freeze({ kind: 'lane_not_isolated' });
+        if (isolated !== true)
+            return Object.freeze({ kind: 'lane_unknown' });
+        const id = ownDataField(input, 'attachmentId');
+        if (typeof id !== 'string' || id.length === 0)
+            return Object.freeze({ kind: 'seed_missing' });
+        return Object.freeze({ kind: 'ready', attachmentIds: Object.freeze([id]) });
+    }
+    catch {
+        return Object.freeze({ kind: 'not_carried' });
+    }
+}
+const nonEmpty = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+export function projectSeedRefusalOf(err) {
+    try {
+        if (!isSlotCarrier(err))
+            return null;
+        const code = effectiveWireErrorCode(err);
+        const o = err;
+        if (code === ATTACHMENT_BUNDLE_INVALID) {
+            const reason = nonEmpty(readErrorString(o, 'reason'));
+            const path = nonEmpty(readErrorString(o, 'path'));
+            return Object.freeze({ code, ...(reason !== undefined ? { reason } : {}), ...(path !== undefined ? { path } : {}) });
+        }
+        if (code === ATTACHMENT_BUNDLE_LANE_NOT_ISOLATED) {
+            const id = nonEmpty(readErrorString(o, 'id'));
+            const lane = nonEmpty(readErrorString(o, 'lane'));
+            return Object.freeze({ code, ...(id !== undefined ? { id } : {}), ...(lane !== undefined ? { lane } : {}) });
+        }
+        if (code === ATTACHMENT_BUNDLE_SEED_FIXED || code === ATTACHMENT_BOUND_ELSEWHERE) {
+            const id = nonEmpty(readErrorString(o, 'id'));
+            return Object.freeze({ code, ...(id !== undefined ? { id } : {}) });
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+const SEED_PATH_DISPLAY_MAX = 200;
+export function projectSeedRefusalContent(refusal, lang) {
+    switch (refusal.code) {
+        case ATTACHMENT_BUNDLE_INVALID: {
+            const sentence = renderMessage(msg('session.projectSeed.invalid'), lang);
+            return refusal.path === undefined ? sentence : renderMessage(msg('session.projectSeed.invalidAt', { sentence, path: capForDisplay(refusal.path, SEED_PATH_DISPLAY_MAX) }), lang);
+        }
+        case ATTACHMENT_BUNDLE_LANE_NOT_ISOLATED:
+            return renderMessage(msg('session.projectSeed.laneNotIsolated'), lang);
+        case ATTACHMENT_BUNDLE_SEED_FIXED:
+            return renderMessage(msg('session.projectSeed.seedFixed'), lang);
+        case ATTACHMENT_BOUND_ELSEWHERE:
+            return renderMessage(msg('session.projectSeed.boundElsewhere'), lang);
+    }
+}
+export function projectSeedGateContent(gate, lang) {
+    switch (gate.kind) {
+        case 'lane_not_isolated':
+            return renderMessage(msg('session.projectSeed.laneNotIsolated'), lang);
+        case 'lane_unknown':
+            return renderMessage(msg('session.projectSeed.laneUnknown'), lang);
+        case 'seed_missing':
+            return renderMessage(msg('session.projectSeed.missing'), lang);
+        default:
+            return undefined;
+    }
+}

package/dist/promptDelivery.js

@@ -149,7 +149,7 @@ function batchTiers(batch) {
     const inFull = new Set(full);
     return { full, partial: partial.filter((u) => !inFull.has(u)) };
 }
-const PRE_RUN_FRAME_TYPES = new Set(['meta', 'approval_request', 'approval_revoke']);
+const PRE_RUN_FRAME_TYPES = new Set(['meta', 'approval_request', 'approval_revoke', 'approval_complete']);
 export function frameProvesDelivery(event) {
     if (typeof event !== 'object' || event === null)
         return false;

package/dist/replayBody.d.ts

@@ -1,14 +1,15 @@
-export interface ReplayRowView {
-    readonly status?: string;
-    readonly errorCode?: string;
-    readonly error?: string;
+export interface RunReceiptView {
+    readonly taskId?: string;
     readonly sessionId?: string;
+    readonly status?: string;
 }
 export interface DoneResultView {
     readonly replay: boolean;
-    readonly engine: unknown;
-    readonly row?: ReplayRowView;
+    readonly receipt: boolean;
+    readonly body: unknown;
 }
+export declare function terminalLayerOf<T>(carrier: T): T | object;
+export declare function runRowSentenceOf<T>(carrier: T): string | undefined;
 export declare function doneResultView(result: unknown): DoneResultView;
 export declare function isReplayedTerminal(frame: object | null | undefined): boolean;
 export declare function isReplayMarked(message: object | null | undefined): boolean;

package/dist/replayBody.js

@@ -11,18 +11,73 @@ function guardedString(o, k) {
     const v = guarded(o, k);
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+function guardedIn(o, k) {
+    try {
+        return k in o;
+    }
+    catch {
+        return undefined;
+    }
+}
+function carriesEngineResult(o) {
+    const stats = guardedIn(o, 'stats');
+    const terminal = guardedIn(o, 'terminal');
+    if (stats === true || terminal === true)
+        return true;
+    return stats === false && terminal === false ? false : undefined;
+}
+function engineResultLayerOf(carrier) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null || Array.isArray(carrier))
+            return undefined;
+        const own = carriesEngineResult(carrier);
+        if (own !== false)
+            return own === true ? carrier : undefined;
+        const nested = guarded(carrier, 'result');
+        if (typeof nested !== 'object' || nested === null || Array.isArray(nested))
+            return undefined;
+        return carriesEngineResult(nested) === true ? nested : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRunReceiptShape(o) {
+    return guardedIn(o, 'activeTaskId') === false && guardedIn(o, 'taskId') === true;
+}
+export function terminalLayerOf(carrier) {
+    return engineResultLayerOf(carrier) ?? carrier;
+}
+export function runRowSentenceOf(carrier) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null || Array.isArray(carrier))
+            return undefined;
+        if (engineResultLayerOf(carrier) !== undefined)
+            return undefined;
+        if (!isRunReceiptShape(carrier))
+            return undefined;
+        return guardedString(carrier, 'error');
+    }
+    catch {
+        return undefined;
+    }
+}
 export function doneResultView(result) {
     if (typeof result !== 'object' || result === null || Array.isArray(result))
-        return { replay: false, engine: result };
-    if (guarded(result, 'replay') !== true)
-        return { replay: false, engine: result };
-    const row = {};
-    for (const k of ['status', 'errorCode', 'error', 'sessionId']) {
+        return { replay: false, receipt: false, body: result };
+    const replay = guarded(result, 'replay') === true;
+    const engine = engineResultLayerOf(result);
+    if (engine !== undefined)
+        return { replay, receipt: false, body: engine };
+    if (!isRunReceiptShape(result))
+        return { replay, receipt: false, body: result };
+    const view = {};
+    for (const k of ['taskId', 'sessionId', 'status']) {
         const v = guardedString(result, k);
         if (v !== undefined)
-            row[k] = v;
+            view[k] = v;
     }
-    return { replay: true, engine: guarded(result, 'result'), row };
+    return { replay, receipt: true, body: Object.freeze(view) };
 }
 export function isReplayedTerminal(frame) {
     if (frame === null || typeof frame !== 'object' || Array.isArray(frame))