@sema-agent/client-core 0.105.0 → 0.106.0

package/dist/coreValuePorts.d.ts

@@ -151,8 +151,17 @@ export interface CoreValuePorts {
     readToolFaces(declared: {} | null | undefined): McpToolFacesReadView;
     ruleNameCovers: (ruleName: string, toolName: string) => boolean;
     IMPORTED_SETTINGS_LAYERS: readonly ['userSettings', 'projectSettings', 'localSettings'];
+    runParkedOf(run: WorkflowRunParkedInputView): boolean;
+    parkedAgentsOf(agents: ReadonlyArray<WorkflowAgentStatusView>): WorkflowAgentStatusView[];
 }
-export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces", "ruleNameCovers", "IMPORTED_SETTINGS_LAYERS"];
+export interface WorkflowAgentStatusView {
+    readonly status: string;
+}
+export interface WorkflowRunParkedInputView {
+    readonly status: string;
+    readonly agents: ReadonlyArray<WorkflowAgentStatusView>;
+}
+export declare const CORE_VALUE_PORT_NAMES: readonly ["resolveAutonomousLoopPrompt", "loosenReasons", "combinePolicies", "createAllowDenyPolicy", "MCP_NAMESPACE", "protocolOf", "ruleToolGrammarOf", "validatePermissionRules", "mintNamespacePrefix", "compileAllowList", "routeKeyOf", "joinRequestUrl", "resolveRouteCredential", "adjudicateModelRoute", "routePairingStatus", "judgeRuleToolName", "readRuleEntry", "readMcpToolAxes", "ANTHROPIC_DEFAULT_BASE_URL", "readToolFaces", "ruleNameCovers", "IMPORTED_SETTINGS_LAYERS", "runParkedOf", "parkedAgentsOf"];
 export type CoreValuePortName = (typeof CORE_VALUE_PORT_NAMES)[number];
 export declare function installCoreValuePorts(ports: Partial<CoreValuePorts> | null): () => void;
 export declare function hasCoreValuePorts(): boolean;
@@ -184,3 +193,5 @@ export declare function anthropicDefaultBaseUrl(): string | undefined;
 export declare function readToolFaces(declared: {} | null | undefined): McpToolFacesReadView | undefined;
 export declare function ruleNameCovers(ruleName: string, toolName: string): boolean | undefined;
 export declare function importedSettingsLayers(): CoreValuePorts['IMPORTED_SETTINGS_LAYERS'] | undefined;
+export declare function runParkedOf(run: WorkflowRunParkedInputView): boolean | undefined;
+export declare function parkedAgentsOf(agents: ReadonlyArray<WorkflowAgentStatusView>): WorkflowAgentStatusView[] | undefined;

package/dist/coreValuePorts.js

@@ -21,6 +21,8 @@ export const CORE_VALUE_PORT_NAMES = Object.freeze([
     'readToolFaces',
     'ruleNameCovers',
     'IMPORTED_SETTINGS_LAYERS',
+    'runParkedOf',
+    'parkedAgentsOf',
 ]);
 let installed = null;
 export function installCoreValuePorts(ports) {
@@ -127,3 +129,11 @@ export function ruleNameCovers(ruleName, toolName) {
 export function importedSettingsLayers() {
     return port('IMPORTED_SETTINGS_LAYERS');
 }
+export function runParkedOf(run) {
+    const fn = port('runParkedOf');
+    return fn === undefined ? undefined : fn(run);
+}
+export function parkedAgentsOf(agents) {
+    const fn = port('parkedAgentsOf');
+    return fn === undefined ? undefined : fn(agents);
+}

package/dist/decideFailureNote.js

@@ -1,6 +1,6 @@
 import { corruptStoredRowContent, corruptStoredRowWhere, scenarioDenyFromError, scenarioNotAllowedContent } from './wireErrorTriage.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
-import { askGoneContent, askGoneFromError, decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
+import { askGoneContent, askGoneFromError, decideParkMovedContent, decideParkMovedFromError, decideRequiresBindingContent, decideRequiresBindingFromError } from './decideReceipt.js';
 import { fieldLimitRefusalContent, fieldLimitRefusalFromError } from './wireRefusalCopy.js';
 import { DECISION_ANSWER_INVALID_CONTENT, decisionConflictOf, decisionGrantChangedContent } from './hitl/decisionConflict.js';
 export function decideFailureNote(err, decision) {
@@ -12,6 +12,7 @@ export function decideFailureNote(err, decision) {
     const scenario = scenarioDenyFromError(err);
     const unsupported = checkpointUnsupportedVersionFromError(err);
     const gone = askGoneFromError(err);
+    const missingBinding = decideRequiresBindingFromError(err);
     const conflict = decisionConflictOf(err);
     const answerInvalid = conflict === 'answer_invalid';
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
@@ -22,6 +23,7 @@ export function decideFailureNote(err, decision) {
         (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`) +
         (unsupported === null ? '' : ` — ${checkpointUnsupportedVersionContent(unsupported)}`) +
         (gone === null ? '' : ` — ${askGoneContent(gone)}`) +
+        (missingBinding === null ? '' : ` — ${decideRequiresBindingContent(missingBinding)}`) +
         (answerInvalid ? ` — ${DECISION_ANSWER_INVALID_CONTENT}` : '') +
         (conflict === 'grant_changed' ? ` — ${decisionGrantChangedContent()}` : ''));
 }

package/dist/decideReceipt.d.ts

@@ -2,6 +2,8 @@ import { type GateOutcomeView } from './gateOutcome.js';
 import { type ResumeReopenDetail } from './hitl/suspendedReopen.js';
 import { type CrashConvergedRowReading } from './hitl/crashConverged.js';
 import type { AskRowEndingCause } from '@sema-agent/sdk';
+import { SDK_DECIDE_BINDING_KEYS } from './generated/sdkFactTables.js';
+import { type UiLanguage } from './env/uiLanguage.js';
 export interface DecideReceiptView {
     status?: string;
     taskId?: string;
@@ -31,6 +33,13 @@ export interface DecideParkMovedDetail {
 }
 export declare function decideParkMovedFromError(e: unknown): DecideParkMovedDetail | null;
 export declare function decideParkMovedContent(detail: Pick<DecideParkMovedDetail, 'code'>): string;
+export type DecideBindingKey = (typeof SDK_DECIDE_BINDING_KEYS)[number];
+export interface DecideRequiresBindingDetail {
+    readonly code: string;
+    readonly missingKeys?: readonly DecideBindingKey[];
+}
+export declare function decideRequiresBindingFromError(e: {} | null | undefined): DecideRequiresBindingDetail | null;
+export declare function decideRequiresBindingContent(_detail?: DecideRequiresBindingDetail, lang?: UiLanguage | (string & {})): string;
 export interface AskGoneDetail {
     code: 'gone.ask';
     state?: 'VOID' | 'DENIED';

package/dist/decideReceipt.js

@@ -1,11 +1,14 @@
 import { gateOutcomeOf } from './gateOutcome.js';
 import { readOwnDataValue } from './ownKey.js';
 import { resumeReopenFromError } from './hitl/suspendedReopen.js';
-import { ASK_GONE, DECIDE_CLAIM_LOST, CONFLICT_NOT_RESUMABLE, GATE_NOT_TOOL_APPROVAL, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
+import { ASK_GONE, DECIDE_CLAIM_LOST, CONFLICT_NOT_RESUMABLE, GATE_NOT_TOOL_APPROVAL, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_REQUIRES_BINDING, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_PARK_FORKED, DECIDE_WORKFLOW_PARKS_UNREADABLE, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { isSlotCarrier, readErrorString, readErrorStrictStringList, readThrownExtra } from './wireFailureShape.js';
 import { isCrashConvergedCause } from './hitl/crashConverged.js';
 import { askRowEndingCauseFor } from './hitl/approvalEndingCause.js';
+import { SDK_DECIDE_BINDING_KEYS } from './generated/sdkFactTables.js';
+import { isUiLanguage } from './env/uiLanguage.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const STATUS_RESUMING = 'resuming';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
@@ -136,6 +139,31 @@ export function decideParkMovedContent(detail) {
     const extra = code === DECIDE_CLAIM_LOST ? '; if this approval is still listed, wait a little before deciding it again' : '';
     return `${what} · This decision was not applied — fetch the pending approvals again and decide from what is pending now${extra}`;
 }
+const isDecideBindingKey = (v) => SDK_DECIDE_BINDING_KEYS.includes(v);
+export function decideRequiresBindingFromError(e) {
+    try {
+        if (effectiveWireErrorCode(e) !== DECIDE_REQUIRES_BINDING)
+            return null;
+        const raw = readErrorStrictStringList(e, 'missingKeys');
+        const keys = [];
+        if (raw !== undefined) {
+            for (const k of raw) {
+                if (!isDecideBindingKey(k) || keys.includes(k)) {
+                    keys.length = 0;
+                    break;
+                }
+                keys.push(k);
+            }
+        }
+        return Object.freeze({ code: DECIDE_REQUIRES_BINDING, ...(keys.length > 0 ? { missingKeys: Object.freeze(keys) } : {}) });
+    }
+    catch {
+        return null;
+    }
+}
+export function decideRequiresBindingContent(_detail, lang) {
+    return renderMessage(msg('approval.decide.requiresBinding'), isUiLanguage(lang) ? lang : undefined);
+}
 function askGoneRawCause(e) {
     let top;
     try {

package/dist/declared/supportFloorDeclared.js

@@ -1,5 +1,5 @@
 export const DECLARED_SUPPORT_FLOOR = Object.freeze({
-    server: "7.129.1",
-    core: "7.51.2",
+    server: "7.139.0",
+    core: "7.60.0",
     sdk: "23.1.0",
 });

package/dist/deviceRebind.d.ts

@@ -95,6 +95,13 @@ export declare function listDevices(devices: DeviceListVerb | null | undefined,
 export declare function readSessionBinding(sessions: SessionExecutionPlacementVerb | null | undefined, rootSessionId: string, opts?: {
     readonly signal?: AbortSignal | undefined;
 }): Promise<DeviceSessionBindingOutcome>;
+export interface SessionPlacementView {
+    readonly sessionId: string;
+    readonly executionLane?: string;
+    readonly onDevice: boolean;
+    readonly rev?: number;
+}
+export declare function foldSessionPlacement(held: SessionPlacementView | undefined, sessionId: string, body: {} | null | undefined): SessionPlacementView | undefined;
 export declare function rebindSession(devices: DeviceRebindVerb | null | undefined, req: DeviceRebindInput, opts?: {
     readonly signal?: AbortSignal | undefined;
 }): Promise<DeviceRebindOutcome>;

package/dist/deviceRebind.js

@@ -140,6 +140,17 @@ function placementReadFailureOf(e) {
     return v.status !== undefined ? refusedOf(v.status, v.code, e) : transportOf(v);
 }
 const isPlacementRole = (v) => typeof v === 'string' && EXECUTION_PLACEMENT_ROLES.includes(v);
+function placementBodyOf(body) {
+    const role = own(body, 'role');
+    if (!isPlacementRole(role))
+        return { role: undefined, lane: undefined, device: null };
+    if (role !== 'writer')
+        return { role, lane: undefined, device: null };
+    const lane = own(body, 'lane');
+    if (typeof lane !== 'string' || lane === '')
+        return { role, lane: undefined, device: null };
+    return { role, lane, device: lane === EXECUTION_PLACEMENT_DEVICE_LANE ? bindingOf(own(body, 'device')) : null };
+}
 export async function readSessionBinding(sessions, rootSessionId, opts) {
     if (typeof rootSessionId !== 'string' || rootSessionId === '') {
         return { kind: 'refused', status: 0, errorCode: 'request.id_invalid', message: 'the session id to read the execution placement of must be a non-empty string — nothing was sent' };
@@ -154,24 +165,47 @@ export async function readSessionBinding(sessions, rootSessionId, opts) {
     catch (e) {
         return placementReadFailureOf(e);
     }
-    const role = own(body, 'role');
-    if (!isPlacementRole(role)) {
+    const { role, lane, device: bound } = placementBodyOf(body);
+    if (role === undefined) {
         return { kind: 'unreadable', why: 'the execution placement it returned names no role this client knows (absent / writer / mirror / forking) — refusing to read it as "not bound"' };
     }
     if (role !== 'writer')
         return { kind: 'unbound', role };
-    const lane = own(body, 'lane');
-    if (typeof lane !== 'string' || lane === '') {
+    if (lane === undefined) {
         return { kind: 'unreadable', why: "the writer's execution lane in the execution placement is missing or not a word — refusing to guess whether a device is bound" };
     }
     if (lane !== EXECUTION_PLACEMENT_DEVICE_LANE)
         return { kind: 'unbound', role };
-    const bound = bindingOf(own(body, 'device'));
     if (bound === null) {
         return { kind: 'unreadable', why: 'the session is written on the device lane but the execution placement names no readable device (deviceId + rev) — the device is unknown, not unbound' };
     }
     return { kind: 'ok', rootSessionId, boundDevice: bound };
 }
+export function foldSessionPlacement(held, sessionId, body) {
+    try {
+        if (typeof sessionId !== 'string' || sessionId === '')
+            return held;
+        const heldOk = held !== null && typeof held === 'object';
+        if (heldOk && own(held, 'sessionId') !== sessionId)
+            return held;
+        const { role, lane, device } = placementBodyOf(body);
+        if (role === undefined)
+            return held;
+        const heldRev = heldOk ? nonNegInt(own(held, 'rev')) : undefined;
+        const rev = device?.rev;
+        if (heldRev !== undefined && (rev === undefined || rev < heldRev))
+            return held;
+        return Object.freeze({
+            sessionId,
+            ...(lane !== undefined ? { executionLane: lane } : {}),
+            onDevice: device !== null,
+            ...(rev !== undefined ? { rev } : {}),
+        });
+    }
+    catch {
+        return held;
+    }
+}
 function rebindFailureOf(e) {
     const v = atMostOnceVerdictOf(e);
     const { status, code } = v;

package/dist/engineAddress.d.ts

@@ -0,0 +1,3 @@
+export declare function tupleOriginUrlOf(raw: string): URL | undefined;
+export declare function carriesNoCredentialSlots(u: URL): boolean;
+export declare function isCenterRelativePath(path: string): boolean;

package/dist/engineAddress.js

@@ -0,0 +1,25 @@
+export function tupleOriginUrlOf(raw) {
+    try {
+        const u = new URL(raw);
+        return /^(?:https?|wss?|ftp):$/.test(u.protocol) ? u : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function carriesNoCredentialSlots(u) {
+    return u.username === '' && u.password === '' && u.search === '' && u.hash === '';
+}
+export function isCenterRelativePath(path) {
+    if (path.length === 0 || path.charCodeAt(0) !== 0x2f)
+        return false;
+    const second = path.charCodeAt(1);
+    if (second === 0x2f || second === 0x5c)
+        return false;
+    if (/[\s\u0000-\u001f\u007f-\u009f\\?#]/u.test(path))
+        return false;
+    return path.split('/').every((segment) => {
+        const decoded = segment.replace(/%2e/gi, '.');
+        return decoded !== '.' && decoded !== '..';
+    });
+}

package/dist/engineDirectory.js

@@ -1,21 +1,9 @@
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { isCenterRelativePath } from './engineAddress.js';
 const KIND_WORDS = ['managed'];
 const POSTURE_WORDS = ['single', 'multi'];
 const RULE_WORDS = ['only-one', 'none', 'ambiguous'];
 const UNREADABLE = Object.freeze({ kind: 'unreadable' });
-function isCenterRelativePath(path) {
-    if (path.length === 0 || path.charCodeAt(0) !== 0x2f)
-        return false;
-    const second = path.charCodeAt(1);
-    if (second === 0x2f || second === 0x5c)
-        return false;
-    if (/[\s\u0000-\u001f\u007f-\u009f\\?#]/u.test(path))
-        return false;
-    return path.split('/').every((segment) => {
-        const decoded = segment.replace(/%2e/gi, '.');
-        return decoded !== '.' && decoded !== '..';
-    });
-}
 function isObj(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
@@ -123,6 +111,9 @@ export function projectMeEngine(body) {
         return undefined;
     }
 }
+function sameNameCount(set, name) {
+    return set.rows.filter((row) => row.name === name).length + set.unreadableNames.filter((n) => n === name).length;
+}
 export function decideMeEngine(reading) {
     try {
         if (reading === undefined)
@@ -139,7 +130,9 @@ export function decideMeEngine(reading) {
             if (candidates === undefined)
                 return unresolved('candidates');
             const picked = target.row;
-            if (!candidates.rows.some((row) => row.name === picked.name && row.viaCenter === picked.viaCenter))
+            if (!candidates.rows.some((row) => row.name === picked.name && row.viaCenter === picked.viaCenter && row.scope === picked.scope))
+                return unresolved('conflict');
+            if (sameNameCount(candidates, picked.name) > 1)
                 return unresolved('conflict');
             if (rule.kind === 'listed' && (candidates.rows.length !== 1 || candidates.unreadableRows !== 0))
                 return unresolved('conflict');
@@ -171,12 +164,11 @@ export function engineOverrideOf(set, requested) {
         if (set === undefined)
             return { kind: 'unreadable' };
         const hits = set.rows.filter((row) => row.name === requested);
-        const hidden = set.unreadableNames.filter((name) => name === requested).length;
-        if (hits.length + hidden > 1)
+        if (sameNameCount(set, requested) > 1)
             return { kind: 'duplicate', name: requested };
         if (hits.length === 1)
             return { kind: 'select', engine: hits[0] };
-        if (hidden === 1)
+        if (set.unreadableNames.some((name) => name === requested))
             return { kind: 'row-unreadable', name: requested };
         return { kind: 'not-listed', candidates: set };
     }

package/dist/engineErrorCodes.d.ts

@@ -8,6 +8,7 @@ export declare const LIMITS_MAX_WALLTIME_EXCEEDED = "limits.max_walltime_exceede
 export declare function isLimitsExceededCode(code: string | undefined): boolean;
 export declare const USAGE_WINDOW_EXHAUSTED = "usage.window_exhausted";
 export declare const ENV_LIFETIME_EXPIRED = "env.lifetime_expired";
+export declare const ENV_HOME_UNCONFIRMED = "env.home_unconfirmed";
 export declare const FLEET_LEASE_UNAVAILABLE = "fleet.lease_unavailable";
 export declare const CONFIG_LIMIT_INVALID = "config.limit_invalid";
 export declare const CONFIG_LIMIT_UNKNOWN_KEY = "config.limit_unknown_key";
@@ -42,6 +43,12 @@ export declare const CAPABILITY_IMAGE_INDEX_REQUIRED = "capability.image_index_r
 export declare const CAPABILITY_K8S_LANE_REQUIRED = "capability.k8s_lane_required";
 export declare const NOT_FOUND_IMAGE = "not_found.image";
 export declare const REQUEST_PRECONDITION_UNMET = "request.precondition_unmet";
+export declare const ATTACHMENT_BUNDLE_INVALID = "attachment.bundle_invalid";
+export declare const ATTACHMENT_BUNDLE_LANE_NOT_ISOLATED = "attachment.bundle_lane_not_isolated";
+export declare const ATTACHMENT_BUNDLE_SEED_FIXED = "attachment.bundle_seed_fixed";
+export declare const ATTACHMENT_BOUND_ELSEWHERE = "attachment.bound_elsewhere";
+export declare const CONFLICT_SESSION_MEMORY_UNOBSERVED = "conflict.session_memory_unobserved";
+export declare const CONFLICT_SESSION_ARCHIVE_STAMPED = "conflict.session_archive_stamped";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
 export declare const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = "conflict.idempotency_payload_mismatch";
@@ -114,6 +121,7 @@ export declare function isDecideParkMovedCode(code: string | null | undefined):
 export declare const DECIDE_ROW_UNREVIVABLE = "decide.row_unrevivable";
 export declare function isDecideRowUnrevivableCode(code: string | null | undefined): boolean;
 export declare const APPROVAL_STALE = "approval_stale";
+export declare const DECIDE_REQUIRES_BINDING = "decide_requires_binding";
 export declare const APPROVAL_BINDING_MISMATCH = "approval_binding_mismatch";
 export declare const CHECKPOINT_INVALID_OUTCOME = "checkpoint.invalid_outcome";
 export declare const RESUME_OUTCOME_INVALID = "resume_outcome_invalid";

package/dist/engineErrorCodes.js

@@ -11,6 +11,7 @@ export function isLimitsExceededCode(code) {
 }
 export const USAGE_WINDOW_EXHAUSTED = 'usage.window_exhausted';
 export const ENV_LIFETIME_EXPIRED = 'env.lifetime_expired';
+export const ENV_HOME_UNCONFIRMED = 'env.home_unconfirmed';
 export const FLEET_LEASE_UNAVAILABLE = 'fleet.lease_unavailable';
 export const CONFIG_LIMIT_INVALID = 'config.limit_invalid';
 export const CONFIG_LIMIT_UNKNOWN_KEY = 'config.limit_unknown_key';
@@ -66,6 +67,12 @@ export const CAPABILITY_IMAGE_INDEX_REQUIRED = 'capability.image_index_required'
 export const CAPABILITY_K8S_LANE_REQUIRED = 'capability.k8s_lane_required';
 export const NOT_FOUND_IMAGE = 'not_found.image';
 export const REQUEST_PRECONDITION_UNMET = 'request.precondition_unmet';
+export const ATTACHMENT_BUNDLE_INVALID = 'attachment.bundle_invalid';
+export const ATTACHMENT_BUNDLE_LANE_NOT_ISOLATED = 'attachment.bundle_lane_not_isolated';
+export const ATTACHMENT_BUNDLE_SEED_FIXED = 'attachment.bundle_seed_fixed';
+export const ATTACHMENT_BOUND_ELSEWHERE = 'attachment.bound_elsewhere';
+export const CONFLICT_SESSION_MEMORY_UNOBSERVED = 'conflict.session_memory_unobserved';
+export const CONFLICT_SESSION_ARCHIVE_STAMPED = 'conflict.session_archive_stamped';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
 export const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = 'conflict.idempotency_payload_mismatch';
@@ -214,6 +221,7 @@ export function isDecideRowUnrevivableCode(code) {
     return typeof code === 'string' && code === DECIDE_ROW_UNREVIVABLE;
 }
 export const APPROVAL_STALE = 'approval_stale';
+export const DECIDE_REQUIRES_BINDING = 'decide_requires_binding';
 export const APPROVAL_BINDING_MISMATCH = 'approval_binding_mismatch';
 export const CHECKPOINT_INVALID_OUTCOME = 'checkpoint.invalid_outcome';
 export const RESUME_OUTCOME_INVALID = 'resume_outcome_invalid';

package/dist/engineNoticeCodes.d.ts

@@ -223,12 +223,14 @@ export interface StreamEndIgnoredFactsView {
     runId: string;
 }
 export declare function readStreamEndIgnored(notice: unknown): StreamEndIgnoredFactsView | undefined;
-export interface ContextImageRemovedFactsView {
+export interface ContextMediaRemovedFactsView {
+    reason: string;
     images: number;
+    documents: number;
     sessionId: string;
     runId: string;
 }
-export declare function readContextImageRemoved(notice: {} | null | undefined): ContextImageRemovedFactsView | undefined;
+export declare function readContextMediaRemoved(notice: {} | null | undefined): ContextMediaRemovedFactsView | undefined;
 export interface McpAuthorizationRequiredFactsView {
     server: string;
     reason: string;
@@ -237,6 +239,26 @@ export interface McpAuthorizationRequiredFactsView {
     runId: string;
 }
 export declare function readMcpAuthorizationRequired(notice: {} | null | undefined): McpAuthorizationRequiredFactsView | undefined;
+interface SessionLineageRerootedCommon {
+    recordsDropped: NoticeCountReading;
+    recordsTotal: NoticeCountReading;
+    entriesOnPath: NoticeCountReading;
+    sessionId: string;
+    runId: string;
+}
+interface SessionLineageRerootedWhole extends SessionLineageRerootedCommon {
+    break: false;
+    leaf: string | null;
+}
+interface SessionLineageRerootedBroken extends SessionLineageRerootedCommon {
+    break: true;
+    leaf: string;
+    missingParentId: string;
+    rootedAt: string;
+    entriesCut: NoticeCountReading;
+}
+export type SessionLineageRerootedFactsView = SessionLineageRerootedWhole | SessionLineageRerootedBroken;
+export declare function readSessionLineageRerooted(notice: {} | null | undefined): SessionLineageRerootedFactsView | undefined;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -261,8 +283,9 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'task.turn_interrupted': typeof readTurnInterrupted;
     readonly 'route.finish_reason_unknown': typeof readFinishReasonUnknown;
     readonly 'route.stream_end_ignored': typeof readStreamEndIgnored;
-    readonly 'context.image_removed': typeof readContextImageRemoved;
     readonly 'mcp.authorization_required': typeof readMcpAuthorizationRequired;
+    readonly 'context.media_removed': typeof readContextMediaRemoved;
+    readonly 'session.lineage_rerooted': typeof readSessionLineageRerooted;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;

package/dist/engineNoticeCodes.js

@@ -897,25 +897,28 @@ function readStreamEndIgnoredOf(notice) {
         return undefined;
     return { statement, word, frames, sessionId, runId };
 }
-export function readContextImageRemoved(notice) {
-    return guardedRead(notice, readContextImageRemovedOf);
+export function readContextMediaRemoved(notice) {
+    return guardedRead(notice, readContextMediaRemovedOf);
 }
-function readContextImageRemovedOf(notice) {
+function readContextMediaRemovedOf(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
         return undefined;
     const n = notice;
-    if (ownSeat(n, 'code') !== 'context.image_removed')
+    if (ownSeat(n, 'code') !== 'context.media_removed')
         return undefined;
     const d = ownSeat(n, 'detail');
     if (typeof d !== 'object' || d === null || Array.isArray(d))
         return undefined;
     const o = d;
+    const reason = nonEmpty(ownSeat(o, 'reason'));
     const images = ownSeat(o, 'images');
+    const documents = ownSeat(o, 'documents');
     const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
     const runId = nonEmpty(ownSeat(o, 'runId'));
-    if (typeof images !== 'number' || !Number.isSafeInteger(images) || images < 1 || sessionId === undefined || runId === undefined)
+    const count = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+    if (reason === undefined || !count(images) || !count(documents) || images + documents < 1 || sessionId === undefined || runId === undefined)
         return undefined;
-    return { images, sessionId, runId };
+    return { reason, images, documents, sessionId, runId };
 }
 export function readMcpAuthorizationRequired(notice) {
     return guardedRead(notice, readMcpAuthorizationRequiredOf);
@@ -939,6 +942,47 @@ function readMcpAuthorizationRequiredOf(notice) {
     const authorizeUrl = nonEmpty(optionalOwnSeat(o, 'authorizeUrl'));
     return { server, reason, ...(authorizeUrl !== undefined ? { authorizeUrl } : {}), sessionId, runId };
 }
+export function readSessionLineageRerooted(notice) {
+    return guardedRead(notice, readSessionLineageRerootedOf);
+}
+function readSessionLineageRerootedOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (ownSeat(n, 'code') !== 'session.lineage_rerooted')
+        return undefined;
+    const d = ownSeat(n, 'detail');
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const brk = ownSeat(o, 'break');
+    if (brk !== true && brk !== false)
+        return undefined;
+    const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
+    const runId = nonEmpty(ownSeat(o, 'runId'));
+    if (sessionId === undefined || runId === undefined)
+        return undefined;
+    const leafRaw = ownSeat(o, 'leaf');
+    const common = {
+        recordsDropped: countReading(optionalOwnSeat(o, 'recordsDropped')),
+        recordsTotal: countReading(optionalOwnSeat(o, 'recordsTotal')),
+        entriesOnPath: countReading(optionalOwnSeat(o, 'entriesOnPath')),
+        sessionId,
+        runId,
+    };
+    if (brk === false) {
+        const leaf = leafRaw === null ? null : nonEmpty(leafRaw);
+        if (leaf === undefined)
+            return undefined;
+        return { break: false, leaf, ...common };
+    }
+    const leaf = nonEmpty(leafRaw);
+    const missingParentId = nonEmpty(ownSeat(o, 'missingParentId'));
+    const rootedAt = nonEmpty(ownSeat(o, 'rootedAt'));
+    if (leaf === undefined || missingParentId === undefined || rootedAt === undefined)
+        return undefined;
+    return { break: true, leaf, missingParentId, rootedAt, entriesCut: countReading(optionalOwnSeat(o, 'entriesCut')), ...common };
+}
 export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'mcp.injection_dropped': readMcpInjectionDrop,
     'delegation.ask_unresolvable': readAskUnresolvable,
@@ -963,8 +1007,9 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'task.turn_interrupted': readTurnInterrupted,
     'route.finish_reason_unknown': readFinishReasonUnknown,
     'route.stream_end_ignored': readStreamEndIgnored,
-    'context.image_removed': readContextImageRemoved,
     'mcp.authorization_required': readMcpAuthorizationRequired,
+    'context.media_removed': readContextMediaRemoved,
+    'session.lineage_rerooted': readSessionLineageRerooted,
 });
 const _factReaderTablePin = true;
 void _factReaderTablePin;

package/dist/engineRowRef.js

@@ -74,7 +74,7 @@ export function mintEngineRowRef(eventId, bound) {
 export function terminalRunIdOf(ev) {
     if (ev.type !== 'done')
         return undefined;
-    const v = (doneResultView(ev.result).engine ?? ev.result)?.runId;
+    const v = doneResultView(ev.result).body?.runId;
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
 export const TRANSCRIPT_ROW_SIDECAR_KEYS = Object.freeze([

package/dist/errorSupplementRoles.js

@@ -4,6 +4,7 @@ import { resumeRefusalContent, resumeContextUnavailableContent, requireExistingS
 import { resumeReopenContent } from './hitl/suspendedReopen.js';
 import { idempotencyPayloadMismatchContent } from './engineErrorCodes.js';
 import { inheritEnvRefusalContent } from './inheritEnvWire.js';
+import { projectSeedRefusalContent } from './projectSeed.js';
 import { usageWindowExhaustedContent, fleetLeaseUnavailableContent, settingsPermissionBucketRefusalContent, fieldLimitRefusalContent, autonomyLaneRefusalContent, unsupportedRuleRefusalContent, admissionWallRefusalContent, hostPostureRefusalContent, toolDeclarationRefusalContent, } from './wireRefusalCopy.js';
 const ROLE_BY_READER = new Map([
     [corruptSessionContent, 'replacement'],
@@ -20,6 +21,7 @@ const ROLE_BY_READER = new Map([
     [autonomyLaneRefusalContent, 'replacement'],
     [idempotencyPayloadMismatchContent, 'replacement'],
     [unsupportedRuleRefusalContent, 'replacement'],
+    [projectSeedRefusalContent, 'replacement'],
     [admissionWallRefusalContent, 'supplement'],
     [hostPostureRefusalContent, 'supplement'],
     [toolDeclarationRefusalContent, 'supplement'],

package/dist/eventLeg.d.ts

@@ -2,7 +2,7 @@ import type { AgentEvent } from '@sema-agent/sdk';
 import type { EngineBoundRun } from './engineRowRef.js';
 import { type AskGateWireDeps } from './hitl/askGateWire.js';
 import { type ActiveRunBusySignal } from './adapter/runStream.js';
-import type { ApprovalRequestChromeEvent, ApprovalRevokeChromeEvent } from './seam.js';
+import type { ApprovalCompleteChromeEvent, ApprovalRequestChromeEvent, ApprovalRevokeChromeEvent } from './seam.js';
 export declare const EVENT_LEG_KINDS: readonly ["live", "durable", "continuation"];
 export type EventLegKind = (typeof EVENT_LEG_KINDS)[number];
 export type EventLegStage = 'bindRun' | 'stampOwner' | 'hitlFrames' | 'askBridge' | 'idleTriage';
@@ -71,7 +71,7 @@ export interface ApprovalFrameContext {
     readonly receivedAtMs: number;
     readonly streamEnded: AbortSignal;
 }
-export declare function approvalFrameContextOf(arm: ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent): ApprovalFrameContext | undefined;
+export declare function approvalFrameContextOf(arm: ApprovalRequestChromeEvent | ApprovalCompleteChromeEvent | ApprovalRevokeChromeEvent): ApprovalFrameContext | undefined;
 export interface EventLegPorts {
     readonly run?: EventLegRunPorts;
     readonly owner?: EventLegOwnerPorts;

package/dist/eventLeg.js

@@ -3,6 +3,7 @@ import { bridgeAskUserQuestionGates } from './hitl/askGateWire.js';
 import { diagnoseSseIdleTear } from './sseIdleTriage.js';
 import { recordSubagentOwnerFromProgress } from './subagentContentStore.js';
 import { activeRunBusySignal } from './adapter/runStream.js';
+import { frameProvesDelivery } from './promptDelivery.js';
 import { faultText, invokeHostCallbackIsolated } from './hostCallbackGuard.js';
 import { hostLog } from './host.js';
 import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
@@ -180,7 +181,7 @@ export function composeEventLeg(source, leg, ports) {
                 if (taskId === undefined && streamKind === 'live')
                     taskId = readHeaderRunId();
                 const refusal = streamKind === 'live' && !runEvidence && inDomain('bindRun', ev.type) ? refusalOf(ev, taskId) : undefined;
-                if (!inDomain('bindRun', ev.type))
+                if (frameProvesDelivery(ev))
                     runEvidence = true;
                 if (refusal !== undefined) {
                     if (runPorts !== undefined && typeof runPorts.onRefused === 'function' && isCurrentNow())