@sema-agent/client-core 0.105.0 → 0.107.0

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/noticePresentation.js

@@ -102,6 +102,8 @@ const OCCURRENCE_KEY_BY_CODE = Object.freeze({
     'memory.hold_released': 'reportId',
     'memory.hold_disposed': 'reportId',
     'memory.consolidation_recommended': 'reportId',
+    'memory.harvest_refused': 'reportId',
+    'memory.harvest_conflict': 'reportId',
     'memory.capture_opted_out': 'sessionId',
     'memory.delegation_static_mark_waived': 'runId',
 });

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))

package/dist/request/taskRequest.js

@@ -450,7 +450,7 @@ const resolvedSnapshotForWire = (resolved) => {
 export function hostTurnSettings(input) {
     return buildHostTurnSettings(input, { materialize: (snapshot) => resolvedSnapshotForWire(snapshot), memoryOffDeclared });
 }
-const fileRestoreRequested = (restoreFiles, rewindFilesTo, rewindFiles) => restoreFiles === true || (typeof rewindFilesTo === 'string' && rewindFilesTo.length > 0) || rewindFiles === true;
+const fileRestoreRequested = (restoreFiles, rewindFilesTo) => restoreFiles === true || (typeof rewindFilesTo === 'string' && rewindFilesTo.length > 0);
 function tightenedRequestOf(request, intake, lane) {
     const readData = (key) => {
         try {
@@ -489,10 +489,9 @@ function tightenedRequestOf(request, intake, lane) {
         if (sent.value !== FILE_HISTORY_DISABLED) {
             const restoreFiles = readData('restoreFiles');
             const rewindFilesTo = readData('rewindFilesTo');
-            const rewindFiles = readData('rewindFiles');
-            if (!restoreFiles.ok || !rewindFilesTo.ok || !rewindFiles.ok)
+            if (!restoreFiles.ok || !rewindFilesTo.ok)
                 return unjudged;
-            if (fileRestoreRequested(restoreFiles.value, rewindFilesTo.value, rewindFiles.value))
+            if (fileRestoreRequested(restoreFiles.value, rewindFilesTo.value))
                 return { kind: 'refuse', notice: hostFileHistoryRestoreNotice() };
             add.fileHistory = FILE_HISTORY_DISABLED;
             appendOwnElement(tightened, 'fileHistory');

package/dist/ruleCompileVerdict.d.ts

@@ -25,5 +25,3 @@ export type DenyEntryReading = {
     readonly kind: 'unknown';
 };
 export declare function denyEntryReading(rule: string): DenyEntryReading;
-export declare const DOMAIN_TIGHTEN_HONORED_FROM = "7.135.0";
-export declare function tightenEntryNeverMatches(rule: string, serverVersion: string | undefined): boolean;

package/dist/ruleCompileVerdict.js

@@ -1,6 +1,5 @@
 import { readRuleEntry, validatePermissionRules } from './coreValuePorts.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
-import { engineVersionTier } from './supportFloor.js';
 const RULE_COMPILE_ROOT = '/';
 function issueText(issue, key) {
     try {
@@ -73,33 +72,3 @@ export function denyEntryReading(rule) {
         return { kind: 'unknown' };
     }
 }
-function readsAsDomainSpelling(rule) {
-    try {
-        const reading = readRuleEntry(rule, 'allow');
-        if (typeof reading !== 'object' || reading === null)
-            return false;
-        if (readOwnDataValue(reading, 'kind') !== 'row')
-            return false;
-        const compiled = readOwnDataValue(reading, 'compiled');
-        if (typeof compiled !== 'object' || compiled === null)
-            return false;
-        return readOwnDataValue(compiled, 'kind') === 'domain';
-    }
-    catch {
-        return false;
-    }
-}
-export const DOMAIN_TIGHTEN_HONORED_FROM = '7.135.0';
-function targetLeavesDomainTightenInert(serverVersion) {
-    return engineVersionTier(serverVersion) === 'engine' && engineVersionTier(serverVersion, DOMAIN_TIGHTEN_HONORED_FROM) === 'legacy';
-}
-export function tightenEntryNeverMatches(rule, serverVersion) {
-    if (!targetLeavesDomainTightenInert(serverVersion))
-        return false;
-    const r = denyEntryReading(rule);
-    if (r.kind !== 'inert' || r.reason !== 'content_unsupported')
-        return false;
-    if (!readsAsDomainSpelling(rule))
-        return false;
-    return ruleCompileVerdict(rule, 'deny').kind === 'compiles';
-}

package/dist/ruleRefusalSentence.js

@@ -10,7 +10,6 @@ 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;
@@ -18,8 +17,6 @@ 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;

package/dist/runReattachPolicy.d.ts

@@ -1,5 +1,6 @@
 import { type RunNotFollowed } from './runFollow.js';
 export declare const REATTACH_MAX_TRIES = 5;
+export declare const STREAM_CAP_CREDIBLE_AFTER_MS = 300000;
 export interface ReattachBudget {
     readonly tries: number;
     readonly drainingStreak: number;
@@ -14,6 +15,7 @@ export type ReattachEvent = {
 } | {
     readonly cause: 'stream_cap';
     readonly runId?: string;
+    readonly legElapsedMs?: number;
 } | {
     readonly cause: 'stream_draining';
     readonly runId?: string;
@@ -30,6 +32,7 @@ export type ReattachDrainingEvent = Extract<ReattachEvent, {
 export type ReattachDecision = {
     readonly action: 'reattach';
     readonly afterMs: number;
+    readonly premature?: true;
     readonly budget: ReattachBudget;
 } | {
     readonly action: 'give_up';