@sema-agent/client-core 0.89.0 → 0.91.0

package/dist/permissionsDeclaration.js

@@ -0,0 +1,307 @@
+import { hasCoreValuePort, protocolOf, retiredToolNames, ruleToolGrammarOf, validatePermissionRules } from './coreValuePorts.js';
+import { allowRulesGate } from './permissionsAllowGrantCapability.js';
+const RULE_TRUST_ORDER = [
+    'policySettings',
+    'cliArg',
+    'flagSettings',
+    'session',
+    'userSettings',
+    'localSettings',
+    'projectSettings',
+];
+export const PERMISSIONS_KEPT_REASONS = Object.freeze([
+    'allow_capability_off',
+    'settings_read_not_clean',
+    'empty_rule',
+    'paren_in_tool_name',
+    'retired_tool_name',
+    'unprefixed_namespaced_name',
+    'incomplete_protocol_name',
+    'home_relative_path',
+    'compile_refused',
+    'content_form_not_grantable',
+    'judge_failed',
+    'duplicate',
+]);
+function normalizeLegacyToolName(name) {
+    switch (name) {
+        case 'Task':
+            return 'Agent';
+        case 'KillShell':
+            return 'TaskStop';
+        case 'AgentOutputTool':
+        case 'BashOutputTool':
+            return 'TaskOutput';
+        default:
+            return name;
+    }
+}
+function unescapedIndex(str, char, fromEnd) {
+    for (let k = 0; k < str.length; k++) {
+        const i = fromEnd ? str.length - 1 - k : k;
+        if (str[i] !== char)
+            continue;
+        let backslashes = 0;
+        for (let j = i - 1; j >= 0 && str[j] === '\\'; j--)
+            backslashes++;
+        if (backslashes % 2 === 0)
+            return i;
+    }
+    return -1;
+}
+function unescapeRuleContent(content) {
+    return content.replace(/\\\(/g, '(').replace(/\\\)/g, ')').replace(/\\\\/g, '\\');
+}
+function parseRule(rule) {
+    const open = unescapedIndex(rule, '(', false);
+    if (open === -1)
+        return { toolName: normalizeLegacyToolName(rule) };
+    const close = unescapedIndex(rule, ')', true);
+    if (close === -1 || close <= open || close !== rule.length - 1)
+        return { toolName: normalizeLegacyToolName(rule) };
+    const toolName = rule.substring(0, open);
+    const rawContent = rule.substring(open + 1, close);
+    if (!toolName)
+        return { toolName: normalizeLegacyToolName(rule) };
+    if (rawContent === '' || rawContent === '*')
+        return { toolName: normalizeLegacyToolName(toolName) };
+    return { toolName: normalizeLegacyToolName(toolName), ruleContent: unescapeRuleContent(rawContent) };
+}
+function requireRulePorts() {
+    const required = ['MCP_NAMESPACE', 'RETIRED_TOOL_NAMES', 'protocolOf', 'ruleToolGrammarOf', 'validatePermissionRules'];
+    const missing = required.filter((p) => !hasCoreValuePort(p));
+    if (missing.length === 0)
+        return;
+    throw new Error(`permissionsDeclaration: 规则判据端口缺席(${missing.join(' / ')})—— 先用 installCoreValuePorts 装上 core 的同名实现。` +
+        '缺席不等于全部合格:不判就发会让整份请求被引擎拒收,不判就删会静默丢掉 deny 规则,所以这里拒绝装配。');
+}
+function wireIssue(name) {
+    if (name.includes('('))
+        return 'paren_in_tool_name';
+    if (retiredToolNames().has(name))
+        return 'retired_tool_name';
+    const ns = protocolOf(name);
+    if (ns === undefined)
+        return name.includes('__') ? 'unprefixed_namespaced_name' : undefined;
+    return ns.parse(name) !== undefined ? undefined : 'incomplete_protocol_name';
+}
+function wholeServerRuleName(name) {
+    const read = name.trim();
+    const ns = protocolOf(read);
+    if (ns === undefined || !read.startsWith(ns.prefix))
+        return name;
+    const peer = read.slice(ns.prefix.length);
+    return peer !== '' && !peer.includes('__') && !peer.endsWith('_') ? `${read}__*` : name;
+}
+const RULE_ROOT = '/';
+function compileVerdict(rule, behavior) {
+    try {
+        const issues = validatePermissionRules([{ rule, behavior }], { pathBases: { root: RULE_ROOT } });
+        if (!Array.isArray(issues))
+            return 'unknown';
+        return issues.length === 0 ? 'compiles' : 'refused';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const kept = (reason) => ({ sent: false, reason });
+function judgeList(rules, behavior) {
+    let portsChecked = false;
+    return rules.map((rule) => {
+        if (rule === '')
+            return kept('empty_rule');
+        if (!portsChecked) {
+            requireRulePorts();
+            portsChecked = true;
+        }
+        const parsed = parseRule(rule);
+        if (parsed.ruleContent === undefined) {
+            const name = wholeServerRuleName(parsed.toolName);
+            const issue = wireIssue(name);
+            if (issue !== undefined)
+                return kept(issue);
+            const verdict = compileVerdict(name, behavior);
+            if (verdict === 'refused')
+                return kept('compile_refused');
+            if (verdict === 'unknown' && behavior === 'allow')
+                return kept('judge_failed');
+            return { sent: true, wire: name, unchecked: verdict === 'unknown' };
+        }
+        const issue = wireIssue(parsed.toolName);
+        if (issue !== undefined)
+            return kept(issue);
+        if (ruleToolGrammarOf(parsed.toolName) === 'path' && parsed.ruleContent.startsWith('~/'))
+            return kept('home_relative_path');
+        const verdict = compileVerdict(rule, behavior);
+        if (verdict === 'refused')
+            return kept(behavior === 'allow' ? 'content_form_not_grantable' : 'compile_refused');
+        if (verdict === 'unknown' && behavior === 'allow')
+            return kept('judge_failed');
+        return { sent: true, wire: rule, unchecked: verdict === 'unknown' };
+    });
+}
+function outsideSettingsFiles(origin) {
+    return origin === 'cliArg' || origin === 'session';
+}
+function judgeBucket(raw, behavior, originOf, cli, settingsGate) {
+    const firstSlot = new Map();
+    for (const s of raw)
+        if (!firstSlot.has(s.rule))
+            firstSlot.set(s.rule, s);
+    const groups = RULE_TRUST_ORDER.map(() => []);
+    const rankOf = (origin) => RULE_TRUST_ORDER.indexOf(origin);
+    if (originOf !== undefined) {
+        for (const [r, origin] of originOf) {
+            const rank = rankOf(origin);
+            if (rank >= 0 && typeof r === 'string' && firstSlot.has(r))
+                groups[rank].push(r);
+        }
+    }
+    const unknownOrigin = [...firstSlot.keys()].filter((r) => originOf === undefined || rankOf(originOf.get(r)) < 0);
+    const fateOfRule = new Map();
+    const sent = [];
+    const winnerOf = new Map();
+    const cliFates = cli === undefined ? [] : [...cli.fates];
+    const place = (slot, fate) => {
+        if (!fate.sent)
+            return fate;
+        if (winnerOf.has(fate.wire))
+            return kept('duplicate');
+        winnerOf.set(fate.wire, slot);
+        sent.push(fate.wire);
+        return fate;
+    };
+    const appendGroup = (group, origin) => {
+        const held = settingsGate !== undefined && !outsideSettingsFiles(origin);
+        const fates = held ? group.map(() => kept(settingsGate)) : judgeList(group, behavior);
+        group.forEach((r, k) => fateOfRule.set(r, place(firstSlot.get(r), fates[k])));
+    };
+    RULE_TRUST_ORDER.forEach((origin, rank) => {
+        if (origin === 'cliArg' && cli !== undefined)
+            cli.slots.forEach((s, k) => (cliFates[k] = place(s, cliFates[k])));
+        appendGroup(groups[rank], origin);
+    });
+    appendGroup(unknownOrigin, undefined);
+    const fates = raw.map((s) => {
+        const f = fateOfRule.get(s.rule);
+        if (firstSlot.get(s.rule) === s)
+            return f;
+        return f.sent || f.reason === 'duplicate' ? kept('duplicate') : f;
+    });
+    return { sent, fates: [...fates, ...cliFates], winnerOf };
+}
+const WHO = 'permissionsDeclaration';
+function ownField(obj, key, where) {
+    if (Object.hasOwn(obj, key))
+        return obj[key];
+    if (key in obj)
+        throw new TypeError(`${WHO}: ${where}${key} 只在原型链上,不是自有字段 —— 拒绝读取(请交普通对象)。`);
+    return undefined;
+}
+function ruleList(v, key) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (!Array.isArray(v))
+        throw new TypeError(`${WHO}: ${key} 必须是规则串数组或缺席 —— 收到 typeof=${typeof v}。`);
+    const out = [];
+    const n = v.length;
+    for (let i = 0; i < n; i++) {
+        if (!Object.hasOwn(v, i)) {
+            if (i in v)
+                throw new TypeError(`${WHO}: ${key}[${i}] 是空洞,而原型链上在这个下标有值 —— 拒绝读取(请交不带空洞的普通数组)。`);
+            continue;
+        }
+        const r = v[i];
+        if (typeof r === 'string')
+            out.push(r);
+    }
+    return out;
+}
+function originMap(v, key) {
+    if (v === undefined || v === null)
+        return undefined;
+    const ok = typeof v === 'object' &&
+        typeof v.get === 'function' &&
+        typeof v[Symbol.iterator] === 'function';
+    if (!ok)
+        throw new TypeError(`${WHO}: origins.${key} 必须是 Map(规则原串 → 来源)或缺席 —— 收到 typeof=${typeof v}。`);
+    const snap = new Map();
+    for (const entry of v) {
+        const [r, origin] = entry;
+        if (!snap.has(r))
+            snap.set(r, origin);
+    }
+    return snap;
+}
+const slotsOf = (list, name) => (list ?? []).map((rule, at) => ({ rule, list: name, at }));
+function assemble(input, caps) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError(`${WHO}: 入参必须是对象 —— 收到 ${input === null ? 'null' : Array.isArray(input) ? 'array' : `typeof=${typeof input}`}。`);
+    }
+    const deny = ruleList(ownField(input, 'deny', ''), 'deny');
+    const ask = ruleList(ownField(input, 'ask', ''), 'ask');
+    const allow = ruleList(ownField(input, 'allow', ''), 'allow');
+    const cliDeny = ruleList(ownField(input, 'cliDeny', ''), 'cliDeny');
+    const originsRaw = ownField(input, 'origins', '');
+    let origins = {};
+    if (originsRaw !== undefined && originsRaw !== null) {
+        if (typeof originsRaw !== 'object' || Array.isArray(originsRaw)) {
+            throw new TypeError(`${WHO}: origins 必须是 { deny?, ask?, allow? } 对象或缺席 —— 收到 typeof=${typeof originsRaw}。`);
+        }
+        const od = originMap(ownField(originsRaw, 'deny', 'origins.'), 'deny');
+        const oa = originMap(ownField(originsRaw, 'ask', 'origins.'), 'ask');
+        const ol = originMap(ownField(originsRaw, 'allow', 'origins.'), 'allow');
+        origins = { ...(od ? { deny: od } : {}), ...(oa ? { ask: oa } : {}), ...(ol ? { allow: ol } : {}) };
+    }
+    const gate = allowRulesGate(caps, ownField(input, 'settingsRead', ''));
+    const cliSlots = slotsOf(cliDeny, 'cliDeny');
+    const cli = cliDeny === undefined ? undefined : { slots: cliSlots, fates: judgeList(cliDeny, 'deny') };
+    const denySlots = slotsOf(deny, 'deny');
+    const askSlots = slotsOf(ask, 'ask');
+    const allowSlots = slotsOf(allow, 'allow');
+    const denyJ = judgeBucket(denySlots, 'deny', origins.deny, cli);
+    const askJ = judgeBucket(askSlots, 'ask', origins.ask, undefined);
+    const allowJ = gate === 'capability_off'
+        ? { sent: [], fates: allowSlots.map(() => kept('allow_capability_off')), winnerOf: new Map() }
+        : judgeBucket(allowSlots, 'allow', origins.allow, undefined, gate === 'settings_read_not_clean' ? 'settings_read_not_clean' : undefined);
+    const buckets = {};
+    if (denyJ.sent.length > 0)
+        buckets.deny = [...denyJ.sent];
+    if (askJ.sent.length > 0)
+        buckets.ask = [...askJ.sent];
+    if (allowJ.sent.length > 0)
+        buckets.allow = [...allowJ.sent];
+    const keptRows = [];
+    const rewritten = [];
+    const unchecked = [];
+    const rows = [
+        ['deny', [...denySlots, ...cliSlots], denyJ],
+        ['ask', askSlots, askJ],
+        ['allow', allowSlots, allowJ],
+    ];
+    for (const [bucket, slots, j] of rows) {
+        slots.forEach((s, k) => {
+            const f = j.fates[k];
+            if (!f.sent)
+                keptRows.push({ rule: s.rule, bucket, reason: f.reason });
+        });
+        for (const wire of j.sent) {
+            const winner = j.winnerOf.get(wire);
+            if (winner.rule !== wire)
+                rewritten.push({ from: winner.rule, to: wire, bucket });
+            const f = (winner.list === 'cliDeny' ? j.fates[denySlots.length + winner.at] : j.fates[winner.at]);
+            if (f.sent && f.unchecked && bucket !== 'allow')
+                unchecked.push({ rule: wire, bucket });
+        }
+    }
+    return { buckets, report: { kept: keptRows, rewritten, unchecked } };
+}
+export function permissionsDeclaration(input, caps) {
+    const { buckets } = assemble(input, caps);
+    return Object.keys(buckets).length > 0 ? { permissions: buckets } : {};
+}
+export function permissionsDeclarationReport(input, caps) {
+    const { buckets, report } = assemble(input, caps);
+    return { ...(Object.keys(buckets).length > 0 ? { permissions: buckets } : {}), ...report };
+}

package/dist/promptDelivery.d.ts

@@ -1,20 +1,31 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import { type SelfHealOutcome } from './adapter/activeRunSelfHeal.js';
+import type { HumanTurnDelivered } from './humanTurn.js';
 export interface PromptDeliveryRecord {
     readonly u: string;
     readonly s: 'a' | 'd';
+    readonly by?: 'frame' | 'steer_receipt';
+    readonly share?: 'full' | 'partial';
 }
 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[];
+    attempted(batchUuids: readonly string[], opts?: {
+        readonly generation?: number;
+    }): readonly PromptDeliveryRecord[];
+    deliveredByFrame(batchUuids: readonly string[] | HumanTurnDelivered, event: AgentEvent): readonly PromptDeliveryRecord[];
+    deliveredBySteerReceipt(batchUuids: readonly string[] | HumanTurnDelivered, outcome: SelfHealOutcome): readonly PromptDeliveryRecord[];
     isAttempted(uuid: string): boolean;
     isDelivered(uuid: string): boolean;
     knownUndelivered(uuid: string): boolean;
+    deliveryShareOf(uuid: string): 'full' | 'partial' | undefined;
+    undeliveredInGeneration(generation: number): readonly string[];
+    droppedKeyCount(): number;
     batchOf(uuid: string): readonly string[] | undefined;
     toRecords(): readonly PromptDeliveryRecord[];
     fromRecords(records: readonly PromptDeliveryRecord[]): readonly PromptDeliveryRecord[];
+    knownUndeliveredMessage(message: object | null | undefined): boolean;
+    withoutUndelivered<T>(messages: readonly T[]): T[];
 }
+export declare function frameProvesDelivery(event: object | null | undefined): boolean;
 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[];
+export declare function promptKnownUndelivered(ledger: Pick<PromptDeliveryLedger, 'knownUndelivered'>, message: object | null | undefined): boolean;
+export declare function withoutUndeliveredPrompts<T>(ledger: Pick<PromptDeliveryLedger, 'knownUndelivered'>, messages: readonly T[]): T[];

package/dist/promptDelivery.js

@@ -1,8 +1,43 @@
 import { activeRunBusySignal } from './adapter/runStream.js';
 import { selfHealSubmissionDisposition } from './adapter/activeRunSelfHeal.js';
 const uuidOk = (u) => typeof u === 'string' && u.length > 0;
+function isArraySafe(v) {
+    try {
+        return Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+const generationOk = (g) => typeof g === 'number' && Number.isSafeInteger(g) && g >= 0;
+function generationOpt(opts) {
+    if (typeof opts !== 'object' || opts === null)
+        return undefined;
+    try {
+        const g = opts.generation;
+        return generationOk(g) ? g : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const levelOf = (rec) => !Object.hasOwn(rec, 'by') ? 1 : Object.hasOwn(rec, 'share') && rec.share === 'partial' ? 2 : 3;
+function deliveredByWord(v) {
+    const words = { frame: true, steer_receipt: true };
+    return typeof v === 'string' && Object.hasOwn(words, v) ? v : undefined;
+}
+function deliveredShareWord(v) {
+    const words = { full: true, partial: true };
+    return typeof v === 'string' && Object.hasOwn(words, v) ? v : undefined;
+}
+function ownExtension(rec, key) {
+    const desc = Object.getOwnPropertyDescriptor(rec, key);
+    if (desc === undefined)
+        return key in rec ? { kind: 'unreadable' } : { kind: 'absent' };
+    return 'value' in desc ? { kind: 'value', value: desc.value } : { kind: 'unreadable' };
+}
 function cleanBatch(batch) {
-    if (!Array.isArray(batch))
+    if (!isArraySafe(batch))
         return [];
     const out = [];
     const seen = new Set();
@@ -19,23 +54,81 @@ function cleanBatch(batch) {
     }
     return out;
 }
-function readRecord(rec) {
-    if (typeof rec !== 'object' || rec === null || Array.isArray(rec))
+function readRecord(raw) {
+    if (typeof raw !== 'object' || raw === null)
         return undefined;
+    let u;
+    let s;
     try {
-        const u = rec.u;
-        const s = rec.s;
-        return uuidOk(u) && (s === 'a' || s === 'd') ? { u, s } : undefined;
+        if (Array.isArray(raw))
+            return undefined;
+        u = raw.u;
+        s = raw.s;
     }
     catch {
         return undefined;
     }
+    if (!uuidOk(u) || (s !== 'a' && s !== 'd'))
+        return undefined;
+    const legacy = { u, s };
+    try {
+        let rec = legacy;
+        if (s === 'd') {
+            const byExt = ownExtension(raw, 'by');
+            const shareExt = ownExtension(raw, 'share');
+            const by = byExt.kind === 'value' ? deliveredByWord(byExt.value) : undefined;
+            const share = shareExt.kind === 'value' ? deliveredShareWord(shareExt.value) : undefined;
+            if (by !== undefined && (shareExt.kind === 'absent' || share !== undefined))
+                rec = share === undefined ? { u, s, by } : { u, s, by, share };
+        }
+        const dropped = Object.keys(raw).filter((k) => !Object.hasOwn(rec, k)).length;
+        return { rec, dropped };
+    }
+    catch {
+        return { rec: legacy, dropped: 0 };
+    }
+}
+function readTierStrict(holder, key) {
+    try {
+        if (!Object.hasOwn(holder, key))
+            return [];
+        const raw = holder[key];
+        if (!Array.isArray(raw))
+            return null;
+        const out = [];
+        const seen = new Set();
+        for (const u of raw) {
+            if (!uuidOk(u) || seen.has(u))
+                continue;
+            seen.add(u);
+            out.push(u);
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+function batchTiers(batch) {
+    const none = { full: [], partial: [] };
+    if (isArraySafe(batch))
+        return { full: cleanBatch(batch), partial: [] };
+    if (typeof batch !== 'object' || batch === null)
+        return none;
+    const full = readTierStrict(batch, 'full');
+    const partial = readTierStrict(batch, 'partial');
+    if (full === null || partial === null)
+        return none;
+    const inFull = new Set(full);
+    return { full, partial: partial.filter((u) => !inFull.has(u)) };
 }
 const PRE_RUN_FRAME_TYPES = new Set(['meta', 'approval_request', 'approval_revoke']);
-function frameProvesDelivery(event) {
-    if (typeof event !== 'object' || event === null || Array.isArray(event))
+export function frameProvesDelivery(event) {
+    if (typeof event !== 'object' || event === null)
         return false;
     try {
+        if (Array.isArray(event))
+            return false;
         const type = event.type;
         if (typeof type !== 'string' || type.length === 0 || PRE_RUN_FRAME_TYPES.has(type))
             return false;
@@ -54,9 +147,11 @@ function frameProvesDelivery(event) {
     }
 }
 function outcomeProvesDelivery(outcome) {
-    if (typeof outcome !== 'object' || outcome === null || Array.isArray(outcome))
+    if (typeof outcome !== 'object' || outcome === null)
         return false;
     try {
+        if (Array.isArray(outcome))
+            return false;
         return selfHealSubmissionDisposition(outcome) === 'handed-off';
     }
     catch {
@@ -65,48 +160,88 @@ function outcomeProvesDelivery(outcome) {
 }
 export function createPromptDeliveryLedger() {
     const attemptedSet = new Set();
-    const deliveredSet = new Set();
+    const deliveredLevel = new Map();
     const batchOfMap = new Map();
+    const generationOf = new Map();
     const log = [];
-    const add = (u, s, into) => {
-        const set = s === 'a' ? attemptedSet : deliveredSet;
-        if (set.has(u))
+    let droppedKeys = 0;
+    const keep = (rec, into) => {
+        const frozen = Object.freeze(rec);
+        log.push(frozen);
+        into.push(frozen);
+    };
+    const add = (rec, into) => {
+        if (rec.s === 'a') {
+            if (attemptedSet.has(rec.u))
+                return;
+            attemptedSet.add(rec.u);
+            keep(rec, into);
             return;
-        set.add(u);
-        const rec = Object.freeze({ u, s });
-        log.push(rec);
-        into.push(rec);
+        }
+        const level = levelOf(rec);
+        if ((deliveredLevel.get(rec.u) ?? 0) >= level)
+            return;
+        deliveredLevel.set(rec.u, level);
+        keep(rec, into);
     };
-    const markDelivered = (batchUuids) => {
+    const markDelivered = (batch, by) => {
         const added = [];
-        for (const u of cleanBatch(batchUuids))
-            add(u, 'd', added);
+        const { full, partial } = batchTiers(batch);
+        for (const u of full)
+            add({ u, s: 'd', by }, added);
+        for (const u of partial)
+            add({ u, s: 'd', by, share: 'partial' }, added);
         return Object.freeze(added);
     };
-    return Object.freeze({
-        attempted(batchUuids) {
+    const levelNow = (uuid) => (uuidOk(uuid) ? (deliveredLevel.get(uuid) ?? 0) : 0);
+    const knownUndeliveredUuid = (uuid) => uuidOk(uuid) && attemptedSet.has(uuid) && !deliveredLevel.has(uuid);
+    const ledger = Object.freeze({
+        attempted(batchUuids, opts) {
+            const generation = generationOpt(opts);
             const batch = Object.freeze(cleanBatch(batchUuids));
             const added = [];
             for (const u of batch) {
                 batchOfMap.set(u, batch);
-                add(u, 'a', added);
+                if (generation !== undefined) {
+                    generationOf.delete(u);
+                    generationOf.set(u, generation);
+                }
+                add({ u, s: 'a' }, added);
             }
             return Object.freeze(added);
         },
         deliveredByFrame(batchUuids, event) {
-            return frameProvesDelivery(event) ? markDelivered(batchUuids) : Object.freeze([]);
+            return frameProvesDelivery(event) ? markDelivered(batchUuids, 'frame') : Object.freeze([]);
         },
         deliveredBySteerReceipt(batchUuids, outcome) {
-            return outcomeProvesDelivery(outcome) ? markDelivered(batchUuids) : Object.freeze([]);
+            return outcomeProvesDelivery(outcome) ? markDelivered(batchUuids, 'steer_receipt') : 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),
+        isDelivered: (uuid) => levelNow(uuid) >= 2,
+        knownUndelivered: (uuid) => knownUndeliveredUuid(uuid),
+        deliveryShareOf: (uuid) => {
+            const level = levelNow(uuid);
+            return level === 3 ? 'full' : level === 2 ? 'partial' : undefined;
+        },
+        undeliveredInGeneration(generation) {
+            const out = [];
+            if (!generationOk(generation))
+                return Object.freeze(out);
+            for (const [u, g] of generationOf) {
+                if (g !== generation)
+                    continue;
+                generationOf.delete(u);
+                if (knownUndeliveredUuid(u))
+                    out.push(u);
+            }
+            return Object.freeze(out);
+        },
+        droppedKeyCount: () => droppedKeys,
         batchOf: (uuid) => (uuidOk(uuid) ? batchOfMap.get(uuid) : undefined),
         toRecords: () => Object.freeze([...log]),
         fromRecords(records) {
             const added = [];
-            if (!Array.isArray(records))
+            if (!isArraySafe(records))
                 return Object.freeze(added);
             let list;
             try {
@@ -116,13 +251,18 @@ export function createPromptDeliveryLedger() {
                 return Object.freeze(added);
             }
             for (const raw of list) {
-                const rec = readRecord(raw);
-                if (rec !== undefined)
-                    add(rec.u, rec.s, added);
+                const read = readRecord(raw);
+                if (read === undefined)
+                    continue;
+                droppedKeys += read.dropped;
+                add(read.rec, added);
             }
             return Object.freeze(added);
         },
+        knownUndeliveredMessage: (message) => promptKnownUndelivered(ledger, message),
+        withoutUndelivered: (messages) => withoutUndeliveredPrompts(ledger, messages),
     });
+    return ledger;
 }
 function uuidOfMessage(m) {
     if (typeof m !== 'object' || m === null)
@@ -147,7 +287,7 @@ export function promptKnownUndelivered(ledger, message) {
 }
 export function withoutUndeliveredPrompts(ledger, messages) {
     assertLedger(ledger, 'withoutUndeliveredPrompts');
-    if (!Array.isArray(messages))
+    if (!isArraySafe(messages))
         return [];
     return messages.filter((m) => !promptKnownUndelivered(ledger, m));
 }

package/dist/providerRejection.d.ts

@@ -1,6 +1,8 @@
 import { type RunTerminalFailureDetail } from './runTerminal.js';
+import { type ToolHistoryErrorCarrier } from './toolHistoryMismatch.js';
 export interface ProviderRejectionResend {
     resend: 'edit_and_resend' | 'not_by_editing';
     text: string;
 }
-export declare function providerRejectionResend(detail: RunTerminalFailureDetail | null | undefined): ProviderRejectionResend | undefined;
+export declare function readProviderRejectionResendKey(v: object | null | undefined): ProviderRejectionResend | undefined;
+export declare function providerRejectionResend(detail: RunTerminalFailureDetail | null | undefined, carrier?: ToolHistoryErrorCarrier | null): ProviderRejectionResend | undefined;