@sema-agent/client-core 0.87.0 → 0.88.0

package/dist/engineErrorCodes.d.ts

@@ -48,6 +48,8 @@ export declare const REWIND_ERROR_CODE_PREFIXES: readonly ["resume_at.", "rewind
 export declare function isRewindFamilyCode(code: string | undefined): boolean;
 export declare const RESUME_USAGE_WINDOW_EXHAUSTED = "resume.usage_window_exhausted";
 export declare const RESUME_PREFLIGHT_REJECTED = "resume.preflight_rejected";
+export declare const RESUME_SESSION_NOT_FOUND = "resume.session_not_found";
+export type StatusDerivedCoarseCode = (typeof STATUS_DERIVED_COARSE_CODES)[number];
 export declare const RESUME_PLACEMENT_MISMATCH = "resume.placement_mismatch";
 export declare const RESUME_CONTEXT_UNAVAILABLE = "conflict.resume_context_unavailable";
 export declare const RESUME_RETRY_LATER_CODES: readonly string[];

package/dist/engineErrorCodes.js

@@ -106,6 +106,7 @@ export function isRewindFamilyCode(code) {
 }
 export const RESUME_USAGE_WINDOW_EXHAUSTED = 'resume.usage_window_exhausted';
 export const RESUME_PREFLIGHT_REJECTED = 'resume.preflight_rejected';
+export const RESUME_SESSION_NOT_FOUND = 'resume.session_not_found';
 export const RESUME_PLACEMENT_MISMATCH = 'resume.placement_mismatch';
 export const RESUME_CONTEXT_UNAVAILABLE = 'conflict.resume_context_unavailable';
 export const RESUME_RETRY_LATER_CODES = Object.freeze([

package/dist/engineNoticeCodes.d.ts

@@ -137,6 +137,24 @@ export interface LegacyModeSeedMigratedFactsView {
     runId: string;
 }
 export declare function readLegacyModeSeedMigrated(notice: unknown): LegacyModeSeedMigratedFactsView | undefined;
+export interface ToolTurnRepairView {
+    form: string;
+    toolCallIds: readonly string[];
+}
+export interface ToolTurnRepairedFactsView {
+    repairs: readonly ToolTurnRepairView[];
+    sessionId: string;
+    runId: string;
+}
+export declare function readToolTurnRepaired(notice: unknown): ToolTurnRepairedFactsView | undefined;
+export interface ModelUnreachableFactsView {
+    code: string;
+    targetHost: string;
+    proxyInUse?: string;
+    remedy: string;
+    sessionId: string;
+}
+export declare function readModelUnreachable(notice: unknown): ModelUnreachableFactsView | undefined;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -153,6 +171,8 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'permission.ask_released_by_mode': typeof readAskReleasedByMode;
     readonly 'permission.read_deny_unapplied': typeof readReadDenyUnapplied;
     readonly 'resume.legacy_mode_seed_migrated': typeof readLegacyModeSeedMigrated;
+    readonly 'context.tool_turn_repaired': typeof readToolTurnRepaired;
+    readonly 'server.model_unreachable': typeof readModelUnreachable;
 }>;
 type FactReaderTable = typeof ENGINE_NOTICE_FACT_READERS;
 export type EngineNoticeFactsCode = keyof FactReaderTable;

package/dist/engineNoticeCodes.js

@@ -7,6 +7,7 @@ export const SERVER_NOTICE_AUDIENCE = Object.freeze({
     'instructions.source_changed': 'user',
     'memory.layer_locked_legacy': 'operator',
     'session.records_skipped': 'user',
+    'server.model_unreachable': 'user',
 });
 function audienceRow(table, code) {
     return Object.hasOwn(table, code) ? table[code] : undefined;
@@ -483,6 +484,74 @@ function readLegacyModeSeedMigratedOf(notice) {
     const permissionMode = nonEmpty(optionalSeat(mo, 'permissionMode'));
     return { ...(permissionMode !== undefined ? { permissionMode } : {}), droppedKeys, sessionId, runId };
 }
+export function readToolTurnRepaired(notice) {
+    return guardedRead(notice, readToolTurnRepairedOf);
+}
+function ownSeat(o, key) {
+    return Object.hasOwn(o, key) ? o[key] : undefined;
+}
+function optionalOwnSeat(o, key) {
+    try {
+        return ownSeat(o, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readToolTurnRepairedOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'context.tool_turn_repaired')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const rawRepairs = ownSeat(o, 'repairs');
+    if (!Array.isArray(rawRepairs) || rawRepairs.length === 0)
+        return undefined;
+    const count = rawRepairs.length;
+    const repairs = [];
+    for (let i = 0; i < count; i++) {
+        const item = rawRepairs[i];
+        if (typeof item !== 'object' || item === null || Array.isArray(item))
+            return undefined;
+        const it = item;
+        const form = nonEmpty(ownSeat(it, 'form'));
+        const toolCallIds = nameList(ownSeat(it, 'toolCallIds'));
+        if (form === undefined || toolCallIds === undefined || toolCallIds.length === 0)
+            return undefined;
+        repairs.push(Object.freeze({ form, toolCallIds }));
+    }
+    const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
+    const runId = nonEmpty(ownSeat(o, 'runId'));
+    if (sessionId === undefined || runId === undefined)
+        return undefined;
+    return { repairs: Object.freeze(repairs), sessionId, runId };
+}
+export function readModelUnreachable(notice) {
+    return guardedRead(notice, readModelUnreachableOf);
+}
+function readModelUnreachableOf(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    const n = notice;
+    if (n.code !== 'server.model_unreachable')
+        return undefined;
+    const d = n.detail;
+    if (typeof d !== 'object' || d === null || Array.isArray(d))
+        return undefined;
+    const o = d;
+    const code = nonEmpty(ownSeat(o, 'code'));
+    const targetHost = nonEmpty(ownSeat(o, 'targetHost'));
+    const remedy = nonEmpty(ownSeat(o, 'remedy'));
+    const sessionId = nonEmpty(ownSeat(o, 'sessionId'));
+    if (code === undefined || targetHost === undefined || remedy === undefined || sessionId === undefined)
+        return undefined;
+    const proxyInUse = nonEmpty(optionalOwnSeat(o, 'proxyInUse'));
+    return { code, targetHost, ...(proxyInUse !== undefined ? { proxyInUse } : {}), remedy, sessionId };
+}
 export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'mcp.injection_dropped': readMcpInjectionDrop,
     'delegation.ask_unresolvable': readAskUnresolvable,
@@ -499,6 +568,8 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'permission.ask_released_by_mode': readAskReleasedByMode,
     'permission.read_deny_unapplied': readReadDenyUnapplied,
     'resume.legacy_mode_seed_migrated': readLegacyModeSeedMigrated,
+    'context.tool_turn_repaired': readToolTurnRepaired,
+    'server.model_unreachable': readModelUnreachable,
 });
 const _factReaderTablePin = true;
 void _factReaderTablePin;

package/dist/engineWireFor.d.ts

@@ -40,4 +40,5 @@ export type EngineWireNoAnswerKind = 'deadline' | 'time-limit' | 'connection-los
 export declare function noAnswerKindOf(e: object | null | undefined): EngineWireNoAnswerKind | null;
 export declare function noAnswerDetailFrom(e: object | null | undefined): string | null;
 export declare function sendOnce<T>(signal: AbortSignal | null | undefined, run: () => Promise<T>): Promise<T>;
+export declare function provablyNotSent(e: object | null | undefined): boolean;
 export declare function settleInjected<T>(ms: number, signal: AbortSignal | null | undefined, run: (signal: AbortSignal) => Promise<T>): Promise<T>;

package/dist/engineWireFor.js

@@ -331,7 +331,7 @@ export async function sendOnce(signal, run) {
         throw error;
     }
 }
-function provablyNotSent(e) {
+export function provablyNotSent(e) {
     try {
         return e !== null && typeof e === 'object' && (markedNotSent(e) || failedBeforeSend(e));
     }

package/dist/gateOutcome.d.ts

@@ -1,5 +1,6 @@
 import type { DeniedBy, Settlement } from '@sema-agent/sdk';
 import { type CcToolDenialKind } from './gateVocabulary.js';
+import { CORE_MODE_RELEASE_REASONS } from './generated/engineFactTables.js';
 export type GateDispositionView = {
     kind: 'allowed';
     classifier?: GateClassifierRoundView;
@@ -31,6 +32,9 @@ export interface GateModeReleaseView {
     mandate?: string;
     reason?: string;
 }
+export declare const GATE_MODE_RELEASE_REASON_WORDS: readonly ["rule_unreadable"];
+export type GateModeReleaseReasonWord = (typeof CORE_MODE_RELEASE_REASONS)[number];
+export declare function isGateModeReleaseReasonWord(v: unknown): v is GateModeReleaseReasonWord;
 export interface SettlementWhoView {
     party: string;
     approver?: string;

package/dist/gateOutcome.js

@@ -1,8 +1,13 @@
 import { ccToolDenialKindForSettledBy, isCcToolDenialKind, isGateDeniedByWord } from './gateVocabulary.js';
 import { GATE_PARKED_ERROR_CODE } from './engineErrorCodes.js';
+import { CORE_MODE_RELEASE_REASONS } from './generated/engineFactTables.js';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+export const GATE_MODE_RELEASE_REASON_WORDS = CORE_MODE_RELEASE_REASONS;
+export function isGateModeReleaseReasonWord(v) {
+    return typeof v === 'string' && CORE_MODE_RELEASE_REASONS.includes(v);
+}
 export const SETTLEMENT_KIND_WORDS = Object.freeze([
     'human_allowed',
     'human_refused',

package/dist/generated/engineFactTables.d.ts

@@ -8,3 +8,4 @@ export declare const CORE_DENIED_BY_VALUES: readonly ["policy", "hook", "org", "
 export declare const CORE_PERMISSION_MODE_FOLD_REASONS: readonly string[];
 export declare const CORE_ENGINE_CARD_TYPES: readonly string[];
 export declare const CORE_TOOL_DECLARATION_CODES: readonly string[];
+export declare const CORE_MODE_RELEASE_REASONS: readonly ["rule_unreadable"];

package/dist/generated/engineFactTables.js

@@ -111,3 +111,6 @@ export const CORE_TOOL_DECLARATION_CODES = Object.freeze([
     "config.egress_requires_write_effect",
     "config.reserved_tool_name",
 ]);
+export const CORE_MODE_RELEASE_REASONS = Object.freeze([
+    "rule_unreadable",
+]);

package/dist/generated/engineNoticeTables.js

@@ -65,6 +65,7 @@ export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
     "route.base_url_changed_key_unchanged",
     "route.response_model_mismatch",
     "route.tool_call_id_folded",
+    "context.tool_turn_repaired",
     "task.user_steer_undrained",
     "task.user_followup_undrained",
     "steering.parked_input_blocked",
@@ -147,6 +148,7 @@ export const CORE_NOTICE_AUDIENCE = Object.freeze({
     "route.base_url_changed_key_unchanged": "operator",
     "route.response_model_mismatch": "operator",
     "route.tool_call_id_folded": "operator",
+    "context.tool_turn_repaired": "operator",
     "task.user_steer_undrained": "user",
     "task.user_followup_undrained": "user",
     "steering.parked_input_blocked": "user",

package/dist/hitl/crashConverged.d.ts

@@ -8,7 +8,7 @@ export interface CrashConvergedRow {
     readonly ts: number;
     readonly expiresAtMs: number;
     readonly decision: 'denied';
-    readonly cause: 'crashed_before_park';
+    readonly cause: 'crashed_before_park' | 'shutdown_before_park';
     readonly orphanState: CrashConvergedOrphanState;
     readonly originalDecision?: 'approve';
     readonly decidedAtMs?: number;

package/dist/hitl/crashConverged.js

@@ -1,3 +1,8 @@
+const CRASH_CONVERGED_CAUSE_WORDS = Object.freeze({
+    crashed_before_park: true,
+    shutdown_before_park: true,
+});
+const isCrashConvergedCause = (v) => typeof v === 'string' && Object.hasOwn(CRASH_CONVERGED_CAUSE_WORDS, v);
 const isString = (v) => typeof v === 'string';
 const isNumber = (v) => typeof v === 'number';
 const nonEmptyString = (v) => typeof v === 'string' && v.length > 0;
@@ -45,7 +50,7 @@ function readCrashConvergedRow(v) {
             return null;
         if (o.decision !== 'denied')
             return null;
-        if (o.cause !== 'crashed_before_park')
+        if (!isCrashConvergedCause(o.cause))
             return null;
         if (o.orphanState !== 'pending' && o.orphanState !== 'decided')
             return null;

package/dist/hitl/planReviewWire.js

@@ -346,9 +346,11 @@ let decideDispatchSeq = 0;
 function planReviewOpsOf(taskId) {
     return planReviewDecisionOps.filter((op) => op.taskId === taskId);
 }
-function settlePlanReviewDecisionOp(op) {
-    if (op.settledAt === null)
-        op.settledAt = ++planReviewLedgerClock;
+function settlePlanReviewDecisionOp(op, by) {
+    if (op.settledAt !== null)
+        return;
+    op.settledAt = ++planReviewLedgerClock;
+    op.settler = by;
 }
 function pushPlanReviewDecisionOp(op) {
     planReviewDecisionOps.push(op);
@@ -366,18 +368,31 @@ function dropPlanReviewDecisionOp(op) {
     if (i >= 0)
         planReviewDecisionOps.splice(i, 1);
 }
+function claimablePlanReviewDecisionOp(taskId) {
+    const open = planReviewDecisionOps.find((o) => o.taskId === taskId && o.phase === 'handed' && o.settledAt === null);
+    if (open !== undefined)
+        return open;
+    let leftBehind;
+    for (const o of planReviewDecisionOps) {
+        if (o.taskId !== taskId || o.phase !== 'handed' || o.settler !== 'gate_left')
+            continue;
+        if (leftBehind === undefined || o.handedAt > leftBehind.handedAt)
+            leftBehind = o;
+    }
+    return leftBehind;
+}
 export function notePlanReviewDecisionHandedOver(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
         return null;
     if (planReviewDecisionOps.some((op) => op.taskId === taskId && op.settledAt === null))
         return null;
-    const op = { taskId, handedAt: ++planReviewLedgerClock, settledAt: null, phase: 'handed', notApplied: false, ownCallOpen: false };
+    const op = { taskId, handedAt: ++planReviewLedgerClock, settledAt: null, settler: null, phase: 'handed', notApplied: false, ownCallOpen: false };
     pushPlanReviewDecisionOp(op);
     return {
         settle: () => {
             if (op.phase !== 'handed')
                 return;
-            settlePlanReviewDecisionOp(op);
+            settlePlanReviewDecisionOp(op, 'host');
         },
         revoke: () => {
             if (op.phase !== 'handed' || op.settledAt !== null)
@@ -412,7 +427,7 @@ export function notePlanReviewGateLeft(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
         return;
     for (const op of planReviewOpsOf(taskId))
-        settlePlanReviewDecisionOp(op);
+        settlePlanReviewDecisionOp(op, 'gate_left');
 }
 export function latestPlanReviewDecisionMark(taskId) {
     if (typeof taskId !== 'string' || taskId === '')
@@ -434,12 +449,17 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
         hostLog('error', `planReviewWire: decidePlanReview(${decision}) for task ${taskId} REFUSED — a decision for this task is already in flight (duplicate delivery latched)`);
         return;
     }
-    let op = planReviewDecisionOps.find((o) => o.taskId === taskId && o.phase === 'handed' && o.settledAt === null);
+    let op = claimablePlanReviewDecisionOp(taskId);
     if (op === undefined) {
-        op = { taskId: typeof taskId === 'string' ? taskId : String(taskId), handedAt: ++planReviewLedgerClock, settledAt: null, phase: 'posting', notApplied: false, ownCallOpen: true };
+        op = { taskId: typeof taskId === 'string' ? taskId : String(taskId), handedAt: ++planReviewLedgerClock, settledAt: null, settler: null, phase: 'posting', notApplied: false, ownCallOpen: true };
         pushPlanReviewDecisionOp(op);
     }
     else {
+        if (op.settler === 'gate_left') {
+            op.settledAt = null;
+            op.settler = null;
+            op.notApplied = false;
+        }
         op.phase = 'posting';
         op.ownCallOpen = true;
     }
@@ -451,7 +471,7 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
     const settle = (notApplied) => {
         if (notApplied)
             mine.notApplied = true;
-        settlePlanReviewDecisionOp(mine);
+        settlePlanReviewDecisionOp(mine, 'package');
     };
     const dispatchNo = ++decideDispatchSeq;
     hostLog('debug', `planReviewWire: decidePlanReview dispatch #${dispatchNo} task=${taskId} decision=${decision} mode=${permissionModeAfter ?? '-'}`);
@@ -460,7 +480,7 @@ async function decidePlanReviewFor(taskId, decision, permissionModeAfter, opts,
     }
     finally {
         releaseLatch();
-        settlePlanReviewDecisionOp(mine);
+        settlePlanReviewDecisionOp(mine, 'package');
         mine.ownCallOpen = false;
     }
 }

package/dist/index.d.ts

@@ -146,6 +146,10 @@ export * from './wireErrorTriage.js';
 export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
 export { classifyToolHistoryMismatch, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
+export { classifyRegistryConflict, isScopeGoneError } from './registryConflict.js';
+export type { RegistryConflictClass } from './registryConflict.js';
+export { createPromptDeliveryLedger, promptKnownUndelivered, withoutUndeliveredPrompts } from './promptDelivery.js';
+export type { PromptDeliveryLedger, PromptDeliveryRecord } from './promptDelivery.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
 export * from './inheritEnvWire.js';
@@ -198,6 +202,8 @@ export { readEngineAgentRegistry, isEngineAgentRegistryListingSuperseded } from
 export type { EngineAgentRegistryClient } from './agentSession/engineAgentRegistryRead.js';
 export { stopEngineSessionBackground, engineSessionBackgroundReceiptReadingOf, ENGINE_SESSION_BACKGROUND_RECEIPT_STATES, } from './agentSession/engineSessionBackgroundStop.js';
 export type { EngineSessionBackgroundStopClient, EngineSessionBackgroundStopWire, EngineSessionBackgroundStopOptions, EngineSessionBackgroundReceipt, EngineSessionBackgroundStopUnavailableWhy, EngineSessionBackgroundStopRefusedWhy, EngineSessionBackgroundStopResult, EngineSessionBackgroundReceiptState, EngineSessionBackgroundReceiptReading, } from './agentSession/engineSessionBackgroundStop.js';
+export { eraseSessionMemory, sessionMemoryEraseOutcome, SESSION_MEMORY_ERASE_REFUSAL_REASONS, SESSION_MEMORY_ERASE_UNCONFIRMED_WHYS, SESSION_MEMORY_ERASE_RETRIES, } from './sessionMemoryErase.js';
+export type { SessionMemoryEraseWire, SessionMemoryEraseCall, SessionMemoryEraseOptions, SessionMemoryEraseSent, SessionMemoryEraseNotSentWhy, SessionMemoryEraseJson, SessionMemoryEraseAnswer, SessionMemoryEraseRefusalReason, SessionMemoryEraseUnconfirmedWhy, SessionMemoryEraseRetry, SessionMemoryEraseOutcome, } from './sessionMemoryErase.js';
 export * from './model/catalog.js';
 export * from './model/catalogLoader.js';
 export * from './model/providerAuth.js';

package/dist/index.js

@@ -134,6 +134,8 @@ export * from './wireErrorTriage.js';
 export * from './corruptSession.js';
 export * from './corruptSessionCopy.js';
 export { classifyToolHistoryMismatch, resolveToolHistoryRewindTarget } from './toolHistoryMismatch.js';
+export { classifyRegistryConflict, isScopeGoneError } from './registryConflict.js';
+export { createPromptDeliveryLedger, promptKnownUndelivered, withoutUndeliveredPrompts } from './promptDelivery.js';
 export * from './resumeRefusalCopy.js';
 export * from './wireRefusalCopy.js';
 export * from './inheritEnvWire.js';
@@ -182,6 +184,7 @@ export * from './agentSession/backgroundView.js';
 export { READ_CREDENTIAL_NOT_ACCEPTED_NOTICE } from './readCredentialRefusal.js';
 export { readEngineAgentRegistry, isEngineAgentRegistryListingSuperseded } from './agentSession/engineAgentRegistryRead.js';
 export { stopEngineSessionBackground, engineSessionBackgroundReceiptReadingOf, ENGINE_SESSION_BACKGROUND_RECEIPT_STATES, } from './agentSession/engineSessionBackgroundStop.js';
+export { eraseSessionMemory, sessionMemoryEraseOutcome, SESSION_MEMORY_ERASE_REFUSAL_REASONS, SESSION_MEMORY_ERASE_UNCONFIRMED_WHYS, SESSION_MEMORY_ERASE_RETRIES, } from './sessionMemoryErase.js';
 export * from './model/catalog.js';
 export * from './model/catalogLoader.js';
 export * from './model/providerAuth.js';

package/dist/promptDelivery.d.ts

@@ -0,0 +1,20 @@
+import type { AgentEvent } from '@sema-agent/sdk';
+import { type SelfHealOutcome } from './adapter/activeRunSelfHeal.js';
+export interface PromptDeliveryRecord {
+    readonly u: string;
+    readonly s: 'a' | 'd';
+}
+export interface PromptDeliveryLedger {
+    attempted(batchUuids: readonly string[]): readonly PromptDeliveryRecord[];
+    deliveredByFrame(batchUuids: readonly string[], event: AgentEvent): readonly PromptDeliveryRecord[];
+    deliveredBySteerReceipt(batchUuids: readonly string[], outcome: SelfHealOutcome): readonly PromptDeliveryRecord[];
+    isAttempted(uuid: string): boolean;
+    isDelivered(uuid: string): boolean;
+    knownUndelivered(uuid: string): boolean;
+    batchOf(uuid: string): readonly string[] | undefined;
+    toRecords(): readonly PromptDeliveryRecord[];
+    fromRecords(records: readonly PromptDeliveryRecord[]): readonly PromptDeliveryRecord[];
+}
+export declare function createPromptDeliveryLedger(): PromptDeliveryLedger;
+export declare function promptKnownUndelivered(ledger: PromptDeliveryLedger, message: object | null | undefined): boolean;
+export declare function withoutUndeliveredPrompts<T>(ledger: PromptDeliveryLedger, messages: readonly T[]): T[];

package/dist/promptDelivery.js

@@ -0,0 +1,153 @@
+import { activeRunBusySignal } from './adapter/runStream.js';
+import { selfHealSubmissionDisposition } from './adapter/activeRunSelfHeal.js';
+const uuidOk = (u) => typeof u === 'string' && u.length > 0;
+function cleanBatch(batch) {
+    if (!Array.isArray(batch))
+        return [];
+    const out = [];
+    const seen = new Set();
+    try {
+        for (const u of batch) {
+            if (!uuidOk(u) || seen.has(u))
+                continue;
+            seen.add(u);
+            out.push(u);
+        }
+    }
+    catch {
+        return [];
+    }
+    return out;
+}
+function readRecord(rec) {
+    if (typeof rec !== 'object' || rec === null || Array.isArray(rec))
+        return undefined;
+    try {
+        const u = rec.u;
+        const s = rec.s;
+        return uuidOk(u) && (s === 'a' || s === 'd') ? { u, s } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const PRE_RUN_FRAME_TYPES = new Set(['meta', 'approval_request', 'approval_revoke']);
+function frameProvesDelivery(event) {
+    if (typeof event !== 'object' || event === null || Array.isArray(event))
+        return false;
+    try {
+        const type = event.type;
+        if (typeof type !== 'string' || type.length === 0 || PRE_RUN_FRAME_TYPES.has(type))
+            return false;
+        if (type === 'done') {
+            const result = event.result;
+            if (typeof result === 'object' && result !== null && !Array.isArray(result) && result.status === undefined) {
+                const r = result;
+                if (activeRunBusySignal({ type: 'failed', errorCode: r.errorCode, activeTaskId: r.activeTaskId }) !== null)
+                    return false;
+            }
+        }
+        return activeRunBusySignal(event) === null;
+    }
+    catch {
+        return false;
+    }
+}
+function outcomeProvesDelivery(outcome) {
+    if (typeof outcome !== 'object' || outcome === null || Array.isArray(outcome))
+        return false;
+    try {
+        return selfHealSubmissionDisposition(outcome) === 'handed-off';
+    }
+    catch {
+        return false;
+    }
+}
+export function createPromptDeliveryLedger() {
+    const attemptedSet = new Set();
+    const deliveredSet = new Set();
+    const batchOfMap = new Map();
+    const log = [];
+    const add = (u, s, into) => {
+        const set = s === 'a' ? attemptedSet : deliveredSet;
+        if (set.has(u))
+            return;
+        set.add(u);
+        const rec = Object.freeze({ u, s });
+        log.push(rec);
+        into.push(rec);
+    };
+    const markDelivered = (batchUuids) => {
+        const added = [];
+        for (const u of cleanBatch(batchUuids))
+            add(u, 'd', added);
+        return Object.freeze(added);
+    };
+    return Object.freeze({
+        attempted(batchUuids) {
+            const batch = Object.freeze(cleanBatch(batchUuids));
+            const added = [];
+            for (const u of batch) {
+                batchOfMap.set(u, batch);
+                add(u, 'a', added);
+            }
+            return Object.freeze(added);
+        },
+        deliveredByFrame(batchUuids, event) {
+            return frameProvesDelivery(event) ? markDelivered(batchUuids) : Object.freeze([]);
+        },
+        deliveredBySteerReceipt(batchUuids, outcome) {
+            return outcomeProvesDelivery(outcome) ? markDelivered(batchUuids) : Object.freeze([]);
+        },
+        isAttempted: (uuid) => uuidOk(uuid) && attemptedSet.has(uuid),
+        isDelivered: (uuid) => uuidOk(uuid) && deliveredSet.has(uuid),
+        knownUndelivered: (uuid) => uuidOk(uuid) && attemptedSet.has(uuid) && !deliveredSet.has(uuid),
+        batchOf: (uuid) => (uuidOk(uuid) ? batchOfMap.get(uuid) : undefined),
+        toRecords: () => Object.freeze([...log]),
+        fromRecords(records) {
+            const added = [];
+            if (!Array.isArray(records))
+                return Object.freeze(added);
+            let list;
+            try {
+                list = [...records];
+            }
+            catch {
+                return Object.freeze(added);
+            }
+            for (const raw of list) {
+                const rec = readRecord(raw);
+                if (rec !== undefined)
+                    add(rec.u, rec.s, added);
+            }
+            return Object.freeze(added);
+        },
+    });
+}
+function uuidOfMessage(m) {
+    if (typeof m !== 'object' || m === null)
+        return undefined;
+    try {
+        const u = m.uuid;
+        return uuidOk(u) ? u : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function assertLedger(ledger, fn) {
+    if (typeof ledger !== 'object' || ledger === null || typeof ledger.knownUndelivered !== 'function') {
+        throw new TypeError(`${fn}: the first argument must be a ledger from createPromptDeliveryLedger()`);
+    }
+}
+export function promptKnownUndelivered(ledger, message) {
+    assertLedger(ledger, 'promptKnownUndelivered');
+    const u = uuidOfMessage(message);
+    return u !== undefined && ledger.knownUndelivered(u);
+}
+export function withoutUndeliveredPrompts(ledger, messages) {
+    assertLedger(ledger, 'withoutUndeliveredPrompts');
+    if (!Array.isArray(messages))
+        return [];
+    return messages.filter((m) => !promptKnownUndelivered(ledger, m));
+}

package/dist/registryConflict.d.ts

@@ -0,0 +1,3 @@
+export type RegistryConflictClass = 'gone' | 'conflict' | 'none';
+export declare function classifyRegistryConflict(status: number, body: unknown): RegistryConflictClass;
+export declare function isScopeGoneError(err: unknown): boolean;

package/dist/registryConflict.js

@@ -0,0 +1,44 @@
+const SCOPE_GONE_CODE = 'scope_gone';
+const nonBlank = (v) => {
+    const s = typeof v === 'string' ? v.trim() : '';
+    return s === '' ? undefined : s;
+};
+export function classifyRegistryConflict(status, body) {
+    if (status !== 409)
+        return 'none';
+    try {
+        const b = (typeof body === 'object' && body !== null ? body : {});
+        const error = b.error;
+        const objectForm = typeof error === 'object' && error !== null ? error.code : undefined;
+        const code = nonBlank(b.errorCode) ?? nonBlank(objectForm) ?? (typeof error === 'string' ? error : undefined);
+        return code === SCOPE_GONE_CODE ? 'gone' : 'conflict';
+    }
+    catch {
+        return 'gone';
+    }
+}
+const SCOPE_GONE_ERROR_NAMES = Object.freeze(['ScopeGoneError', 'ControlScopeGoneError']);
+export function isScopeGoneError(err) {
+    if ((typeof err !== 'object' && typeof err !== 'function') || err === null)
+        return false;
+    let status;
+    try {
+        status = err.status;
+    }
+    catch {
+        return false;
+    }
+    if (status !== 409)
+        return false;
+    try {
+        const o = err;
+        const body = o.body;
+        if (body !== undefined && body !== null && classifyRegistryConflict(409, body) === 'gone')
+            return true;
+        const name = o.name;
+        return typeof name === 'string' && SCOPE_GONE_ERROR_NAMES.includes(name);
+    }
+    catch {
+        return true;
+    }
+}

package/dist/request/taskRequest.d.ts

@@ -50,6 +50,7 @@ export interface TaskRequestInput {
     memory?: 'off';
     fileHistory?: 'disabled';
     inheritEnv?: InheritEnvWord;
+    requireExistingSession?: TaskRequest['requireExistingSession'];
     rewind?: Record<string, unknown>;
     repo?: string;
     council?: boolean;