@sema-agent/client-core 0.112.1 → 0.113.0

package/dist/settingsHooksSalvage.js

@@ -2,7 +2,7 @@ import { requestCoordinateText } from './requestCoordinate.js';
 import { displayUntrusted } from './displayUntrusted.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { appendOwnElement } from './ownKey.js';
-import { SETTINGS_CLASSIFY_HOOKS_CONFIG, } from './generated/settingsSchemaFns.js';
+import { SETTINGS_CLASSIFY_HOOKS_CONFIG, SETTINGS_HOOK_EVENTS, } from './generated/settingsSchemaFns.js';
 const _tuplePins = [true, true, true, true, true, true];
 void _tuplePins;
 const _classifierPins = [true, true, true, true, true, true];
@@ -113,13 +113,13 @@ export function salvageSettingsHooksEntries(doc) {
     });
 }
 const READER_GROUP_WIRE_KEYS = ['source'];
-const READER_COMMAND_WIRE_KEYS = ['plugin', 'args'];
-function unreadOf(raw, carried, wireKeys, notRead) {
+const READER_COMMAND_WIRE_KEYS = ['plugin'];
+function unreadOf(raw, carried, wireKeys, reads) {
     const out = [];
     for (const k of Object.keys(raw)) {
         if (own(raw, k) === undefined || wireKeys.includes(k))
             continue;
-        if (Object.hasOwn(carried, k) && !notRead.includes(k))
+        if (reads(k, Object.hasOwn(carried, k)))
             continue;
         appendOwnElement(out, k);
     }
@@ -136,7 +136,7 @@ function carriedGroupOf(event, group) {
 export function hooksGroupUnreadKeys(event, group) {
     const raw = group;
     const carried = carriedGroupOf(event, { ...raw, hooks: [] });
-    return carried === undefined ? undefined : unreadOf(raw, carried, READER_GROUP_WIRE_KEYS, []);
+    return carried === undefined ? undefined : unreadOf(raw, carried, READER_GROUP_WIRE_KEYS, (_key, carriedByCopy) => carriedByCopy);
 }
 export function hooksGroupAuthoredSource(group) {
     try {
@@ -153,14 +153,27 @@ export function hooksGroupAuthoredSource(group) {
         return 'unreadable';
     }
 }
-export function hooksEntryUnreadKeys(event, entry, notRead) {
-    const raw = entry;
-    const g = carriedGroupOf(event, { hooks: [raw] });
+export function hooksEntryContractView(event, entry) {
+    const g = carriedGroupOf(event, { hooks: [entry] });
     const entries = g === undefined ? undefined : own(g, 'hooks');
     const carried = Array.isArray(entries) ? entries[0] : undefined;
+    return isRecord(carried) ? carried : undefined;
+}
+export function hooksEntryUnreadKeys(event, entry, reader) {
+    const raw = entry;
+    const carried = hooksEntryContractView(event, raw);
     if (!isRecord(carried))
         return undefined;
-    return unreadOf(raw, carried, own(carried, 'type') === 'command' ? READER_COMMAND_WIRE_KEYS : [], notRead);
+    const type = own(carried, 'type');
+    const entryType = typeof type === 'string' ? type : '';
+    return unreadOf(raw, carried, entryType === 'command' ? READER_COMMAND_WIRE_KEYS : [], (key, carriedByCopy) => reader.reads(entryType, key, carriedByCopy));
+}
+const GUARD_HOOK_EVENTS = new Set(SETTINGS_HOOK_EVENTS.filter((event) => {
+    const r = SETTINGS_CLASSIFY_HOOKS_CONFIG({ hooks: { [event]: 1 } });
+    return r.outcome === 'rejected' && r.rejections.some((x) => x.code === 'guard-event-not-array');
+}));
+export function isGuardHookEvent(event) {
+    return typeof event === 'string' && GUARD_HOOK_EVENTS.has(event);
 }
 export function hooksKeyCoordinateText(path) {
     return requestCoordinateText('settings', path, (seg) => labelOf(seg));

package/dist/skillOverrideChain.d.ts

@@ -47,6 +47,7 @@ export interface SkillOverrideLock {
     readonly source: SkillOverrideLockSource;
     readonly value: SkillOverrideState;
 }
+export declare const LIST_BUDGET = 4096;
 export interface ShapedSkillSubject {
     readonly name: string;
     readonly origin: SkillOrigin;
@@ -75,6 +76,8 @@ export declare function secondaryNamesOf(s: ShapedSkillSubject): string[];
 export declare function effectiveOfShaped(L: ShapedSkillLayers, s: ShapedSkillSubject): SkillOverrideEffective;
 export declare function lockOfShaped(L: ShapedSkillLayers, s: ShapedSkillSubject): SkillOverrideLock | undefined;
 export declare function skillOverrideEffectiveOf(layers: SkillOverrideLayers, skill: SkillOverrideSubject): SkillOverrideEffective | undefined;
+export type SkillOverrideTightening = 'none' | 'plain' | 'managed';
+export declare function skillOverrideTighteningOf(layers: SkillOverrideLayers): SkillOverrideTightening;
 export declare function skillOverrideLockOf(layers: SkillOverrideLayers, skill: SkillOverrideSubject): SkillOverrideLock | undefined;
 export declare function ownValueIn(ov: object | undefined, s: ShapedSkillSubject): SkillOverrideState | undefined;
 export declare function stateAt(ov: object | undefined, key: string | undefined): SkillOverrideState | undefined;

package/dist/skillOverrideChain.js

@@ -7,9 +7,8 @@ export const SKILL_OVERRIDE_DECIDERS = Object.freeze([...SKILL_OVERRIDE_LAYERS,
 export const SKILL_OVERRIDE_LOCK_SOURCES = Object.freeze(['policy', 'flag', 'plugin', 'skill-author', 'reserved-name']);
 const MANAGED = ['policySettings', 'flagSettings'];
 const PLAIN = ['localSettings', 'projectSettings', 'userSettings'];
-const MERGED = ['policySettings', 'flagSettings', 'localSettings', 'projectSettings', 'userSettings'];
 const RANK = { on: 0, 'name-only': 1, 'user-invocable-only': 2, off: 3 };
-const LIST_BUDGET = 4096;
+export const LIST_BUDGET = 4096;
 function own(v, key) {
     if (typeof v !== 'object' || v === null)
         return undefined;
@@ -91,7 +90,7 @@ export function shapeSkillLayers(v) {
     const session = own(v, 'session');
     const enabled = (layer) => layer === 'policySettings' || layer === 'flagSettings' || !disabled.has(layer);
     let fromSettings = false;
-    for (const l of MERGED) {
+    for (const l of SKILL_OVERRIDE_LAYERS) {
         if (!enabled(l))
             continue;
         const b = own(own(v, l), 'disableBundledSkills');
@@ -151,7 +150,7 @@ function reservedTighten(ov, s, by) {
     return r === undefined || r.value === 'on' ? undefined : r;
 }
 function mergedAt(L, key) {
-    for (const l of MERGED) {
+    for (const l of SKILL_OVERRIDE_LAYERS) {
         if (!L.enabled(l))
             continue;
         const h = hitAt(L.docs[l], key, l);
@@ -324,6 +323,34 @@ export function skillOverrideEffectiveOf(layers, skill) {
         return undefined;
     }
 }
+function recordTightens(rec) {
+    if (rec === undefined)
+        return false;
+    const keys = Reflect.ownKeys(rec);
+    if (keys.length > LIST_BUDGET)
+        return true;
+    for (const k of keys) {
+        if (typeof k !== 'string')
+            continue;
+        const v = own(rec, k);
+        if (isState(v) && v !== 'on')
+            return true;
+    }
+    return false;
+}
+export function skillOverrideTighteningOf(layers) {
+    try {
+        const L = shapeSkillLayers(layers);
+        if (MANAGED.some((l) => recordTightens(L.docs[l])))
+            return 'managed';
+        if (PLAIN.some((l) => L.enabled(l) && recordTightens(L.docs[l])) || recordTightens(L.session))
+            return 'plain';
+        return 'none';
+    }
+    catch {
+        return 'managed';
+    }
+}
 export function skillOverrideLockOf(layers, skill) {
     try {
         const s = shapeSkillSubject(skill);

package/dist/skillsWireCaps.d.ts

@@ -1,6 +1,6 @@
 import type { SkillSpec } from '@sema-agent/sdk';
 import { type SkillToolListsReading } from './skillToolListsCapability.js';
-import { type SkillOverrideLayers, type SkillOverrideSubject } from './skillOverrideChain.js';
+import { type SkillOrigin, type SkillOverrideLayers, type SkillOverrideSubject } from './skillOverrideChain.js';
 export interface SkillCmdLike {
     type?: string;
     name?: string;
@@ -23,6 +23,17 @@ export interface SkillSpecsOptions {
     skillToolLists?: SkillToolListsReading;
     skillOverrides?: SkillOverrideLayers;
 }
+export type SkillCmdWithSubject = SkillCmdLike & {
+    skillOverrideSubject: SkillOverrideSubject;
+};
+export declare const SKILL_WITHHELD_REASONS: readonly ["identity_unreadable"];
+export type SkillWithheldReason = (typeof SKILL_WITHHELD_REASONS)[number];
+export interface SkillWithheldRow {
+    readonly name: string;
+    readonly origin: SkillOrigin;
+    readonly reason: SkillWithheldReason;
+}
+export declare function skillCommandsWithheldOf(cmds: readonly SkillCmdLike[], opts?: SkillSpecsOptions): readonly SkillWithheldRow[];
 export declare function skillBaseDirOf(skillRoot: string | undefined, platform?: 'posix' | 'win32'): string | undefined;
 export type SkillToolListKey = 'allowedTools' | 'disallowedTools';
 export type SkillToolListsVerdict = {
@@ -38,4 +49,7 @@ export type SkillToolListsVerdict = {
     readonly detail: string;
 };
 export declare function skillToolListsVerdict(source: object, reading: SkillToolListsReading | undefined): SkillToolListsVerdict;
-export declare function skillCommandsToSpecs(cmds: SkillCmdLike[], resolveBody: (cmd: SkillCmdLike) => string | null, opts?: SkillSpecsOptions): SkillSpecOnWire[];
+export declare function skillCommandsToSpecs(cmds: SkillCmdLike[], resolveBody: (cmd: SkillCmdLike) => string | null, opts?: SkillSpecsOptions & {
+    skillOverrides?: undefined;
+}): SkillSpecOnWire[];
+export declare function skillCommandsToSpecs(cmds: SkillCmdWithSubject[], resolveBody: (cmd: SkillCmdWithSubject) => string | null, opts: SkillSpecsOptions): SkillSpecOnWire[];

package/dist/skillsWireCaps.js

@@ -1,7 +1,8 @@
 import { skillToolListsAvailable } from './skillToolListsCapability.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { appendOwnElement } from './ownKey.js';
-import { skillOverrideEffectiveOf } from './skillOverrideChain.js';
+import { pathShapeOf, PATH_LENGTH_LIMIT } from './pathShape.js';
+import { skillOverrideEffectiveOf, skillOverrideTighteningOf, } from './skillOverrideChain.js';
 export function toCappedSpec(name, description, whenToUse, body) {
     const n = name.trim();
     const c = body.trim();
@@ -13,29 +14,54 @@ export function toCappedSpec(name, description, whenToUse, body) {
     return { name: n, description: desc, content: c };
 }
 const ORIGIN_OF_SOURCE = { plugin: 'plugin', builtin: 'builtin', bundled: 'bundled', mcp: 'mcp' };
+function originOfCommand(cmd) {
+    const src = typeof cmd.source === 'string' && Object.hasOwn(ORIGIN_OF_SOURCE, cmd.source) ? ORIGIN_OF_SOURCE[cmd.source] : undefined;
+    return src ?? 'skills';
+}
 function overrideSubjectOf(cmd, name) {
     if (cmd.skillOverrideSubject !== undefined)
         return cmd.skillOverrideSubject;
-    const src = typeof cmd.source === 'string' && Object.hasOwn(ORIGIN_OF_SOURCE, cmd.source) ? ORIGIN_OF_SOURCE[cmd.source] : undefined;
-    return { name, origin: src ?? 'skills' };
+    return { name, origin: originOfCommand(cmd) };
+}
+export const SKILL_WITHHELD_REASONS = Object.freeze(['identity_unreadable']);
+function identityNeedsSubject(cmd, name) {
+    if (name.includes(':'))
+        return true;
+    const s = cmd.source;
+    return s === 'mcp' || s === 'plugin' || s === 'commands';
+}
+function readOverrideIdentity(cmd, name, layers, tightening) {
+    if (cmd.skillOverrideSubject === undefined) {
+        if (tightening === 'managed' || (tightening === 'plain' && identityNeedsSubject(cmd, name)))
+            return { kind: 'withheld', reason: 'identity_unreadable' };
+    }
+    const effective = skillOverrideEffectiveOf(layers, overrideSubjectOf(cmd, name));
+    return effective === undefined ? { kind: 'withheld', reason: 'identity_unreadable' } : { kind: 'read', effective };
+}
+export function skillCommandsWithheldOf(cmds, opts) {
+    const rows = [];
+    const layers = opts?.skillOverrides;
+    if (layers === undefined)
+        return Object.freeze(rows);
+    const tightening = skillOverrideTighteningOf(layers);
+    for (const cmd of cmds) {
+        if (cmd.type !== 'prompt' || cmd.disableModelInvocation)
+            continue;
+        const name = (cmd.name ?? '').trim();
+        const read = readOverrideIdentity(cmd, name, layers, tightening);
+        if (read.kind === 'withheld')
+            appendOwnElement(rows, Object.freeze({ name, origin: originOfCommand(cmd), reason: read.reason }));
+    }
+    return Object.freeze(rows);
 }
 export function skillBaseDirOf(skillRoot, platform = 'posix') {
-    if (skillRoot === undefined || skillRoot.length === 0 || skillRoot.length > 4096)
-        return undefined;
-    if (skillRoot.includes('\u0000'))
-        return undefined;
-    if (platform === 'win32') {
-        if (!(/^[A-Za-z]:[\\/]/.test(skillRoot) || /^\\\\[^\\/]+[\\/][^\\/]+/.test(skillRoot)))
-            return undefined;
-        if (skillRoot.split(/[\\/]/).includes('..'))
-            return undefined;
-        return skillRoot;
-    }
-    if (!skillRoot.startsWith('/'))
+    if (skillRoot === undefined || skillRoot.length > PATH_LENGTH_LIMIT)
         return undefined;
-    if (skillRoot.split(/[\\/]/).includes('..'))
+    const shape = pathShapeOf(skillRoot);
+    if (shape === undefined || shape.hasParentSegment)
         return undefined;
-    return skillRoot;
+    const rooted = platform === 'win32' ? shape.kind === 'drive' || shape.kind === 'unc' : shape.kind === 'posix';
+    return rooted ? skillRoot : undefined;
 }
 const SKILL_TOOL_LIST_READ_BUDGET = 100_000;
 function readSkillToolList(key, source) {
@@ -123,6 +149,7 @@ export function skillToolListsVerdict(source, reading) {
 }
 export function skillCommandsToSpecs(cmds, resolveBody, opts) {
     const specs = [];
+    const tightening = opts?.skillOverrides !== undefined ? skillOverrideTighteningOf(opts.skillOverrides) : 'none';
     const seen = new Set();
     const reading = opts?.skillToolLists;
     for (const cmd of cmds) {
@@ -130,10 +157,10 @@ export function skillCommandsToSpecs(cmds, resolveBody, opts) {
             continue;
         let nameOnly = false;
         if (opts?.skillOverrides !== undefined) {
-            const eff = skillOverrideEffectiveOf(opts.skillOverrides, overrideSubjectOf(cmd, (cmd.name ?? '').trim()));
-            if (eff === undefined || eff.value === 'off' || eff.value === 'user-invocable-only')
+            const read = readOverrideIdentity(cmd, (cmd.name ?? '').trim(), opts.skillOverrides, tightening);
+            if (read.kind === 'withheld' || read.effective.value === 'off' || read.effective.value === 'user-invocable-only')
                 continue;
-            nameOnly = eff.value === 'name-only';
+            nameOnly = read.effective.value === 'name-only';
         }
         const body = resolveBody(cmd);
         if (!body)

package/dist/subagent/agentStateDetail.js

@@ -12,6 +12,16 @@ function own(v, key) {
 }
 const finite = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
 const word = (v) => (typeof v === 'string' && v.trim() !== '' ? displayUntrusted(v, { max: 64 }) : undefined);
+function ownSlotAbsent(v, key) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return true;
+    try {
+        return Object.getOwnPropertyDescriptor(v, key) === undefined;
+    }
+    catch {
+        return false;
+    }
+}
 function span(ms) {
     const s = Math.floor(ms / 1000);
     if (s < 60)
@@ -29,13 +39,27 @@ export function subagentStateDetail(carrier) {
     const readAt = finite(own(st, 'readAt'));
     const last = finite(own(st, 'lastActivityAt'));
     const activity = readAt !== undefined && last !== undefined && last <= readAt ? `last activity ${span(readAt - last)} ago` : 'last activity unknown';
-    const approval = own(st, 'approval');
-    const approvalState = word(own(approval, 'state'));
-    let approvalPart = '';
-    if (approvalState !== undefined) {
-        const deadline = finite(own(approval, 'deadline'));
-        const when = deadline === undefined || readAt === undefined ? '' : deadline > readAt ? ` (deadline in ${span(deadline - readAt)})` : ' (deadline passed)';
-        approvalPart = ` · approval ${approvalState}${when}`;
+    const deadlineClause = (holder) => {
+        const deadline = finite(own(holder, 'deadline'));
+        return deadline === undefined || readAt === undefined ? '' : deadline > readAt ? ` (deadline in ${span(deadline - readAt)})` : ' (deadline passed)';
+    };
+    let parkPart = '';
+    if (!ownSlotAbsent(st, 'park')) {
+        const park = own(st, 'park');
+        const parkState = word(own(park, 'state'));
+        if (parkState !== undefined) {
+            const gate = own(park, 'gate');
+            const gateKind = word(own(gate, 'kind'));
+            const limitReason = gateKind === 'resource_limit' ? word(own(gate, 'reason')) : undefined;
+            const on = gateKind === undefined ? '' : ` on ${gateKind}${limitReason !== undefined ? `: ${limitReason}` : ''}`;
+            parkPart = ` · park ${parkState}${on}${deadlineClause(park)}`;
+        }
+    }
+    else {
+        const approval = own(st, 'approval');
+        const approvalState = word(own(approval, 'state'));
+        if (approvalState !== undefined)
+            parkPart = ` · approval ${approvalState}${deadlineClause(approval)}`;
     }
-    return `Subagent state: ${status} · ${activity}${approvalPart}`;
+    return `Subagent state: ${status} · ${activity}${parkPart}`;
 }

package/dist/subagent/engineCompactWire.js

@@ -12,10 +12,16 @@ function usableCompactClient(client) {
     return clientHasVerbs(client, [['capabilities'], ['runs', 'compact']]);
 }
 const COMPACT_PROBE_SETTLE_MS = 5000;
-const pendingCompactKeys = new Set();
-const pendingCompactSinks = new Map();
+const pendingCompactRequests = new Map();
+function armCompactRequests(sessionKey, requests) {
+    const queued = pendingCompactRequests.get(sessionKey);
+    if (queued === undefined)
+        pendingCompactRequests.set(sessionKey, [...requests]);
+    else
+        queued.push(...requests);
+}
 export function isEngineCompactPending(sessionKey = DEFAULT_SESSION_KEY) {
-    return pendingCompactKeys.has(sessionKey);
+    return pendingCompactRequests.has(sessionKey);
 }
 function probeManualCompactCapability(wire) {
     const base = wire.kind === 'injected' ? wire.capsBaseUrl : wire.target.baseUrl;
@@ -32,8 +38,7 @@ function probeManualCompactCapability(wire) {
     kickEngineCapsProbe(base, () => client.capabilities());
 }
 export function __resetEngineCompactArmForTests() {
-    pendingCompactKeys.clear();
-    pendingCompactSinks.clear();
+    pendingCompactRequests.clear();
 }
 function deferFire(ms, fn, why, sessionKey) {
     const timers = hostTimersFor(sessionKey);
@@ -73,13 +78,23 @@ function emitCompactOutcome(sink, outcome) {
 function callSinkIsolated(sink, outcome) {
     invokeHostCallbackIsolated('engineCompactWire: onSettled sink', () => sink(outcome));
 }
-function fanOutCompactSinks(sinks) {
-    if (sinks === undefined || sinks.length === 0)
-        return undefined;
-    return (outcome) => {
-        for (const s of sinks)
-            callSinkIsolated(s, outcome);
-    };
+function settleCompactRequests(requests, outcome) {
+    for (const r of requests)
+        emitCompactOutcome(r.sink, outcome);
+}
+function settleNotRunning(sessionKey, requests, outcome) {
+    const renewed = [];
+    for (const r of requests) {
+        if (r.continued)
+            emitCompactOutcome(r.sink, outcome);
+        else
+            renewed.push({ sink: r.sink, continued: true });
+    }
+    if (renewed.length > 0) {
+        armCompactRequests(sessionKey, renewed);
+        hostLog('debug', `engineCompactWire: 409 compact.not_running —— ${renewed.length} 只请求记回本槽待发(下一条 run 续一次)`);
+    }
+    surfaceCompactNotRunning(sessionKey, renewed.length > 0 ? 'will_retry' : 'final');
 }
 function compactFailureOutcomeOf(e) {
     const shape = wireFailureShapeOf(e);
@@ -98,10 +113,12 @@ function compactFailureOutcomeOf(e) {
         return { kind: 'failed', detail: noAnswer, unconfirmed: true };
     return { kind: 'failed', detail: wireFailureTextsOf(e).reason };
 }
-async function postCompact(shot, sink, retriesLeft = 1) {
+const COMPACT_404_RETRIES = 5;
+const COMPACT_404_FIRST_RETRY_MS = 100;
+async function postCompact(shot, requests, retriesUsed = 0) {
     const client = shot.client();
     if (!client) {
-        emitCompactOutcome(sink, { kind: 'offline' });
+        settleCompactRequests(requests, { kind: 'offline' });
         return;
     }
     const taskId = shot.taskId;
@@ -109,7 +126,7 @@ async function postCompact(shot, sink, retriesLeft = 1) {
         const fire = (signal) => client.runs.compact(taskId, { ...(shot.session !== undefined ? { session: shot.session } : {}), ...(signal ? { signal } : {}) });
         const ack = shot.injected ? await settleInjected(INJECTED_WIRE_SETTLE_MS, undefined, fire) : await fire(undefined);
         hostLog('debug', `engineCompactWire: POST compact ${taskId} → ok${ack?.status ? ` (${ack.status})` : ''}`);
-        emitCompactOutcome(sink, { kind: 'accepted' });
+        settleCompactRequests(requests, { kind: 'accepted' });
     }
     catch (e) {
         const outcome = compactFailureOutcomeOf(e);
@@ -119,13 +136,16 @@ async function postCompact(shot, sink, retriesLeft = 1) {
         else {
             hostLog('debug', `engineCompactWire: compact fire failed (best-effort): ${wireFailureTextsOf(e).log}`);
         }
-        if (outcome.kind === 'refused' && outcome.status === 404 && retriesLeft > 0) {
-            if (deferFire(2000, () => void postCompact(shot, sink, retriesLeft - 1), '404 单次重试', shot.sessionKey))
+        if (outcome.kind === 'refused' && outcome.status === 404 && retriesUsed < COMPACT_404_RETRIES) {
+            const waitMs = COMPACT_404_FIRST_RETRY_MS * 2 ** retriesUsed;
+            if (deferFire(waitMs, () => void postCompact(shot, requests, retriesUsed + 1), '404 短梯重试', shot.sessionKey))
                 return;
         }
-        if (outcome.kind === 'refused' && outcome.errorCode === COMPACT_NOT_RUNNING)
-            surfaceCompactNotRunning(shot.sessionKey);
-        emitCompactOutcome(sink, outcome);
+        if (outcome.kind === 'refused' && outcome.errorCode === COMPACT_NOT_RUNNING) {
+            settleNotRunning(shot.sessionKey, requests, outcome);
+            return;
+        }
+        settleCompactRequests(requests, outcome);
     }
 }
 export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY, opts) {
@@ -141,37 +161,29 @@ export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY, opts) {
     const taskId = activeEngineRunIdFor(sessionKey);
     const rawSink = opts?.onSettled;
     const sink = typeof rawSink === 'function' ? rawSink : undefined;
+    const request = { sink, continued: false };
     if (taskId) {
         const shot = freezeCompactShot(taskId, sessionKey, wire);
         if (shot !== null)
-            void postCompact(shot, sink);
+            void postCompact(shot, [request]);
         else
             emitCompactOutcome(sink, { kind: 'offline' });
         return 'fired';
     }
-    pendingCompactKeys.add(sessionKey);
-    if (sink !== undefined) {
-        const sinks = pendingCompactSinks.get(sessionKey);
-        if (sinks === undefined)
-            pendingCompactSinks.set(sessionKey, [sink]);
-        else
-            sinks.push(sink);
-    }
+    armCompactRequests(sessionKey, [request]);
     return 'armed';
 }
-const BOUND_FIRE_DELAY_MS = 1500;
 export function onEngineTaskBound(taskId, sessionKey = DEFAULT_SESSION_KEY, opts) {
     const wire = engineWireFor(opts?.wire, sessionKey, usableCompactClient);
     if (wire.kind !== 'no-target' && wire.kind !== 'injected-unusable')
         probeManualCompactCapability(wire);
-    if (!pendingCompactKeys.has(sessionKey))
+    const requests = pendingCompactRequests.get(sessionKey);
+    if (requests === undefined)
         return;
     const shot = freezeCompactShot(taskId, sessionKey, wire);
     if (shot === null)
         return;
-    const sink = fanOutCompactSinks(pendingCompactSinks.get(sessionKey));
-    if (deferFire(BOUND_FIRE_DELAY_MS, () => void postCompact(shot, sink), 'bind 后发射', sessionKey)) {
-        pendingCompactKeys.delete(sessionKey);
-        pendingCompactSinks.delete(sessionKey);
-    }
+    const batch = [...requests];
+    if (deferFire(0, () => void postCompact(shot, batch), 'bind 后发射', sessionKey))
+        pendingCompactRequests.delete(sessionKey);
 }

package/dist/subagent/engineDelegatedPrompt.d.ts

@@ -12,13 +12,14 @@ export declare function delegatedPromptText(content: unknown): string | undefine
 export declare function pickDelegatedPrompt(messages: readonly unknown[]): string | undefined;
 type TranscriptWindowReader = (transcriptId: string) => Promise<readonly unknown[] | null>;
 export declare function __setTranscriptWindowReaderForTests(r: TranscriptWindowReader | null): void;
-export declare const DELEGATED_PROMPT_ABSENCE_CAUSES: readonly ["not_owned_after_restart", "not_in_store", "forbidden", "prompt_absent", "unknown"];
+export declare const DELEGATED_PROMPT_ABSENCE_CAUSES: readonly ["anchor_unreported", "not_in_store", "forbidden", "prompt_absent", "unknown"];
 export type DelegatedPromptAbsenceCause = (typeof DELEGATED_PROMPT_ABSENCE_CAUSES)[number];
 export interface DelegatedPromptAbsence {
     readonly cause: DelegatedPromptAbsenceCause;
     readonly text: string;
 }
 export declare function delegatedPromptAbsenceSentence(cause: DelegatedPromptAbsenceCause | string, lang?: UiLanguage): string;
+export declare function standingDelegatedPromptAbsence(taskId: string, lang?: UiLanguage): DelegatedPromptAbsence | undefined;
 export interface DelegatedPromptFetch {
     prompt?: string;
     outcome: 'hit' | 'skipped' | 'unreadable' | 'absent';
@@ -26,5 +27,5 @@ export interface DelegatedPromptFetch {
 }
 export declare function fetchDelegatedPrompt(taskId: string, opts?: {
     wire?: DelegatedPromptWire;
-}): Promise<DelegatedPromptFetch>;
+}, lang?: UiLanguage): Promise<DelegatedPromptFetch>;
 export {};

package/dist/subagent/engineDelegatedPrompt.js

@@ -115,9 +115,9 @@ async function readTranscriptWindow(transcriptId, sessionKey, injectedWire) {
     const msgs = rec.messages;
     return Array.isArray(msgs) ? msgs : null;
 }
-export const DELEGATED_PROMPT_ABSENCE_CAUSES = Object.freeze(['not_owned_after_restart', 'not_in_store', 'forbidden', 'prompt_absent', 'unknown']);
+export const DELEGATED_PROMPT_ABSENCE_CAUSES = Object.freeze(['anchor_unreported', 'not_in_store', 'forbidden', 'prompt_absent', 'unknown']);
 const ABSENCE_KEY = {
-    not_owned_after_restart: 'session.subagent.delegatedPrompt.absence.notOwnedAfterRestart',
+    anchor_unreported: 'session.subagent.delegatedPrompt.absence.anchorUnreported',
     not_in_store: 'session.subagent.delegatedPrompt.absence.notInStore',
     forbidden: 'session.subagent.delegatedPrompt.absence.forbidden',
     prompt_absent: 'session.subagent.delegatedPrompt.absence.promptAbsent',
@@ -127,46 +127,83 @@ export function delegatedPromptAbsenceSentence(cause, lang) {
     const known = typeof cause === 'string' && Object.hasOwn(ABSENCE_KEY, cause);
     return renderMessage(msg(known ? ABSENCE_KEY[cause] : ABSENCE_KEY.unknown), lang);
 }
-function absenceOf(cause) {
-    return Object.freeze({ cause, text: delegatedPromptAbsenceSentence(cause) });
+function absenceOf(cause, lang) {
+    return Object.freeze({ cause, text: delegatedPromptAbsenceSentence(cause, lang) });
 }
-function absenceOfThrown(e) {
+function causeOfThrown(e) {
     const status = readThrownSlot(e, 'status');
     if (status === 404)
-        return absenceOf('not_in_store');
+        return 'not_in_store';
     if (status === 401 || status === 403)
-        return absenceOf('forbidden');
-    return absenceOf('unknown');
+        return 'forbidden';
+    return 'unknown';
 }
-export async function fetchDelegatedPrompt(taskId, opts) {
-    if (promptHydrateInFlight.has(taskId)) {
-        const settled = promptHydrateInFlight.get(taskId);
-        return settled ? { outcome: 'skipped', absence: settled } : { outcome: 'skipped' };
-    }
-    const transcriptId = getEngineTranscriptId(taskId);
-    if (!isSessionIdPathSegment(transcriptId))
-        return { outcome: 'skipped', absence: absenceOf(transcriptId === undefined ? 'not_owned_after_restart' : 'unknown') };
-    promptHydrateInFlight.set(taskId, null);
+function anchorlessCause(anchor) {
+    return anchor === undefined ? 'anchor_unreported' : 'unknown';
+}
+export function standingDelegatedPromptAbsence(taskId, lang) {
+    if (typeof taskId !== 'string' || taskId === '')
+        return undefined;
+    const anchor = getEngineTranscriptId(taskId);
+    if (!isSessionIdPathSegment(anchor))
+        return absenceOf(anchorlessCause(anchor), lang);
+    const mark = promptHydrateInFlight.get(taskId);
+    return mark !== undefined && mark.anchor === anchor && (mark.phase === 'absent' || mark.phase === 'failed') ? absenceOf(mark.cause, lang) : undefined;
+}
+async function readDelegatedPrompt(taskId, transcriptId, wire, lang) {
     let msgs = null;
+    let prompt;
     try {
-        msgs = await readTranscriptWindow(transcriptId, resolveOwnerContext(taskId).key, opts?.wire);
+        msgs = await readTranscriptWindow(transcriptId, resolveOwnerContext(taskId).key, wire);
+        prompt = msgs ? pickDelegatedPrompt(msgs) : undefined;
     }
     catch (e) {
-        promptHydrateInFlight.delete(taskId);
         hostLog('debug', `[delegated-prompt] ${taskId} transcript ${transcriptId} read failed: ${String(e).slice(0, 160)}`);
-        return { outcome: 'unreadable', absence: absenceOfThrown(e) };
+        return { outcome: 'unreadable', absence: absenceOf(causeOfThrown(e), lang) };
     }
-    const prompt = msgs ? pickDelegatedPrompt(msgs) : undefined;
     if (!prompt) {
-        if (msgs === null)
-            promptHydrateInFlight.delete(taskId);
         hostLog('debug', `[delegated-prompt] ${taskId} transcript ${transcriptId}: ${msgs === null ? 'transcript unreadable (retryable)' : 'no delegated user message (final)'}`);
         if (msgs === null)
-            return { outcome: 'unreadable', absence: absenceOf('unknown') };
-        const settled = absenceOf('prompt_absent');
-        promptHydrateInFlight.set(taskId, settled);
-        return { outcome: 'absent', absence: settled };
+            return { outcome: 'unreadable', absence: absenceOf('unknown', lang) };
+        return { outcome: 'absent', absence: absenceOf('prompt_absent', lang) };
     }
     hostLog('debug', `[delegated-prompt] ${taskId} <- transcript ${transcriptId} (${prompt.length} chars) head=${JSON.stringify(prompt.slice(0, 60))}`);
-    return { prompt, outcome: 'hit' };
+    return { outcome: 'hit', prompt };
+}
+function markOf(anchor, r) {
+    if (r.outcome === 'hit')
+        return { anchor, phase: 'hit' };
+    return { anchor, phase: r.outcome === 'absent' ? 'absent' : 'failed', cause: r.absence.cause };
+}
+function landed(taskId, mine, next) {
+    if (promptHydrateInFlight.get(taskId) !== mine)
+        return false;
+    if (getEngineTranscriptId(taskId) !== mine.anchor) {
+        promptHydrateInFlight.delete(taskId);
+        return false;
+    }
+    promptHydrateInFlight.set(taskId, next);
+    return true;
+}
+export async function fetchDelegatedPrompt(taskId, opts, lang) {
+    const transcriptId = getEngineTranscriptId(taskId);
+    const held = promptHydrateInFlight.get(taskId);
+    if (held !== undefined) {
+        if (held.anchor !== transcriptId)
+            promptHydrateInFlight.delete(taskId);
+        else if (held.phase === 'flying' || held.phase === 'hit')
+            return { outcome: 'skipped' };
+        else if (held.phase === 'absent')
+            return { outcome: 'skipped', absence: absenceOf(held.cause, lang) };
+    }
+    if (!isSessionIdPathSegment(transcriptId))
+        return { outcome: 'skipped', absence: absenceOf(anchorlessCause(transcriptId), lang) };
+    const mine = { anchor: transcriptId, phase: 'flying' };
+    promptHydrateInFlight.set(taskId, mine);
+    const read = await readDelegatedPrompt(taskId, transcriptId, opts?.wire, lang);
+    if (!landed(taskId, mine, markOf(transcriptId, read))) {
+        hostLog('debug', `[delegated-prompt] ${taskId} dropped=${transcriptId}`);
+        return { outcome: 'skipped' };
+    }
+    return read;
 }

package/dist/subagentEditOutcomes.d.ts

@@ -0,0 +1,9 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+export interface SubagentEditOutcomes {
+    readonly attempted: number;
+    readonly succeeded: number;
+    readonly refused: number;
+    readonly failed: number;
+}
+export declare function subagentEditOutcomesOf(toolStats: {} | null | undefined): SubagentEditOutcomes | undefined;
+export declare function subagentEditOutcomesSentence(outcomes: SubagentEditOutcomes | null | undefined, lang?: UiLanguage): string | undefined;