@sema-agent/client-core 0.84.0 → 0.84.1

package/dist/hitl/sessionPolicyWire.js

@@ -1,5 +1,6 @@
 import { wireFailureShapeOf } from '../wireFailureShape.js';
 import { hostLog } from '../host.js';
+import { isEngineRefusedToolName } from './sessionPolicyDeliverable.js';
 const RULE_FIELD_PRESENCE = {
     toolAllow: true,
     toolDeny: true,
@@ -306,3 +307,212 @@ export function sessionPolicyTightenNotice(outcome) {
             }
     }
 }
+function rosterMountedNames(roster) {
+    if (roster === undefined || roster === null)
+        return 'absent';
+    try {
+        if (typeof roster !== 'object' || Array.isArray(roster))
+            return 'unreadable';
+        const entries = roster.entries;
+        if (!Array.isArray(entries))
+            return 'unreadable';
+        const names = new Set();
+        const n = entries.length;
+        for (let i = 0; i < n; i++) {
+            if (!Object.hasOwn(entries, i))
+                return 'unreadable';
+            const row = entries[i];
+            if (typeof row !== 'object' || row === null)
+                return 'unreadable';
+            const name = row.name;
+            if (typeof name !== 'string' || name.length === 0)
+                return 'unreadable';
+            names.add(name);
+            const aliases = row.aliases;
+            if (aliases === undefined)
+                continue;
+            if (!Array.isArray(aliases))
+                return 'unreadable';
+            for (const a of aliases) {
+                if (typeof a !== 'string')
+                    return 'unreadable';
+                names.add(a);
+            }
+        }
+        return names;
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+function withoutRefusedEntries(prior, mounted) {
+    const REFUSABLE_NAME_FIELDS = ['toolDeny', 'toolAllow'];
+    const isRefusable = (f) => REFUSABLE_NAME_FIELDS.includes(f);
+    const next = {};
+    const removed = [];
+    for (const field of SESSION_POLICY_RULE_FIELDS) {
+        const list = Object.hasOwn(prior, field) ? prior[field] : undefined;
+        if (list === undefined)
+            continue;
+        if (!isRefusable(field)) {
+            next[field] = [...list];
+            continue;
+        }
+        const kept = [];
+        const seen = new Set();
+        for (const x of list) {
+            if (!isEngineRefusedToolName(x) || mounted.has(x)) {
+                kept.push(x);
+                continue;
+            }
+            if (seen.has(x))
+                continue;
+            seen.add(x);
+            removed.push({ field, rule: x });
+        }
+        next[field] = kept;
+    }
+    return { next, removed };
+}
+function removalFailed(failure, leg) {
+    const u = unknownFrom(failure, leg);
+    const message = u.message;
+    switch (u.why) {
+        case 'write_indeterminate':
+            return { kind: 'write_unconfirmed', why: 'write_indeterminate', ...(message !== undefined ? { message } : {}) };
+        case 'read_failed':
+        case 'read_unreadable':
+            return { kind: 'read_failed', why: u.why, ...(message !== undefined ? { message } : {}) };
+        case 'write_refused':
+            return { kind: 'write_refused', why: 'write_refused', ...(message !== undefined ? { message } : {}) };
+        case 'face_unavailable':
+        case 'session_not_found':
+        case 'session_ownerless':
+        case 'unauthorized':
+        case 'request_rejected':
+        case 'store_corrupt':
+            return leg === 'read'
+                ? { kind: 'read_failed', why: u.why, ...(message !== undefined ? { message } : {}) }
+                : { kind: 'write_refused', why: u.why, ...(message !== undefined ? { message } : {}) };
+        default:
+            return leg === 'read'
+                ? { kind: 'read_failed', why: 'read_failed', ...(message !== undefined ? { message } : {}) }
+                : { kind: 'write_unconfirmed', why: 'write_indeterminate', ...(message !== undefined ? { message } : {}) };
+    }
+}
+async function attemptRemoval(facade, sessionId, mounted, opts) {
+    const read = await readSessionPolicy(facade, sessionId, opts);
+    if (read.kind === 'failed')
+        return { done: removalFailed(read.failure, 'read') };
+    if (read.kind === 'malformed')
+        return { done: { kind: 'read_failed', why: 'read_unreadable', message: read.detail } };
+    const { next, removed } = withoutRefusedEntries(read.rules, mounted);
+    if (removed.length === 0)
+        return { done: { kind: 'nothing_to_remove', rev: read.rev } };
+    let receipt;
+    try {
+        receipt = await facade.putPolicy(sessionId, { rules: next, expectedRev: read.rev }, opts);
+    }
+    catch (e) {
+        const failure = classifySessionPolicyFailure(e);
+        if (failure.kind === 'loosen-forbidden')
+            return { done: { kind: 'loosen_forbidden', message: failure.message, refused: removed } };
+        if (failure.kind === 'cas-conflict')
+            return { retryAtRev: read.rev };
+        return { done: removalFailed(failure, 'write') };
+    }
+    let narrowed;
+    try {
+        narrowed = narrowStoredRecord(receipt);
+    }
+    catch {
+        narrowed = { ok: false, why: 'envelope', detail: 'policy write receipt could not be read' };
+    }
+    if (!narrowed.ok)
+        return { done: { kind: 'write_unconfirmed', why: 'write_receipt_unreadable', message: narrowed.detail } };
+    const mismatch = receiptMismatch(next, narrowed.rules, read.rev, narrowed.rev) ??
+        (removed.some((e) => {
+            const r = Object.hasOwn(narrowed.rules, e.field) ? narrowed.rules[e.field] : undefined;
+            return r !== undefined && r.includes(e.rule);
+        })
+            ? 'the write receipt still holds an entry that was sent for removal'
+            : null);
+    if (mismatch !== null)
+        return { done: { kind: 'write_unconfirmed', why: 'write_receipt_mismatch', message: mismatch } };
+    return { done: { kind: 'removed', rev: narrowed.rev, removed } };
+}
+export async function removeRefusedSessionRules(facade, sessionId, roster, opts) {
+    const mounted = rosterMountedNames(roster);
+    if (typeof mounted === 'string')
+        return { kind: 'roster_required', why: mounted };
+    const first = await attemptRemoval(facade, sessionId, mounted, opts);
+    if ('done' in first)
+        return first.done;
+    hostLog('debug', 'sessionPolicyWire: the session rule record moved between this read and this removal — re-reading once and judging the other writer’s record again');
+    const second = await attemptRemoval(facade, sessionId, mounted, opts);
+    if ('done' in second)
+        return second.done;
+    return { kind: 'conflict', rev: second.retryAtRev };
+}
+export function sessionPolicyRemovalNotice(outcome) {
+    const generic = 'The session’s rule record may not have changed — re-read it before doing anything else.';
+    if (outcome === null || typeof outcome !== 'object')
+        return generic;
+    switch (outcome.kind) {
+        case 'roster_required':
+            return outcome.why === 'unreadable'
+                ? 'The tool roster supplied for this removal could not be read, so nothing was changed: without it an entry that looks refused may name a tool this deployment mounts itself, and removing it would lift a restriction that is in effect. Supply the tool roster exactly as read from a run’s assembly manifest and try again.'
+                : 'No tool roster was supplied for this removal, so nothing was changed: without it an entry that looks refused may name a tool this deployment mounts itself, and removing it would lift a restriction that is in effect. Supply the tool roster from a run of this session on this deployment (a run that fails at startup reports none) and try again.';
+        case 'removed': {
+            const list = Array.isArray(outcome.removed) ? outcome.removed : [];
+            const n = list.length;
+            const what = n === 1 ? '1 entry' : `${n} entries`;
+            const fields = new Set(list.map((e) => (typeof e === 'object' && e !== null ? e.field : undefined)));
+            const deny = fields.has('toolDeny')
+                ? ' Removing names from the deny list lifts no block on any tool mounted for this session’s runs; to block such a tool under its current name, add a new deny rule with that name.'
+                : '';
+            const allow = fields.has('toolAllow')
+                ? ' Removing names from the allow list allows nothing new: the tools those names were meant to allow stay outside it, and an allow list left empty allows no tool at all; to allow such a tool under its current name, add its current name to the allow list.'
+                : '';
+            return `Removed ${what} from this session’s rule record (now at version ${outcome.rev}): ${n === 1 ? 'it names' : 'each names'} a tool the engine refuses, and no tool in the supplied roster answers to ${n === 1 ? 'it' : 'those names'}; this record no longer stops the session’s runs from starting.${deny}${allow}`;
+        }
+        case 'nothing_to_remove':
+            return 'This session’s rule record holds no entry naming a tool the engine refuses that the supplied roster does not mount, so nothing was changed. If runs still fail at startup over a refused tool name, that entry is set somewhere this record does not cover — the settings sent with the run, a parent session’s rule record, or the deployment’s own tool rules — or it is a name the engine refuses that this version does not yet recognise, or the failing run does not mount a tool the supplied roster has under that name.';
+        case 'loosen_forbidden':
+            return 'The engine refused to take these entries out of this session’s rule record: on this engine only an operator can remove entries from it, so the record is unchanged. Ask an operator to remove them, or continue in a new session.';
+        case 'conflict':
+            return 'This session’s rule record was changed by someone else while the refused entries were being removed, twice in a row — nothing was changed. Try again once the other change has finished.';
+        case 'read_failed':
+            switch (outcome.why) {
+                case 'face_unavailable':
+                    return 'This deployment does not keep per-session tool rules, so there is no session rule record to remove entries from — nothing was changed.';
+                case 'session_not_found':
+                    return 'This session is not readable from here — it may not exist, or it may belong to someone else; nothing was changed.';
+                case 'session_ownerless':
+                    return 'This session has no owner, so it has no session rule record to change; nothing was changed.';
+                case 'unauthorized':
+                    return 'This call could not present a verifiable identity, so nothing was changed.';
+                case 'store_corrupt':
+                    return 'The engine could not establish which version this session’s rules are at, so nothing was changed. This needs an operator to look at the rule store.';
+                case 'read_unreadable':
+                    return 'The session’s current rules could not be read, so nothing was changed — rewriting a record that cannot be read could replace real restrictions.';
+                default:
+                    return 'The session’s current rules could not be fetched, so nothing was changed.';
+            }
+        case 'write_refused':
+            switch (outcome.why) {
+                case 'store_corrupt':
+                    return 'The engine could not establish which version this session’s rules are at and refused to stamp a new one, so nothing was changed. This needs an operator to look at the rule store.';
+                case 'session_not_found':
+                    return 'This session is not writable from here — it may not exist, or it may belong to someone else; nothing was changed.';
+                case 'unauthorized':
+                    return 'This call could not present a verifiable identity, so nothing was changed.';
+                default:
+                    return 'The engine refused this change, so nothing was changed. Re-read the session’s rules before trying again.';
+            }
+        case 'write_unconfirmed':
+            return 'The removal was sent but no clear answer came back from the engine — it may already be in effect. Run the removal again: it re-reads the record, and reports nothing left to remove if it did take effect.';
+        default:
+            return generic;
+    }
+}

package/dist/hitl/toolApprovalWire.js

@@ -282,7 +282,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                         kind: 'failed',
                         stage: 'decide',
                         gatedCallId,
-                        reason: `decide(approve) failed: ${String(e)}${decideFailureNote(e)}`,
+                        reason: `decide(approve) failed: ${String(e)}${decideFailureNote(e, 'approve')}`,
                         ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
                         ...(currentPending !== undefined ? { currentPending } : {}),
                         ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
@@ -339,7 +339,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                         kind: 'failed',
                         stage: 'decide',
                         gatedCallId,
-                        reason: `decide(deny) failed: ${String(e)}${decideFailureNote(e)}`,
+                        reason: `decide(deny) failed: ${String(e)}${decideFailureNote(e, 'deny')}`,
                         ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
                         ...(currentPending !== undefined ? { currentPending } : {}),
                         ...(wireCode !== undefined ? { errorCode: wireCode } : {}),

package/dist/index.d.ts

@@ -70,7 +70,8 @@ export * from './sseIdleTriage.js';
 export * from './engineWireSdk.js';
 export * from './classifierVerdictWire.js';
 export { stripSystemReminderBlocks, unwrapSystemReminder } from './systemReminderTag.js';
-export { ACTIVE_RUN_BUSY_ERROR_CODE, asModelFallbackReason, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, CONFIG_LIMIT_INVALID, CONFIG_LIMIT_UNKNOWN_KEY, CONFIG_MEMORY_PROJECT_KEY_SPELLING, CONFIG_MEMORY_WRITE_SCOPE_MISMATCH, CONFIG_REFUSAL_CODES, CONFIG_STRATEGY_FIND_LIMIT_INVALID, CONFIG_STRATEGY_MAX_SIZE_INVALID, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, DELEGATION_CAP_CODES, DELEGATION_CONCURRENCY_CAP, DELEGATION_SESSION_CAP, delegationCapDispositionOf, DRAINING_ERROR_CODE, ENGINE_STOP_REASONS, engineStopReasonToCc, ENV_LIFETIME_EXPIRED, GATE_PARKED_ERROR_CODE, isConfigRefusalCode, isDelegationCapCode, isInterruptedToolEndCode, isLimitsExceededCode, isRewindFamilyCode, isWorkflowParkRefusalCode, LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, MCP_SERVER_REVOKED, MODEL_FALLBACK_INHERIT_NO_TIER_BINDING, OUTPUT_INVALID, RESUME_AT_ERROR_CODE_PREFIX, RESUME_CONTEXT_UNAVAILABLE, RESUME_ENV_FAILED, RESUME_PLACEMENT_MISMATCH, RESUME_POLICY_FOLD_CODE, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, RESUME_TOOL_CONTRACT_MISMATCH, RESUME_TOOL_UNAVAILABLE, RESUME_USAGE_WINDOW_EXHAUSTED, REWIND_ERROR_CODE_PREFIXES, SCENARIO_NOT_ALLOWED_ERROR_CODE, STOP_CONFLICT_CODES, STREAM_MAX_DURATION, TOOL_END_INTERRUPTED_NEVER_STARTED, TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN, USAGE_WINDOW_EXHAUSTED, WORKFLOW_PARK_REFUSAL_CODES, } from './engineErrorCodes.js';
+export { findSystemReminderOpenTag, type SystemReminderOpenTagSpan } from './systemReminderTag.js';
+export { ACTIVE_RUN_BUSY_ERROR_CODE, asModelFallbackReason, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, CONFIG_LEGACY_TOOL_NAME, CONFIG_LIMIT_INVALID, CONFIG_LIMIT_UNKNOWN_KEY, CONFIG_MEMORY_PROJECT_KEY_SPELLING, CONFIG_MEMORY_WRITE_SCOPE_MISMATCH, CONFIG_REFUSAL_CODES, CONFIG_STRATEGY_FIND_LIMIT_INVALID, CONFIG_STRATEGY_MAX_SIZE_INVALID, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, DELEGATION_CAP_CODES, DELEGATION_CONCURRENCY_CAP, DELEGATION_SESSION_CAP, delegationCapDispositionOf, DRAINING_ERROR_CODE, ENGINE_STOP_REASONS, engineStopReasonToCc, ENV_LIFETIME_EXPIRED, GATE_PARKED_ERROR_CODE, isConfigRefusalCode, isDelegationCapCode, isInterruptedToolEndCode, isLimitsExceededCode, isRewindFamilyCode, isWorkflowParkRefusalCode, LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, MCP_SERVER_REVOKED, MODEL_FALLBACK_INHERIT_NO_TIER_BINDING, OUTPUT_INVALID, PARKED_RESUME_STARTUP_FAILED, RESUME_AT_ERROR_CODE_PREFIX, RESUME_CONTEXT_UNAVAILABLE, RESUME_ENV_FAILED, RESUME_PLACEMENT_MISMATCH, RESUME_POLICY_FOLD_CODE, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, RESUME_TOOL_CONTRACT_MISMATCH, RESUME_TOOL_UNAVAILABLE, RESUME_USAGE_WINDOW_EXHAUSTED, REWIND_ERROR_CODE_PREFIXES, SCENARIO_NOT_ALLOWED_ERROR_CODE, STOP_CONFLICT_CODES, STREAM_MAX_DURATION, TOOL_END_INTERRUPTED_NEVER_STARTED, TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN, USAGE_WINDOW_EXHAUSTED, WORKFLOW_PARK_REFUSAL_CODES, } from './engineErrorCodes.js';
 export type { DelegationCapDisposition, ModelFallbackReason, } from './engineErrorCodes.js';
 export * from './agentsWireCaps.js';
 export * from './attachmentsWireCaps.js';

package/dist/index.js

@@ -64,7 +64,8 @@ export * from './sseIdleTriage.js';
 export * from './engineWireSdk.js';
 export * from './classifierVerdictWire.js';
 export { stripSystemReminderBlocks, unwrapSystemReminder } from './systemReminderTag.js';
-export { ACTIVE_RUN_BUSY_ERROR_CODE, asModelFallbackReason, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, CONFIG_LIMIT_INVALID, CONFIG_LIMIT_UNKNOWN_KEY, CONFIG_MEMORY_PROJECT_KEY_SPELLING, CONFIG_MEMORY_WRITE_SCOPE_MISMATCH, CONFIG_REFUSAL_CODES, CONFIG_STRATEGY_FIND_LIMIT_INVALID, CONFIG_STRATEGY_MAX_SIZE_INVALID, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, DELEGATION_CAP_CODES, DELEGATION_CONCURRENCY_CAP, DELEGATION_SESSION_CAP, delegationCapDispositionOf, DRAINING_ERROR_CODE, ENGINE_STOP_REASONS, engineStopReasonToCc, ENV_LIFETIME_EXPIRED, GATE_PARKED_ERROR_CODE, isConfigRefusalCode, isDelegationCapCode, isInterruptedToolEndCode, isLimitsExceededCode, isRewindFamilyCode, isWorkflowParkRefusalCode, LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, MCP_SERVER_REVOKED, MODEL_FALLBACK_INHERIT_NO_TIER_BINDING, OUTPUT_INVALID, RESUME_AT_ERROR_CODE_PREFIX, RESUME_CONTEXT_UNAVAILABLE, RESUME_ENV_FAILED, RESUME_PLACEMENT_MISMATCH, RESUME_POLICY_FOLD_CODE, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, RESUME_TOOL_CONTRACT_MISMATCH, RESUME_TOOL_UNAVAILABLE, RESUME_USAGE_WINDOW_EXHAUSTED, REWIND_ERROR_CODE_PREFIXES, SCENARIO_NOT_ALLOWED_ERROR_CODE, STOP_CONFLICT_CODES, STREAM_MAX_DURATION, TOOL_END_INTERRUPTED_NEVER_STARTED, TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN, USAGE_WINDOW_EXHAUSTED, WORKFLOW_PARK_REFUSAL_CODES, } from './engineErrorCodes.js';
+export { findSystemReminderOpenTag } from './systemReminderTag.js';
+export { ACTIVE_RUN_BUSY_ERROR_CODE, asModelFallbackReason, CAPABILITY_SELF_ORCHESTRATION_REQUIRED, CONFIG_DELEGATION_ENTRY_CAPS, CONFIG_LEGACY_TOOL_NAME, CONFIG_LIMIT_INVALID, CONFIG_LIMIT_UNKNOWN_KEY, CONFIG_MEMORY_PROJECT_KEY_SPELLING, CONFIG_MEMORY_WRITE_SCOPE_MISMATCH, CONFIG_REFUSAL_CODES, CONFIG_STRATEGY_FIND_LIMIT_INVALID, CONFIG_STRATEGY_MAX_SIZE_INVALID, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, DELEGATION_CAP_CODES, DELEGATION_CONCURRENCY_CAP, DELEGATION_SESSION_CAP, delegationCapDispositionOf, DRAINING_ERROR_CODE, ENGINE_STOP_REASONS, engineStopReasonToCc, ENV_LIFETIME_EXPIRED, GATE_PARKED_ERROR_CODE, isConfigRefusalCode, isDelegationCapCode, isInterruptedToolEndCode, isLimitsExceededCode, isRewindFamilyCode, isWorkflowParkRefusalCode, LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, MCP_SERVER_REVOKED, MODEL_FALLBACK_INHERIT_NO_TIER_BINDING, OUTPUT_INVALID, PARKED_RESUME_STARTUP_FAILED, RESUME_AT_ERROR_CODE_PREFIX, RESUME_CONTEXT_UNAVAILABLE, RESUME_ENV_FAILED, RESUME_PLACEMENT_MISMATCH, RESUME_POLICY_FOLD_CODE, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_RETRY_LATER_CODES, RESUME_TOOL_CONTRACT_MISMATCH, RESUME_TOOL_UNAVAILABLE, RESUME_USAGE_WINDOW_EXHAUSTED, REWIND_ERROR_CODE_PREFIXES, SCENARIO_NOT_ALLOWED_ERROR_CODE, STOP_CONFLICT_CODES, STREAM_MAX_DURATION, TOOL_END_INTERRUPTED_NEVER_STARTED, TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN, USAGE_WINDOW_EXHAUSTED, WORKFLOW_PARK_REFUSAL_CODES, } from './engineErrorCodes.js';
 export * from './agentsWireCaps.js';
 export * from './attachmentsWireCaps.js';
 export * from './clientContextWireCaps.js';

package/dist/liveInitToolFace.js

@@ -1,4 +1,5 @@
 import { makeEngineWireClient, resolveWireAuth } from './engineWireSdk.js';
+import { settleWithinDeadline } from './abortableSleep.js';
 import { hostLog } from './host.js';
 import { scenarioForPrint } from './scenarioWire.js';
 import { resolveHeadlessInteractiveTools } from './interactiveToolsWire.js';
@@ -58,17 +59,34 @@ export function _resetLiveInitToolFaceForTest() {
     cached = null;
 }
 export async function probeScenarioTools(baseUrl, scenario, opts) {
-    const client = makeEngineWireClient({
-        baseUrl,
-        ...(opts?.authToken ? { token: opts.authToken } : {}),
-        ...(opts?.principal ? { principal: opts.principal } : {}),
-        timeoutMs: opts?.timeoutMs ?? 2000,
-        ...(opts?.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
-    });
-    if (!client)
-        return null;
+    const injected = opts?.client;
+    let body;
+    if (injected !== undefined) {
+        if (typeof injected?.scenarioCapabilities !== 'function')
+            return null;
+        const got = await settleWithinDeadline(opts?.timeoutMs ?? 2000, (signal) => injected.scenarioCapabilities(scenario, { signal }));
+        if (got.kind !== 'value')
+            return null;
+        body = got.value;
+    }
+    else {
+        const client = makeEngineWireClient({
+            baseUrl,
+            ...(opts?.authToken ? { token: opts.authToken } : {}),
+            ...(opts?.principal ? { principal: opts.principal } : {}),
+            timeoutMs: opts?.timeoutMs ?? 2000,
+            ...(opts?.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
+        });
+        if (!client)
+            return null;
+        try {
+            body = await client.scenarioCapabilities(scenario);
+        }
+        catch {
+            return null;
+        }
+    }
     try {
-        const body = await client.scenarioCapabilities(scenario);
         if (!Array.isArray(body?.tools))
             return null;
         const names = body.tools.filter((t) => typeof t === 'string' && t.length > 0);

package/dist/resumeRefusalCopy.d.ts

@@ -33,3 +33,14 @@ export interface ResumeContextUnavailableDetail {
 }
 export declare function resumeContextUnavailableFromError(err: unknown): ResumeContextUnavailableDetail | null;
 export declare function resumeContextUnavailableContent(d: ResumeContextUnavailableDetail): string;
+export type ParkedResumeStartupDecision = 'approve' | 'deny';
+export type ParkedResumeStartupCause = 'resume_rejected' | 'undetermined';
+export interface ParkedResumeStartupDetail {
+    code: string;
+    cause: ParkedResumeStartupCause;
+    taskId?: string;
+    resendable: false;
+    denyStaysOpen: true;
+}
+export declare function parkedResumeStartupFromError(err: unknown, decision?: ParkedResumeStartupDecision): ParkedResumeStartupDetail | null;
+export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDetail): string;

package/dist/resumeRefusalCopy.js

@@ -1,5 +1,5 @@
 import { readErrorNumber, readErrorString } from './wireFailureShape.js';
-import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE, RESUME_POLICY_FOLD_CODE, } from './engineErrorCodes.js';
+import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
 export const RESUME_REFUSAL_CODES = Object.freeze([
@@ -134,3 +134,41 @@ export function resumeContextUnavailableContent(d) {
         third,
     ].join(' · ');
 }
+export function parkedResumeStartupFromError(err, decision) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    let code;
+    try {
+        code = err.errorCode;
+    }
+    catch {
+        return null;
+    }
+    if (code !== PARKED_RESUME_STARTUP_FAILED)
+        return null;
+    const rawTaskId = readErrorString(err, 'taskId');
+    const taskId = rawTaskId !== undefined && rawTaskId.length > 0 ? rawTaskId : undefined;
+    return {
+        code: PARKED_RESUME_STARTUP_FAILED,
+        cause: decision === 'deny' ? 'resume_rejected' : 'undetermined',
+        ...(taskId !== undefined ? { taskId } : {}),
+        resendable: false,
+        denyStaysOpen: true,
+    };
+}
+const PARKED_RESUME_STARTUP_STATE = 'This refusal does not say whether the card is still waiting — re-fetch the pending approvals';
+const PARKED_RESUME_STARTUP_SENTENCES = Object.freeze({
+    resume_rejected: [
+        'The engine could not start the parked work to apply this decision (its session may be gone, or the engine rejected the decision itself)',
+        PARKED_RESUME_STARTUP_STATE,
+        'If the card is still there, decide it again from the fresh list',
+    ].join(' · '),
+    undetermined: [
+        'The engine could not start the parked work to apply this decision',
+        PARKED_RESUME_STARTUP_STATE,
+        'If the card is still there: when the engine rejected the decision itself (for example an answer given to the wrong question), correct it and decide again; when the approved tool is one the agent inherits from the task that started it, approving it again will not work on this server — deny the card, or wait for a server upgrade',
+    ].join(' · '),
+});
+export function parkedResumeStartupContent(detail) {
+    return detail.cause === 'resume_rejected' ? PARKED_RESUME_STARTUP_SENTENCES.resume_rejected : PARKED_RESUME_STARTUP_SENTENCES.undetermined;
+}

package/dist/systemReminderTag.d.ts

@@ -1,2 +1,7 @@
+export interface SystemReminderOpenTagSpan {
+    readonly start: number;
+    readonly end: number;
+}
+export declare function findSystemReminderOpenTag(text: string, from?: number): SystemReminderOpenTagSpan | null;
 export declare function unwrapSystemReminder(text: string): string;
 export declare function stripSystemReminderBlocks(text: string): string;

package/dist/systemReminderTag.js

@@ -1,29 +1,40 @@
 const OPEN_TAG_SOURCE = '<system-reminder(?: mark="[A-Za-z0-9_-]{22}")?>';
 const CLOSE_TAG = '</system-reminder>';
-const OPEN_TAG_AT_START_RE = new RegExp(`^${OPEN_TAG_SOURCE}`);
+function matchOpenTag(text, from, anchored) {
+    const re = new RegExp(OPEN_TAG_SOURCE, anchored ? 'y' : 'g');
+    re.lastIndex = from;
+    const m = re.exec(text);
+    return m === null ? null : { start: m.index, end: m.index + m[0].length };
+}
+export function findSystemReminderOpenTag(text, from) {
+    if (typeof text !== 'string')
+        return null;
+    const at = from === undefined ? 0 : from;
+    if (!Number.isInteger(at) || at < 0 || at > text.length)
+        return null;
+    return matchOpenTag(text, at, false);
+}
 export function unwrapSystemReminder(text) {
     const head = text.trimStart();
-    const open = OPEN_TAG_AT_START_RE.exec(head);
+    const open = matchOpenTag(head, 0, true);
     if (open === null)
         return text;
     const whole = head.trimEnd();
-    if (!whole.endsWith(CLOSE_TAG) || whole.length - CLOSE_TAG.length < open[0].length)
+    if (!whole.endsWith(CLOSE_TAG) || whole.length - CLOSE_TAG.length < open.end)
         return text;
-    return whole.slice(open[0].length, whole.length - CLOSE_TAG.length).trim();
+    return whole.slice(open.end, whole.length - CLOSE_TAG.length).trim();
 }
 export function stripSystemReminderBlocks(text) {
-    const openRe = new RegExp(OPEN_TAG_SOURCE, 'g');
     let out = '';
     let pos = 0;
     for (;;) {
-        openRe.lastIndex = pos;
-        const open = openRe.exec(text);
+        const open = matchOpenTag(text, pos, false);
         if (open === null)
             break;
-        const close = text.indexOf(CLOSE_TAG, open.index + open[0].length);
+        const close = text.indexOf(CLOSE_TAG, open.end);
         if (close === -1)
             break;
-        out += text.slice(pos, open.index);
+        out += text.slice(pos, open.start);
         pos = close + CLOSE_TAG.length;
     }
     return pos === 0 ? text : out + text.slice(pos);