@sema-agent/client-core 0.94.0 → 0.95.0

package/dist/fleetAgentPanelProjection.js

@@ -1,212 +1,22 @@
-import { isStaleEngineAgentPanelEnd, publishEngineAgentPanelAbsence, publishEngineAgentPanelEvent } from './engineAgentPanelStore.js';
-import { __resetPanelRunningHistoryForTests, notePanelRowRunning, panelRowUnknownToConsumer, panelRowEndedIdentity, holdNewbornTerminalRow, peekHeldNewbornTerminalRow, dropHeldNewbornTerminalRow } from './panelRunningHistory.js';
-import { rowIdTail } from './workflow.js';
-import { TERMINAL_FLEET_TASK_STATUSES } from './fleet/fleetProjection.js';
+import { ABSENT_SETTLE_MS, panelPresenceSize } from './panelReduce.js';
+import { panelStateNow, stepEnginePanel } from './panelStateHolder.js';
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
-import { isTerminalNotSuccess } from './runTerminal.js';
-export const ABSENT_SETTLE_MS = 30_000;
-const SETTLED_RETENTION_MS = ABSENT_SETTLE_MS * 4;
-function currentToolKeyOf(ct) {
-    if (!ct || typeof ct.toolName !== 'string' || ct.toolName.length === 0)
-        return undefined;
-    return `${ct.toolName}\u0000${ct.target ?? ''}`;
-}
-const seen = new Map();
-function seenFor(sessionKey) {
-    let m = seen.get(sessionKey);
-    if (!m) {
-        m = new Map();
-        seen.set(sessionKey, m);
-    }
-    return m;
-}
+export { ABSENT_SETTLE_MS };
 export function resetFleetAgentPanelProjection() {
-    seen.clear();
-    __resetPanelRunningHistoryForTests();
+    stepEnginePanel({ kind: 'fleet-rows-reset' });
 }
 export function resetFleetAgentPanelProjectionFor(sessionKey) {
-    seen.delete(sessionKey);
+    stepEnginePanel({ kind: 'fleet-rows-reset', sessionKey });
 }
 export function fleetAgentProjectionSize() {
     return fleetAgentProjectionSizeFor(DEFAULT_SESSION_KEY);
 }
 export function fleetAgentProjectionSizeFor(sessionKey) {
-    return seen.get(sessionKey)?.size ?? 0;
+    return panelPresenceSize(panelStateNow(), sessionKey);
 }
 export function projectFleetAgentRows(rows, nowMs = Date.now()) {
     projectFleetAgentRowsFor(DEFAULT_SESSION_KEY, rows, nowMs);
 }
 export function projectFleetAgentRowsFor(sessionKey, rows, nowMs = Date.now()) {
-    const seenMap = seenFor(sessionKey);
-    const present = new Set();
-    for (const row of rows) {
-        if (!row?.id)
-            continue;
-        const taskId = rowIdTail(row.id);
-        if (!taskId)
-            continue;
-        present.add(taskId);
-        const status = row.status ?? 'running';
-        const wireTokens = typeof row.tokens === 'number' && Number.isInteger(row.tokens) && row.tokens >= 0 ? row.tokens : undefined;
-        const tokens = wireTokens;
-        const toolUses = typeof row.toolUses === 'number' ? row.toolUses : undefined;
-        const transcriptId = row.transcriptId || undefined;
-        const parentToolCallId = typeof row.parentToolCallId === 'string' && row.parentToolCallId.length > 0 ? row.parentToolCallId : undefined;
-        const startedAt = typeof row.startedAt === 'number' && Number.isFinite(row.startedAt) && row.startedAt > 0 ? row.startedAt : undefined;
-        const cycleSeq = typeof row.cycleSeq === 'number' && Number.isInteger(row.cycleSeq) && row.cycleSeq >= 1 ? row.cycleSeq : undefined;
-        const currentTool = currentToolKeyOf(row.currentTool) !== undefined ? row.currentTool : undefined;
-        const currentToolKey = currentToolKeyOf(row.currentTool);
-        const prev = seenMap.get(taskId);
-        const rowIdentity = { ...(cycleSeq !== undefined ? { cycleSeq } : {}), ...(startedAt !== undefined ? { startedAt } : {}) };
-        const prevIdentity = prev !== undefined
-            ? { ...(prev.cycleSeq !== undefined ? { cycleSeq: prev.cycleSeq } : {}), ...(prev.startedAt !== undefined ? { startedAt: prev.startedAt } : {}) }
-            : undefined;
-        if (prev !== undefined && isStaleEngineAgentPanelEnd(rowIdentity, prevIdentity))
-            continue;
-        const rowNewerCycle = prev !== undefined && isStaleEngineAgentPanelEnd(prevIdentity, rowIdentity);
-        const sameCycle = prev !== undefined &&
-            !prev.settled &&
-            (startedAt === undefined || prev.startedAt === undefined || prev.startedAt === startedAt) &&
-            (cycleSeq === undefined || prev.cycleSeq === undefined || prev.cycleSeq === cycleSeq);
-        const knownTokens = tokens !== undefined ? tokens : sameCycle ? prev?.tokens : undefined;
-        const carryIdentity = prev !== undefined && !rowNewerCycle;
-        const knownStartedAt = startedAt !== undefined ? startedAt : carryIdentity ? prev.startedAt : undefined;
-        const knownCycleSeq = cycleSeq !== undefined ? cycleSeq : carryIdentity ? prev.cycleSeq : undefined;
-        if (TERMINAL_FLEET_TASK_STATUSES.has(status)) {
-            const newbornTerminal = prev === undefined && panelRowUnknownToConsumer(taskId);
-            const settledThisCycle = prev?.settled === true && !rowNewerCycle;
-            const endedRec = prev === undefined ? panelRowEndedIdentity(taskId) : undefined;
-            const frameCycle = { ...(cycleSeq !== undefined ? { cycleSeq } : {}), ...(startedAt !== undefined ? { startedAt } : {}) };
-            if (endedRec !== undefined && isStaleEngineAgentPanelEnd(frameCycle, endedRec))
-                continue;
-            const endedSameCycle = endedRec !== undefined && !isStaleEngineAgentPanelEnd(endedRec, frameCycle);
-            if (newbornTerminal) {
-                holdNewbornTerminalRow(taskId, {
-                    kind: 'fleet-row',
-                    taskId,
-                    ...(row.name ? { name: row.name } : {}),
-                    ...(row.description ? { description: row.description } : {}),
-                    ...(knownTokens !== undefined ? { totalTokens: knownTokens } : {}),
-                    ...(toolUses !== undefined ? { toolUses } : {}),
-                    ...(transcriptId !== undefined ? { transcriptId } : {}),
-                    ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
-                    ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
-                    ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
-                });
-            }
-            else if (!settledThisCycle) {
-                if (rowNewerCycle ||
-                    (cycleSeq !== undefined && prev?.cycleSeq !== cycleSeq) ||
-                    (tokens !== undefined && prev?.tokens !== tokens) ||
-                    (toolUses !== undefined && prev?.toolUses !== toolUses) ||
-                    (transcriptId !== undefined && prev?.transcriptId !== transcriptId) ||
-                    (parentToolCallId !== undefined && prev?.parentToolCallId !== parentToolCallId) ||
-                    (startedAt !== undefined && prev?.startedAt !== startedAt)) {
-                    publishEngineAgentPanelEvent({
-                        kind: 'fleet-row',
-                        taskId,
-                        ...(row.name ? { name: row.name } : {}),
-                        ...(row.description ? { description: row.description } : {}),
-                        ...(knownTokens !== undefined ? { totalTokens: knownTokens } : {}),
-                        ...(toolUses !== undefined ? { toolUses } : {}),
-                        ...(transcriptId !== undefined ? { transcriptId } : {}),
-                        ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
-                        ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
-                        ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
-                    });
-                }
-                if (!endedSameCycle)
-                    publishEngineAgentPanelEvent({
-                        kind: 'end',
-                        taskId,
-                        isError: isTerminalNotSuccess(status),
-                        ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
-                        ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
-                    });
-            }
-            seenMap.set(taskId, {
-                status,
-                tokens: knownTokens,
-                toolUses: toolUses !== undefined ? toolUses : prev?.toolUses,
-                transcriptId: transcriptId !== undefined ? transcriptId : prev?.transcriptId,
-                parentToolCallId: parentToolCallId !== undefined ? parentToolCallId : prev?.parentToolCallId,
-                startedAt: knownStartedAt,
-                cycleSeq: knownCycleSeq,
-                currentToolKey: currentToolKey !== undefined ? currentToolKey : prev?.currentToolKey,
-                lastSeenAt: nowMs,
-                settled: true,
-                settledAtMs: prev?.settled ? prev.settledAtMs : nowMs,
-                absentReportedAtMs: undefined,
-            });
-            continue;
-        }
-        const cycleComparable = (cycleSeq !== undefined && prev?.cycleSeq !== undefined) || (startedAt !== undefined && prev?.startedAt !== undefined);
-        const staleSnapshotOverHeldRow = prev !== undefined && prev.settled === true && cycleComparable && !rowNewerCycle && peekHeldNewbornTerminalRow(taskId) !== undefined;
-        if (staleSnapshotOverHeldRow)
-            continue;
-        if (!prev ||
-            prev.settled ||
-            prev.absentReportedAtMs !== undefined ||
-            prev.status !== status ||
-            prev.tokens !== knownTokens ||
-            (toolUses !== undefined && prev.toolUses !== toolUses) ||
-            (transcriptId !== undefined && prev.transcriptId !== transcriptId) ||
-            (parentToolCallId !== undefined && prev.parentToolCallId !== parentToolCallId) ||
-            (startedAt !== undefined && prev.startedAt !== startedAt) ||
-            (cycleSeq !== undefined && prev.cycleSeq !== cycleSeq) ||
-            (currentToolKey !== undefined && prev.currentToolKey !== currentToolKey)) {
-            notePanelRowRunning(taskId);
-            dropHeldNewbornTerminalRow(taskId);
-            publishEngineAgentPanelEvent({
-                kind: 'fleet-row',
-                taskId,
-                ...(row.name ? { name: row.name } : {}),
-                ...(row.description ? { description: row.description } : {}),
-                ...(knownTokens !== undefined ? { totalTokens: knownTokens } : {}),
-                ...(toolUses !== undefined ? { toolUses } : {}),
-                ...(transcriptId !== undefined ? { transcriptId } : {}),
-                ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
-                ...(knownStartedAt !== undefined ? { startedAt: knownStartedAt } : {}),
-                ...(knownCycleSeq !== undefined ? { cycleSeq: knownCycleSeq } : {}),
-                ...(currentTool !== undefined ? { currentTool } : {}),
-            });
-        }
-        seenMap.set(taskId, {
-            status,
-            tokens: knownTokens,
-            toolUses: toolUses !== undefined ? toolUses : prev?.toolUses,
-            transcriptId: transcriptId !== undefined ? transcriptId : prev?.transcriptId,
-            parentToolCallId: parentToolCallId !== undefined ? parentToolCallId : prev?.parentToolCallId,
-            startedAt: knownStartedAt,
-            cycleSeq: knownCycleSeq,
-            currentToolKey: currentToolKey !== undefined ? currentToolKey : prev?.currentToolKey,
-            lastSeenAt: nowMs,
-            settled: false,
-            settledAtMs: undefined,
-            absentReportedAtMs: undefined,
-        });
-    }
-    for (const [taskId, s] of seenMap) {
-        if (present.has(taskId) || s.settled || s.absentReportedAtMs !== undefined)
-            continue;
-        const absentForMs = nowMs - s.lastSeenAt;
-        if (absentForMs <= ABSENT_SETTLE_MS)
-            continue;
-        publishEngineAgentPanelAbsence({ taskId, lastSeenAtMs: s.lastSeenAt, absentForMs });
-        seenMap.set(taskId, { ...s, absentReportedAtMs: nowMs });
-    }
-    for (const [taskId, s] of seenMap) {
-        if (present.has(taskId))
-            continue;
-        if (s.settled) {
-            const settledAt = s.settledAtMs ?? s.lastSeenAt;
-            if (nowMs - settledAt > SETTLED_RETENTION_MS)
-                seenMap.delete(taskId);
-        }
-        else if (s.absentReportedAtMs !== undefined && nowMs - s.absentReportedAtMs > SETTLED_RETENTION_MS) {
-            seenMap.delete(taskId);
-        }
-    }
-    if (seenMap.size === 0)
-        seen.delete(sessionKey);
+    stepEnginePanel({ kind: 'fleet-rows', sessionKey, rows, nowMs });
 }

package/dist/fleetAgentRowLike.d.ts

@@ -0,0 +1,16 @@
+export interface FleetAgentRowLike {
+    id: string;
+    name?: string;
+    description?: string;
+    status?: string;
+    tokens?: number;
+    toolUses?: number;
+    transcriptId?: string;
+    currentTool?: {
+        toolName: string;
+        target?: string;
+    };
+    startedAt?: number;
+    cycleSeq?: number;
+    parentToolCallId?: string;
+}

package/dist/fleetAgentRowLike.js

@@ -0,0 +1 @@
+export {};

package/dist/gateOutcome.js

@@ -1,6 +1,7 @@
 import { ccToolDenialKindForSettledBy, isCcToolDenialKind, isGateDeniedByWord } from './gateVocabulary.js';
 import { GATE_PARKED_ERROR_CODE } from './engineErrorCodes.js';
 import { CORE_MODE_RELEASE_REASONS, CORE_SETTLEMENT_KINDS } from './generated/engineFactTables.js';
+import { readAskOrigin } from './ownKey.js';
 function str(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
@@ -32,7 +33,8 @@ function readSettlement(v) {
     const who = readWho(s.who);
     if (kind === undefined || who === undefined)
         return undefined;
-    const when = typeof s.when === 'number' && Number.isFinite(s.when) ? s.when : undefined;
+    const whenRaw = s.when;
+    const when = typeof whenRaw === 'number' && Number.isFinite(whenRaw) ? whenRaw : undefined;
     const note = str(s.note);
     return {
         kind,
@@ -62,7 +64,7 @@ function readModeRelease(raw) {
     const classes = nonEmptyStringList(r.classes);
     if (mode === undefined || askClass === undefined || classes === undefined)
         return undefined;
-    const origin = str(r.origin);
+    const origin = readAskOrigin(r);
     const mandate = str(r.mandate);
     const reason = str(r.reason);
     return {
@@ -94,7 +96,7 @@ function readClassifierRound(raw) {
     }
     return view;
 }
-export function gateOutcomeOf(frame) {
+function readGateRecord(frame) {
     if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
         return undefined;
     const g = frame.gate;
@@ -107,7 +109,9 @@ export function gateOutcomeOf(frame) {
     const dr = d;
     const dk = str(dr.kind);
     let disposition;
-    const classifier = readClassifierRound(dr.classifier);
+    let causePresent = false;
+    const classifierRaw = dr.classifier;
+    const classifier = readClassifierRound(classifierRaw);
     if (dk === 'allowed') {
         const released = readModeRelease(dr.released);
         disposition = {
@@ -120,7 +124,9 @@ export function gateOutcomeOf(frame) {
         const deniedBy = str(dr.deniedBy);
         if (deniedBy === undefined)
             return undefined;
-        const cause = str(dr.cause);
+        const causeRaw = dr.cause;
+        causePresent = causeRaw !== undefined;
+        const cause = str(causeRaw);
         const mode = str(dr.mode);
         const askClass = str(dr.askClass);
         const classes = nonEmptyStringList(dr.classes);
@@ -137,14 +143,23 @@ export function gateOutcomeOf(frame) {
     else {
         return undefined;
     }
-    const settlement = readSettlement(raw.settlement);
-    const origin = str(raw.origin);
+    const settlementRaw = raw.settlement;
+    const settlement = readSettlement(settlementRaw);
+    const origin = readAskOrigin(raw);
     return {
-        disposition,
-        ...(settlement !== undefined ? { settlement } : {}),
-        ...(origin !== undefined ? { origin } : {}),
+        view: {
+            disposition,
+            ...(settlement !== undefined ? { settlement } : {}),
+            ...(origin !== undefined ? { origin } : {}),
+        },
+        settlementPresent: settlementRaw !== undefined,
+        causePresent,
+        classifierPresent: classifierRaw !== undefined,
     };
 }
+export function gateOutcomeOf(frame) {
+    return readGateRecord(frame)?.view;
+}
 export function isGateParkedToolEnd(frame) {
     if (typeof frame !== 'object' || frame === null || Array.isArray(frame))
         return false;
@@ -189,21 +204,19 @@ export function ccToolDenialKindForToolEnd(frame) {
         return stamped;
     if (frame._sema_denial_unclassified === true)
         return undefined;
-    const outcome = gateOutcomeOf(frame);
+    const record = readGateRecord(frame);
+    const outcome = record?.view;
     const kind = outcome?.settlement?.kind;
     if (kind === 'human_refused')
         return ccToolDenialKindForSettledBy('human');
     if (kind === 'policy_refused')
         return ccToolDenialKindForSettledBy('policy');
-    const rawGate = frame.gate;
-    const settlementAbsent = typeof rawGate === 'object' && rawGate !== null && rawGate.settlement === undefined;
-    if (outcome !== undefined && settlementAbsent && outcome.disposition.kind === 'denied') {
+    if (record !== undefined && outcome !== undefined && !record.settlementPresent && outcome.disposition.kind === 'denied') {
         const by = outcome.disposition.deniedBy;
         if (by === 'ask_resolution' || !isGateDeniedByWord(by))
             return undefined;
         if (DENIED_BY_MAY_CARRY_CAUSE.has(by)) {
-            const rawDisposition = rawKeyOf(rawGate, 'disposition');
-            if (rawKeyOf(rawDisposition, 'cause') !== undefined) {
+            if (record.causePresent) {
                 const cause = outcome.disposition.cause;
                 if (cause === 'unavailable')
                     return 'automode-unavailable';
@@ -213,14 +226,13 @@ export function ccToolDenialKindForToolEnd(frame) {
             }
             if (by === 'classifier')
                 return 'automode-blocked';
-            if (rawKeyOf(rawDisposition, 'classifier') !== undefined)
+            if (record.classifierPresent)
                 return undefined;
         }
         return ccToolDenialKindForSettledBy('policy');
     }
     return undefined;
 }
-const rawKeyOf = (holder, key) => typeof holder === 'object' && holder !== null ? holder[key] : undefined;
 const DENIED_BY_MAY_CARRY_CAUSE = new Set(['classifier', 'policy']);
 const _gateOutcomeShapePin = (w) => w;
 void _gateOutcomeShapePin;

package/dist/generated/sdkFactTables.d.ts

@@ -1,3 +1,5 @@
 export declare const SDK_ABORT_CAUSES: readonly ["client_disconnected", "ask_park_grace_exhausted", "cancel_verb"];
 export declare const SDK_STATUS_DERIVED_COARSE_CODES: readonly ["request.rejected", "auth.unauthorized", "auth.forbidden", "not_found.resource", "request.payload_too_large", "request.unprocessable", "limit.rate_exceeded", "capability.unavailable", "internal.error"];
 export declare const SDK_DENY_REASON_ROUTING_FAILURE: "routing_failure_fail_closed";
+export declare const SDK_ASK_ROW_ENDING_CAUSES: readonly ["routing_failure_fail_closed", "run_cancelled", "run_exited", "batch_aborted", "batch_sibling_withdrawn", "batch_bound_elsewhere", "adhoc_leg_no_durable_domain", "orphan_ttl_exceeded", "crashed_before_park", "shutdown_before_park"];
+export declare const SDK_RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];

package/dist/generated/sdkFactTables.js

@@ -15,3 +15,20 @@ export const SDK_STATUS_DERIVED_COARSE_CODES = Object.freeze([
     "internal.error",
 ]);
 export const SDK_DENY_REASON_ROUTING_FAILURE = "routing_failure_fail_closed";
+export const SDK_ASK_ROW_ENDING_CAUSES = Object.freeze([
+    "routing_failure_fail_closed",
+    "run_cancelled",
+    "run_exited",
+    "batch_aborted",
+    "batch_sibling_withdrawn",
+    "batch_bound_elsewhere",
+    "adhoc_leg_no_durable_domain",
+    "orphan_ttl_exceeded",
+    "crashed_before_park",
+    "shutdown_before_park",
+]);
+export const SDK_RUN_DEATH_VERDICT_CODES = Object.freeze([
+    "run.stalled",
+    "run.orphaned",
+    "approval.expired",
+]);

package/dist/generated/settingsSchemaFns.d.ts

@@ -0,0 +1,10 @@
+export declare const SETTINGS_AT_MENTION_MODES: readonly ["all", "none", "only"];
+export type SettingsAtMention = {
+    readonly mode: Exclude<(typeof SETTINGS_AT_MENTION_MODES)[number], 'only'>;
+} | {
+    readonly mode: 'only';
+    readonly models: readonly string[];
+};
+export declare const SETTINGS_IS_LOOPBACK_AUTH_HOST: (host: string) => boolean;
+export declare const SETTINGS_IS_HIERARCHICAL_URL: (raw: string) => boolean;
+export declare const SETTINGS_NARROW_AT_MENTION: (atMention: SettingsAtMention, available: ReadonlySet<string>) => SettingsAtMention;

package/dist/generated/settingsSchemaFns.js

@@ -0,0 +1,22 @@
+export const SETTINGS_AT_MENTION_MODES = Object.freeze([
+    "all",
+    "none",
+    "only",
+]);
+export const SETTINGS_IS_LOOPBACK_AUTH_HOST = function isLoopbackAuthHost(host) {
+    return host === "127.0.0.1" || host === "localhost" || host === "::1" || host === "[::1]" || host === "::ffff:127.0.0.1";
+};
+export const SETTINGS_IS_HIERARCHICAL_URL = function isHierarchicalUrl(raw) {
+    if (!URL.canParse(raw))
+        return false;
+    const u = new URL(raw);
+    return u.href.startsWith(`${u.protocol}//`);
+};
+export const SETTINGS_NARROW_AT_MENTION = function narrowAtMention(atMention, available) {
+    if (atMention.mode !== "only")
+        return atMention;
+    const kept = atMention.models.filter((n) => available.has(n));
+    if (kept.length === atMention.models.length)
+        return atMention;
+    return kept.length > 0 ? { mode: "only", models: kept } : { mode: "none" };
+};

package/dist/headlessPermissionModeWire.d.ts

@@ -3,7 +3,7 @@ import { type PermissionModesReading } from './permissionModesCapability.js';
 import { type EnvLike } from './hostEnv.js';
 export declare const HEADLESS_PERMISSION_MODE_ENV = "SEMA_HEADLESS_PERMISSION_MODE";
 export declare const HEADLESS_PERMISSION_WIRE_MODES: readonly PermissionMode[];
-export declare function normalizeShellPermissionModeForWire(mode: string | undefined, _permissionModes?: PermissionModesReading): string | undefined;
+export declare function normalizeShellPermissionModeForWire(mode: string | undefined): string | undefined;
 export type HeadlessPermissionResolution = {
     fields: PermissionModeField;
     source: 'flag' | 'env' | 'default';

package/dist/headlessPermissionModeWire.js

@@ -7,7 +7,7 @@ import { readOwnDataValue } from './ownKey.js';
 export const HEADLESS_PERMISSION_MODE_ENV = 'SEMA_HEADLESS_PERMISSION_MODE';
 export const HEADLESS_PERMISSION_WIRE_MODES = [...PERMISSION_MODE_WORDS];
 const SHELL_INTERNAL_MODE_TO_WIRE = new Map([['manual', 'default']]);
-export function normalizeShellPermissionModeForWire(mode, _permissionModes) {
+export function normalizeShellPermissionModeForWire(mode) {
     if (mode === undefined)
         return undefined;
     return SHELL_INTERNAL_MODE_TO_WIRE.get(mode) ?? mode;

package/dist/headlessReconnectWire.js

@@ -1,23 +1,18 @@
 import { isSseIdleError, probeEngineAlive } from './sseIdleTriage.js';
 import { hostEnv } from './hostEnv.js';
+import { isSdkRunFrameSynthesizable } from './terminalStatuses.js';
+import { createStreamDrainingLegs } from './streamDrainingLegs.js';
+import { abortableSleep } from './abortableSleep.js';
 export const HEADLESS_RECONNECT_MAX = 2;
 function debugLog(msg) {
     if (hostEnv().SEMA_DEBUG) {
         console.error(`[sema] headless reconnect: ${msg}`);
     }
 }
-const RUN_ROW_TERMINAL_STATUSES = new Set([
-    'completed',
-    'failed',
-    'timeout',
-    'blocked',
-    'suspended',
-    'needs_review',
-]);
 export function terminalEventFromRunRow(row) {
     if (!row || typeof row.status !== 'string')
         return null;
-    if (RUN_ROW_TERMINAL_STATUSES.has(row.status)) {
+    if (isSdkRunFrameSynthesizable(row.status)) {
         if (row.result && typeof row.result === 'object') {
             return { type: 'done', result: row.result };
         }
@@ -49,6 +44,15 @@ export async function* withHeadlessR1Reconnect(live, deps) {
     let lastSeenSeq;
     const probe = deps.probeAlive ?? probeEngineAlive;
     let isRecoverableTear;
+    const drains = createStreamDrainingLegs();
+    let drainReopenAfterMs;
+    const terminalFromRunRow = async (taskId) => {
+        const row = await deps.getRun(taskId).catch(() => null);
+        const terminal = terminalEventFromRunRow(row);
+        if (terminal)
+            debugLog(`run row terminal (${String(row?.status)}) — synthesizing the terminal frame (R1b)`);
+        return terminal;
+    };
     for (;;) {
         if (deps.signal?.aborted)
             throw originalTearErr;
@@ -59,25 +63,37 @@ export async function* withHeadlessR1Reconnect(live, deps) {
         const taskId = deps.getTaskId();
         if (!taskId)
             throw originalTearErr;
-        if (attempts >= HEADLESS_RECONNECT_MAX) {
-            debugLog(`budget exhausted (${attempts}/${HEADLESS_RECONNECT_MAX}) — falling to the honest death path`);
-            throw originalTearErr;
+        if (drainReopenAfterMs !== undefined) {
+            const waitMs = drainReopenAfterMs;
+            drainReopenAfterMs = undefined;
+            await abortableSleep(waitMs, deps.signal ?? new AbortController().signal);
+            if (deps.signal?.aborted)
+                throw originalTearErr;
+            debugLog(`engine draining — reopening runs.events(${taskId}${lastSeenSeq !== undefined ? `, Last-Event-ID ${lastSeenSeq}` : ''}) after ${waitMs}ms (not counted against the reconnect budget)`);
+        }
+        else {
+            if (attempts >= HEADLESS_RECONNECT_MAX) {
+                debugLog(`budget exhausted (${attempts}/${HEADLESS_RECONNECT_MAX}) — falling to the honest death path`);
+                throw originalTearErr;
+            }
+            attempts++;
+            if (!(await probe(deps.baseUrl)))
+                throw originalTearErr;
+            debugLog(`attempt ${attempts}/${HEADLESS_RECONNECT_MAX} — switching to runs.events(${taskId}${lastSeenSeq !== undefined ? `, Last-Event-ID ${lastSeenSeq}` : ''})`);
         }
-        attempts++;
-        if (!(await probe(deps.baseUrl)))
-            throw originalTearErr;
-        debugLog(`attempt ${attempts}/${HEADLESS_RECONNECT_MAX} — switching to runs.events(${taskId}${lastSeenSeq !== undefined ? `, Last-Event-ID ${lastSeenSeq}` : ''})`);
         try {
             const cont = deps.openEvents(taskId, lastSeenSeq !== undefined ? String(lastSeenSeq) : undefined);
             for await (const ev of cont) {
                 if (deps.signal?.aborted)
                     return;
+                if (drains.see(ev))
+                    continue;
                 const rec = ev;
                 const t = rec?.type;
                 if (t === undefined)
                     continue;
                 if (t === 'error') {
-                    debugLog(`runs.events lane frame type=error code=${String(rec?.errorCode ?? rec?.code ?? '')} — SDK resumes with Last-Event-ID internally`);
+                    debugLog(`runs.events lane frame type=error code=${String(rec?.errorCode ?? rec?.code ?? '')} — not forwarded (the cap frame is resumed inside the SDK)`);
                     continue;
                 }
                 const seq = typeof rec?.id === 'string' && /^\d+$/.test(rec.id) ? Number(rec.id) : undefined;
@@ -94,16 +110,29 @@ export async function* withHeadlessR1Reconnect(live, deps) {
             }
             if (deps.signal?.aborted)
                 return;
+            const drained = drains.legEnded('returned');
+            if (drained !== undefined) {
+                if ('reconnectAfterMs' in drained) {
+                    drainReopenAfterMs = drained.reconnectAfterMs;
+                    continue;
+                }
+                debugLog(`runs.events kept ending on drain end frames (${drained.giveUp}) — checking the run row`);
+                const terminal = await terminalFromRunRow(taskId);
+                if (terminal) {
+                    yield terminal;
+                    return;
+                }
+                continue;
+            }
             debugLog('runs.events continuation ended without a terminal frame');
         }
         catch (contErr) {
+            drains.legEnded('threw');
             debugLog(`runs.events continuation failed: ${contErr instanceof Error ? contErr.message : String(contErr)}`);
             if (deps.signal?.aborted)
                 throw originalTearErr;
-            const row = await deps.getRun(taskId).catch(() => null);
-            const terminal = terminalEventFromRunRow(row);
+            const terminal = await terminalFromRunRow(taskId);
             if (terminal) {
-                debugLog(`run row terminal (${String(row?.status)}) — synthesizing the terminal frame (R1b)`);
                 yield terminal;
                 return;
             }

package/dist/hitl/allowRuleShadow.d.ts

@@ -18,4 +18,4 @@ export interface ApprovalAllowRuleShadow {
 export declare function readAllowRuleShadowFromWire(carrier: object | null | undefined, leg: 'frame' | 'row'): ApprovalAllowRuleShadow | undefined;
 export declare function readApprovalAllowRuleShadow(card: object | null | undefined): ApprovalAllowRuleShadow | undefined;
 export declare function approvalAllowRuleShadowed(card: object | null | undefined): boolean;
-export declare function legacyShadowedRuleTextOf(r: ApprovalAllowRuleShadow | undefined): string | undefined;
+export declare function allowRuleShadowSentence(card: object | null | undefined): string | undefined;

package/dist/hitl/allowRuleShadow.js

@@ -1,4 +1,5 @@
 import { CORE_ALLOW_RULE_MEMBERS } from '../generated/engineFactTables.js';
+import { quoteUntrustedForSentence } from '../displayUntrusted.js';
 const KNOWN_MEMBERS = new Set(CORE_ALLOW_RULE_MEMBERS);
 function freezeMember(m) {
     return Object.freeze({ ...m });
@@ -154,14 +155,54 @@ export function readApprovalAllowRuleShadow(card) {
 export function approvalAllowRuleShadowed(card) {
     return readApprovalAllowRuleShadow(card) !== undefined;
 }
-export function legacyShadowedRuleTextOf(r) {
-    if (r === undefined)
+const ENTRY_MAX = 4096;
+const MEMBER_MAX = 64;
+const ENTRIES_SHOWN = 5;
+const UNREADABLE_LINE = 'An allow rule matched this call but cannot clear it; which rule could not be read, so this one is confirmed individually.';
+function legacySingleEntry(shadow) {
+    if (shadow.unreadable === true || shadow.members.length !== 1)
         return undefined;
-    for (const m of r.members) {
-        if (m.member !== 'persisted' || m.entries === undefined)
-            continue;
-        const first = m.entries[0];
-        return typeof first === 'string' && first.trim() !== '' ? first : undefined;
+    const m = shadow.members[0];
+    if (m.member !== 'persisted' || m.malformed === true || m.omitted !== undefined)
+        return undefined;
+    if (m.entries === undefined || m.entries.length !== 1)
+        return undefined;
+    return quoteUntrustedForSentence(m.entries[0], ENTRY_MAX);
+}
+function memberPhrase(m) {
+    const memberWord = m.member === undefined ? undefined : KNOWN_MEMBERS.has(m.member) ? m.member : quoteUntrustedForSentence(m.member, MEMBER_MAX);
+    const word = memberWord ?? 'an unrecognised source';
+    const entries = m.entries ?? [];
+    if (m.malformed === true && entries.length === 0)
+        return `${word} (could not be read)`;
+    const listed = entries
+        .map((e) => quoteUntrustedForSentence(e, ENTRY_MAX))
+        .filter((e) => e !== undefined)
+        .slice(0, ENTRIES_SHOWN);
+    const notListed = entries.length - listed.length + (m.omitted ?? 0);
+    const parts = [];
+    if (listed.length > 0)
+        parts.push(listed.join(', '));
+    if (notListed > 0)
+        parts.push(listed.length > 0 ? `and ${String(notListed)} more not listed` : `${String(notListed)} not listed`);
+    if (m.malformed === true)
+        parts.push('part of it could not be read');
+    return parts.length > 0 ? `${word}: ${parts.join('; ')}` : word;
+}
+export function allowRuleShadowSentence(card) {
+    const shadow = readApprovalAllowRuleShadow(card);
+    if (shadow === undefined)
+        return undefined;
+    try {
+        if (shadow.unreadable === true || shadow.members.length === 0)
+            return UNREADABLE_LINE;
+        const legacy = legacySingleEntry(shadow);
+        if (legacy !== undefined) {
+            return `Your saved permission rule ${legacy} still exists — it just cannot clear this particular call, so this one is confirmed individually.`;
+        }
+        return `Allow rules matched this call but cannot clear it, so this one is confirmed individually — ${shadow.members.map(memberPhrase).join(' · ')}.`;
+    }
+    catch {
+        return UNREADABLE_LINE;
     }
-    return undefined;
 }

package/dist/hitl/approvalCompleteParked.d.ts

@@ -0,0 +1 @@
+export declare function approvalCompleteParked(frame: unknown): boolean;