@sema-agent/client-core 0.109.0 → 0.111.0

package/dist/permissionsDeclaration.d.ts

@@ -115,6 +115,7 @@ export declare function assembledRuleRows(input: PermissionsDeclarationInput, ca
 export interface PermissionsAllowKeptFacts {
     readonly problemCount?: number;
     readonly managedPolicyPending?: true;
+    readonly managedPolicyFetch?: 'in_progress' | 'failed' | 'unknown';
     readonly where?: string;
 }
 export declare function permissionsAllowKeptNotice(report: Pick<PermissionsDeclarationReport, 'kept'>, settingsRead: 'clean' | 'partial' | 'unreadable', facts?: PermissionsAllowKeptFacts): string | undefined;

package/dist/permissionsDeclaration.js

@@ -543,11 +543,21 @@ export function permissionsAllowKeptNotice(report, settingsRead, facts) {
     const rawCount = readFact('problemCount');
     const rawWhere = readFact('where');
     const managedPending = readFact('managedPolicyPending') === true;
+    const rawFetch = readFact('managedPolicyFetch');
+    const fetchState = rawFetch === 'in_progress' || rawFetch === 'failed' ? rawFetch : 'unknown';
     const count = typeof rawCount === 'number' && Number.isInteger(rawCount) && rawCount >= 1 ? rawCount : undefined;
     const where = typeof rawWhere === 'string' && rawWhere.length >= 1 && rawWhere.length <= 200 && !/\p{Cc}/u.test(rawWhere) ? rawWhere : undefined;
     const head = `${String(held)} permissions.allow rule${held === 1 ? ' was' : 's were'} not sent to the engine for this run because `;
     if (settingsRead === 'partial' && managedPending && count === 1) {
-        return (`${head}the managed policy for your account has not been received yet (sema keeps fetching it; allow rules apply once it arrives). ` +
+        if (fetchState === 'in_progress') {
+            return (`${head}the managed policy for your account has not been received yet (sema keeps fetching it; allow rules apply once it arrives). ` +
+                'Run again once it has been received (deny and ask rules, and rules given with --allowedTools, are still sent).');
+        }
+        if (fetchState === 'failed') {
+            return (`${head}the managed policy for your account has not been received yet (this run will not fetch again; the next run retries). ` +
+                'Run again to retry fetching it (deny and ask rules, and rules given with --allowedTools, are still sent).');
+        }
+        return (`${head}the managed policy for your account has not been received yet. ` +
             'Run again once it has been received (deny and ask rules, and rules given with --allowedTools, are still sent).');
     }
     const why = settingsRead === 'partial'

package/dist/planReviewCardFacts.d.ts

@@ -16,6 +16,7 @@ export interface PlanReviewCardFacts {
     readonly taskId: string;
     readonly checkpointId?: string;
     readonly body: PlanReviewBody;
+    readonly evidenceRevision?: number;
 }
 export declare function planReviewBodyOf(text: string): Exclude<PlanReviewBody, {
     kind: 'unknown';
@@ -91,10 +92,12 @@ export interface PlanBodyClaimLeg {
     }>;
     overflow: boolean;
     unreadable: boolean;
+    readonly seen: Set<string>;
 }
 export declare function openPlanBodyClaimLeg(): PlanBodyClaimLeg;
 export declare function stepPlanBodyClaim(leg: PlanBodyClaimLeg, frame: object, subFlow: boolean): void;
 export declare function planReviewParkFacts(leg: PlanBodyClaimLeg, result: {} | null | undefined): PlanReviewCardFacts | undefined;
+export declare function planReviewClaimStep(leg: PlanBodyClaimLeg, frame: object, subFlow: boolean, seq: string | undefined): PlanReviewCardFacts | undefined;
 export interface PlanReviewFactsTaken {
     readonly sessionKey: string;
     readonly taskId: string;

package/dist/planReviewCardFacts.js

@@ -3,6 +3,7 @@ import { readRunTerminal, runTerminalGateKind } from './runTerminal.js';
 import { SDK_PLAN_REVIEW_GATE_KINDS } from './generated/sdkFactTables.js';
 import { CORE_PRESENT_PLAN_TOOL_NAME } from './generated/engineFactTables.js';
 import { DEFAULT_SESSION_KEY } from './sessionSlot.js';
+import { doneResultView } from './replayBody.js';
 const PLAN_BODY_MAX_LENGTH = 200_000;
 const PLAN_BODY_UNKNOWN_CAUSES = Object.freeze([
     'not_observed', 'gate_unidentified', 'gate_moved', 'unreadable', 'ambiguous_call', 'malformed_frame', 'conflicting_claims', 'not_presented', 'not_carried',
@@ -29,6 +30,13 @@ export function mintPlanReviewCardFacts(taskId, checkpointId, body) {
     const b = checkpointId === undefined ? unknownBody('gate_unidentified') : body;
     return Object.freeze({ taskId, ...(checkpointId !== undefined ? { checkpointId } : {}), body: Object.isFrozen(b) ? b : Object.freeze({ ...b }) });
 }
+let evidenceRevisionSeq = 0;
+function withEvidenceRevision(facts, evidenceRevision) {
+    return Object.freeze({ taskId: facts.taskId, ...(facts.checkpointId !== undefined ? { checkpointId: facts.checkpointId } : {}), body: facts.body, evidenceRevision });
+}
+function isEvidenceRevision(v) {
+    return typeof v === 'number' && Number.isSafeInteger(v) && v > 0;
+}
 export function unknownBody(cause) {
     return Object.freeze({ kind: 'unknown', cause });
 }
@@ -59,7 +67,11 @@ export function planReviewCardFactsFrom(v) {
         const checkpointId = ck.present ? ck.value : undefined;
         if (checkpointId === undefined && !(body.kind === 'unknown' && body.cause === 'gate_unidentified'))
             return undefined;
-        return mintPlanReviewCardFacts(taskId, checkpointId, body);
+        const eg = ownData(v, 'evidenceRevision');
+        if (eg.present && !isEvidenceRevision(eg.value))
+            return undefined;
+        const minted = mintPlanReviewCardFacts(taskId, checkpointId, body);
+        return eg.present ? withEvidenceRevision(minted, eg.value) : minted;
     }
     catch {
         return undefined;
@@ -167,6 +179,10 @@ export function commitPlanReviewFacts(ticket, facts, claim, highWater) {
     if (prev !== undefined && prev.checkpointId === checkpointId && (isConflict(prev.facts) || !samePlanClaim(prev.claim, claim))) {
         out = mintPlanReviewCardFacts(facts.taskId, checkpointId, unknownBody('conflicting_claims'));
     }
+    const reused = prev !== undefined && prev.checkpointId === checkpointId && prev.facts.evidenceRevision !== undefined && samePlanReviewCardFacts(prev.facts, out)
+        ? prev.facts.evidenceRevision
+        : undefined;
+    out = withEvidenceRevision(out, reused ?? ++evidenceRevisionSeq);
     rec.gate = { checkpointId, facts: out, claim, generation: ticket.generation, ...(highWater !== undefined ? { highWater } : {}) };
     return out;
 }
@@ -338,7 +354,7 @@ function foldMarker(rec, frame) {
 }
 const LEG_BUFFER_MAX = 256;
 export function openPlanBodyClaimLeg() {
-    return { buffer: [], overflow: false, unreadable: false };
+    return { buffer: [], overflow: false, unreadable: false, seen: new Set() };
 }
 function bindLeg(leg, taskId) {
     const rec = recordFor(DEFAULT_SESSION_KEY, taskId);
@@ -425,6 +441,40 @@ export function planReviewParkFacts(leg, result) {
         return taskId === undefined ? undefined : mintPlanReviewCardFacts(taskId, checkpointId, unknownBody('unreadable'));
     }
 }
+export function planReviewClaimStep(leg, frame, subFlow, seq) {
+    if (claimSeqDedupe(leg, frame, seq) === 'duplicate')
+        return undefined;
+    stepPlanBodyClaim(leg, frame, subFlow);
+    let result;
+    try {
+        if (frame.type !== 'done')
+            return undefined;
+        result = frame.result;
+    }
+    catch {
+        return undefined;
+    }
+    return planReviewParkFacts(leg, doneResultView(result).body);
+}
+function claimSeqDedupe(leg, frame, seq) {
+    try {
+        if (seq !== undefined && classOf(frame) !== 'other') {
+            if (leg.seen.has(seq))
+                return 'duplicate';
+            leg.seen.add(seq);
+            while (leg.seen.size > SETTLED_CALLS_MAX) {
+                const oldest = leg.seen.values().next();
+                if (oldest.done === true)
+                    break;
+                leg.seen.delete(oldest.value);
+            }
+        }
+        return 'fresh';
+    }
+    catch {
+        return 'class_unreadable';
+    }
+}
 function legRecord(leg, taskId) {
     return leg.taskId === undefined || leg.taskId === taskId ? bindLeg(leg, taskId) : recordFor(DEFAULT_SESSION_KEY, taskId);
 }

package/dist/pluginHooksWire.d.ts

@@ -12,8 +12,10 @@ export declare const PLUGIN_HOOK_REASONS: readonly ["projected", "shell_event",
 export type PluginHookReason = (typeof PLUGIN_HOOK_REASONS)[number];
 export declare const PLUGIN_HOOK_EXCLUSION_REASONS: readonly ["workspace_untrusted", "governance_unreadable", "policy_disable_all", "startup_mode", "managed_plugins_only", "prompt_not_user_authored"];
 export type PluginHookExclusionReason = (typeof PLUGIN_HOOK_EXCLUSION_REASONS)[number];
-export declare const SETTINGS_HOOK_DROP_REASONS: readonly ["exec_form_unsupported", "mcp_tool_unsupported", "key_not_read", "source_not_authored"];
+export declare const SETTINGS_HOOK_DROP_REASONS: readonly ["exec_form_unsupported", "mcp_tool_unsupported", "key_not_read", "source_not_authored", "workspace_untrusted", "governance_unreadable", "policy_disable_all", "no_executor"];
 export type SettingsHookDropReason = (typeof SETTINGS_HOOK_DROP_REASONS)[number];
+export type HookEntryTypeWord = 'command' | 'prompt' | 'agent' | 'http' | 'mcp_tool';
+export declare const HOOK_ENTRY_TYPE_WORDS: readonly ["command", "prompt", "agent", "http", "mcp_tool"];
 export type HookSettingsSource = 'policySettings' | 'userSettings' | 'projectSettings' | 'localSettings' | 'flagSettings';
 export interface PluginHookKey {
     readonly pluginId: string;
@@ -34,6 +36,7 @@ export interface SettingsHookDrop {
     readonly event: string;
     readonly groupIndex: number;
     readonly hookIndex: number;
+    readonly type?: HookEntryTypeWord;
     readonly reason: SettingsHookDropReason;
     readonly notRun: boolean;
     readonly unreadKeys?: readonly (readonly (string | number)[])[];
@@ -43,6 +46,7 @@ export interface SettingsHookVerdict {
     readonly event: string;
     readonly groupIndex: number;
     readonly hookIndex: number;
+    readonly type?: HookEntryTypeWord;
     readonly disposition: PluginHookDisposition;
     readonly reason: PluginHookReason;
 }
@@ -51,6 +55,7 @@ export interface SettingsHookExclusion {
     readonly event: string;
     readonly groupIndex: number;
     readonly hookIndex: number;
+    readonly type?: HookEntryTypeWord;
     readonly reason: PluginHookExclusionReason;
 }
 export interface SettingsHooksSalvageRow {
@@ -169,6 +174,9 @@ export declare function decideSessionHooks(input: SessionHookDecisionInput): {
     readonly unreadable: number;
 };
 export declare function filterSettingsHookGroups(source: HookSettingsSource, event: string, groups: readonly WireHookGroup[], execFormCapable: boolean, shellRunsType: (type: string | undefined) => boolean, judge: SettingsHookJudge, readerNotRead: readonly string[], mask?: HooksSalvageMask): SettingsHookFilterResult;
+export declare function hookEntryTypeWordOf(entry: {} | null | undefined): {
+    readonly type?: HookEntryTypeWord;
+};
 export interface SettingsHookFilterResult {
     readonly groups: WireHookGroup[];
     readonly drops: SettingsHookDrop[];
@@ -196,6 +204,7 @@ export interface SettingsHooksLocalGroup<T> {
 export declare function settingsHooksKeptLocally<T>(plan: HooksWirePlan, event: string, group: SettingsHooksLocalGroup<T>, opts?: {
     readonly engineCompaction?: 'performed' | 'not_performed';
 }): readonly T[];
+export declare function pluginHooksKeptLocally<T>(plan: HooksWirePlan, pluginId: string, event: string, groupIndex: number, hooks: readonly T[]): readonly T[];
 export declare function pluginHookReasonText(reason: PluginHookReason): string;
 export declare function settingsHookDropText(reason: SettingsHookDropReason): string;
 export declare function pluginHookExecutorLabel(v: PluginHookVerdict): string;

package/dist/pluginHooksWire.js

@@ -1,7 +1,9 @@
 import { displayUntrusted } from './displayUntrusted.js';
 import { appendOwnElement, readOwnDataValue } from './ownKey.js';
+import { inSlotReadOf } from './wireFailureShape.js';
 import { msg, renderMessage } from './i18n/translate.js';
 import { SETTINGS_ENGINE_OWNED_HOOK_EVENTS } from './generated/settingsSchemaTables.js';
+import { SETTINGS_HOOK_EVENTS } from './generated/settingsSchemaFns.js';
 import { HOOK_SETTINGS_SOURCE_TEXT, hooksEntryUnreadKeys, hooksGroupAuthoredSource, hooksGroupUnreadKeys, hooksKeyCoordinateText, hooksSalvageMaskOf, salvageSettingsHooksEntries, } from './settingsHooksSalvage.js';
 export const ENGINE_FIRED_HOOK_EVENTS = SETTINGS_ENGINE_OWNED_HOOK_EVENTS;
 export const PLUGIN_HOOK_DISPOSITIONS = ['engine', 'shell', 'not_run'];
@@ -40,7 +42,19 @@ export const PLUGIN_HOOK_EXCLUSION_REASONS = [
     'managed_plugins_only',
     'prompt_not_user_authored',
 ];
-export const SETTINGS_HOOK_DROP_REASONS = ['exec_form_unsupported', 'mcp_tool_unsupported', 'key_not_read', 'source_not_authored'];
+export const SETTINGS_HOOK_DROP_REASONS = [
+    'exec_form_unsupported',
+    'mcp_tool_unsupported',
+    'key_not_read',
+    'source_not_authored',
+    'workspace_untrusted',
+    'governance_unreadable',
+    'policy_disable_all',
+    'no_executor',
+];
+export const HOOK_ENTRY_TYPE_WORDS = Object.freeze(['command', 'prompt', 'agent', 'http', 'mcp_tool']);
+const _hookEntryTypePins = [true, true, true, true];
+void _hookEntryTypePins;
 export function hooksWirePlanShapeOf(v) {
     try {
         if (typeof v !== 'object' || v === null || Array.isArray(v))
@@ -135,6 +149,7 @@ function hookExecutorOf(x) {
     return judged(x.shellRuns ? 'shell' : 'not_run', why);
 }
 const ENGINE_EVENTS = new Set(ENGINE_FIRED_HOOK_EVENTS);
+const SHELL_OWNED_EVENTS = new Set(SETTINGS_HOOK_EVENTS.filter((e) => !ENGINE_EVENTS.has(e)));
 const USER_CONFIG_REF_ONE = /\$\{user_config\.[^}]+\}/;
 const USER_CONFIG_REF_ALL = /\$\{user_config\.([^}]+)\}/g;
 function isRecord(v) {
@@ -484,10 +499,23 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
     const excluded = [];
     const out = [];
     let stripped = 0;
-    const engineEvent = ENGINE_EVENTS.has(event);
+    const engineEvent = isEngineFiredHookEvent(event);
+    const shellOwned = !engineEvent && SHELL_OWNED_EVENTS.has(event);
     groups.forEach((group, groupIndex) => {
         if (mask !== undefined && mask.groupDropped(event, groupIndex))
             return;
+        if (!engineEvent) {
+            if (!shellOwned || !isRecord(group) || !Array.isArray(group.hooks))
+                return;
+            group.hooks.forEach((entry, hookIndex) => {
+                if (mask !== undefined && mask.entryDropped(event, groupIndex, hookIndex))
+                    return;
+                if (shellRunsType(isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined))
+                    return;
+                appendOwnElement(drops, { source, event, groupIndex, hookIndex, reason: 'no_executor', notRun: true });
+            });
+            return;
+        }
         if (!isRecord(group) || !Array.isArray(group.hooks)) {
             appendOwnElement(out, group);
             return;
@@ -513,27 +541,29 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
             const sourceNotAuthored = earlier === undefined && groupSourceAuthored && (authored === 'unreadable' || entryUnread !== undefined);
             const unreadKeys = earlier === undefined && !sourceNotAuthored ? unreadKeyPathsOf(event, groupIndex, hookIndex, groupUnread ?? [], entryUnread) : [];
             const reason = earlier ?? (sourceNotAuthored ? 'source_not_authored' : unreadKeys.length > 0 ? 'key_not_read' : undefined);
+            const typed = hookEntryTypeWordOf(entry);
             if (reason !== undefined) {
                 appendOwnElement(drops, {
                     source,
                     event,
                     groupIndex,
                     hookIndex,
+                    ...typed,
                     reason,
-                    notRun: engineEvent && !shellRunsType(isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined),
+                    notRun: !shellRunsType(isRecord(entry) && typeof entry.type === 'string' ? entry.type : undefined),
                     ...(reason === 'key_not_read' ? { unreadKeys } : {}),
                 });
                 changed = true;
                 return;
             }
-            if (engineEvent && isRecord(entry) && judgeableSettingsEntry(entry)) {
+            if (isRecord(entry) && judgeableSettingsEntry(entry)) {
                 const ex = judge(event, group, entry);
                 if (ex.kind === 'excluded') {
-                    appendOwnElement(excluded, { source, event, groupIndex, hookIndex, reason: ex.reason });
+                    appendOwnElement(excluded, { source, event, groupIndex, hookIndex, ...typed, reason: ex.reason });
                     changed = true;
                     return;
                 }
-                appendOwnElement(verdicts, { source, event, groupIndex, hookIndex, disposition: ex.disposition, reason: ex.reason });
+                appendOwnElement(verdicts, { source, event, groupIndex, hookIndex, ...typed, disposition: ex.disposition, reason: ex.reason });
                 if (ex.disposition === 'shell') {
                     changed = true;
                     return;
@@ -558,6 +588,17 @@ export function filterSettingsHookGroups(source, event, groups, execFormCapable,
     });
     return { groups: out, drops, stripped, verdicts, excluded };
 }
+export function hookEntryTypeWordOf(entry) {
+    try {
+        if (!isRecord(entry))
+            return {};
+        const t = readOwnDataValue(entry, 'type');
+        return typeof t === 'string' && HOOK_ENTRY_TYPE_WORDS.includes(t) ? { type: t } : {};
+    }
+    catch {
+        return {};
+    }
+}
 function judgeableSettingsEntry(entry) {
     const type = entry.type;
     if (typeof type !== 'string' || !ENGINE_HOOK_TYPE_RUNS.has(type))
@@ -729,6 +770,8 @@ function skipMatcherKey(matcher) {
     return matcher === undefined || matcher === null || matcher === '' || matcher === '*' ? 'null' : JSON.stringify(matcher);
 }
 export function settingsHooksKeptLocally(plan, event, group, opts) {
+    if (planClosedLocally(plan))
+        return [];
     let raw;
     try {
         raw = group?.hooks;
@@ -802,6 +845,42 @@ export function settingsHooksKeptLocally(plan, event, group, opts) {
         return hooks;
     }
 }
+function planClosedLocally(plan) {
+    if (typeof plan !== 'object' || plan === null)
+        return false;
+    let slot;
+    try {
+        slot = inSlotReadOf(plan, 'closedBy');
+    }
+    catch {
+        return true;
+    }
+    if (slot.state === 'absent')
+        return false;
+    if (slot.state !== 'present')
+        return true;
+    return slot.value !== null && slot.value !== undefined;
+}
+export function pluginHooksKeptLocally(plan, pluginId, event, groupIndex, hooks) {
+    if (planClosedLocally(plan))
+        return [];
+    if (!Array.isArray(hooks))
+        return hooks;
+    try {
+        let kept = null;
+        hooks.forEach((h, i) => {
+            const engineRuns = pluginHookVerdictOf(plan, pluginId, event, groupIndex, i)?.disposition === 'engine';
+            if (engineRuns)
+                kept ??= hooks.slice(0, i);
+            else if (kept !== null)
+                appendOwnElement(kept, h);
+        });
+        return kept ?? hooks;
+    }
+    catch {
+        return hooks;
+    }
+}
 function settingsRowBaseOf(v) {
     if (!isRecord(v))
         return undefined;
@@ -852,7 +931,7 @@ function settingsExclusionRowOf(v) {
 const REASON_TEXT = {
     projected: 'it is sent to the engine',
     shell_event: 'this client runs this event itself',
-    no_executor: 'neither the engine nor this client runs this event',
+    no_executor: renderMessage(msg('config.hooks.plan.reason.noExecutor')),
     engine_not_local: 'the engine was not started by this client on this machine, so it cannot reach the plugin files',
     engine_locality_unknown: 'it is not known whether the engine was started by this client on this machine, so plugin hooks are not sent to it',
     engine_capability_absent: 'the connected engine does not support plugin hooks',
@@ -881,6 +960,10 @@ const DROP_TEXT = {
     mcp_tool_unsupported: 'MCP tool hooks are not supported by the engine',
     key_not_read: REASON_TEXT.key_not_read,
     source_not_authored: REASON_TEXT.source_not_authored,
+    workspace_untrusted: renderMessage(msg('config.hooks.plan.reason.closedUntrusted')),
+    governance_unreadable: renderMessage(msg('config.hooks.plan.reason.closedGovernanceUnreadable')),
+    policy_disable_all: renderMessage(msg('config.hooks.plan.reason.closedDisableAll')),
+    no_executor: REASON_TEXT.no_executor,
 };
 const SOURCE_TEXT = HOOK_SETTINGS_SOURCE_TEXT;
 export function pluginHookReasonText(reason) {
@@ -958,6 +1041,10 @@ function namedPathsOfRow(d) {
             return typeof d.event === 'string' && Number.isInteger(d.groupIndex) && d.groupIndex >= 0 ? [['hooks', d.event, d.groupIndex, 'source']] : [];
         case 'exec_form_unsupported':
         case 'mcp_tool_unsupported':
+        case 'workspace_untrusted':
+        case 'governance_unreadable':
+        case 'policy_disable_all':
+        case 'no_executor':
             return [];
     }
 }
@@ -1009,6 +1096,8 @@ export function hooksNotRunNotice(plan) {
     for (const d of plan.settingsDropped) {
         if (!d.notRun)
             continue;
+        if (d.reason === 'workspace_untrusted' || d.reason === 'policy_disable_all')
+            continue;
         const named = d.reason === 'key_not_read' || d.reason === 'source_not_authored' ? namedPathsOfRow(d) : [];
         if (named.length > 0 && (d.reason === 'key_not_read' || d.reason === 'source_not_authored')) {
             const nk = `${d.source}\u0000${d.reason}`;

package/dist/printToolResultFrame.js

@@ -24,6 +24,8 @@ export function toolEndResultToUserFrame(arm) {
     }, undefined, parent === null ? 'leader' : 'subagent');
     const envelope = toolResultEnvelopeParts(outcome);
     const gateView = guardedRead(() => gateOutcomeOf(arm));
+    const denialKindRaw = arm._sema_denial_kind;
+    const denialKind = typeof denialKindRaw === 'string' ? denialKindRaw : undefined;
     const content = Array.isArray(outcome.body.content) ? outcome.body.content : arm.truncated === true ? `${text}\n…(truncated)` : text;
     return {
         type: 'user',
@@ -39,9 +41,9 @@ export function toolEndResultToUserFrame(arm) {
             ],
         },
         parent_tool_use_id: parent,
-        ...(isCcToolDenialKind(arm._sema_denial_kind) ? { _sema_denial_kind: arm._sema_denial_kind } : {}),
+        ...(isCcToolDenialKind(denialKind) ? { _sema_denial_kind: denialKind } : {}),
         ...(gateView !== undefined ? { _sema_gate: gateView } : {}),
-        ...toolResultRowFlagParts(arm, gateView),
+        ...toolResultRowFlagParts(arm, gateView, denialKind),
         ...(Object.hasOwn(envelope, 'tool_use_result') ? { tool_use_result: envelope.tool_use_result } : {}),
         ...(Object.hasOwn(envelope, '_sema_degraded') ? { _sema_degraded: envelope._sema_degraded } : {}),
         uuid: rowIdentity.uuid,

package/dist/promptBlockedCopy.js

@@ -4,7 +4,10 @@ import { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD } from './rowKind.js';
 export { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD };
 const RUN_BLOCKED_REASONED = 'Run blocked';
 const RUN_BLOCKED_NO_REASON = 'Run blocked (the agent reported it cannot proceed)';
-const HOOK_WORDS_SHOWN_MAX = 1000;
+const WORDS_SHOWN_MAX = 1000;
+function shownWords(words) {
+    return displayUntrusted(words, { max: WORDS_SHOWN_MAX }).trim();
+}
 const CAUSE_CLAUSE = Object.freeze({
     crashed: 'the hook failed before it answered; the prompt was not submitted',
     timeout: 'the hook did not answer in time; the prompt was not submitted',
@@ -13,7 +16,7 @@ const CAUSE_CLAUSE = Object.freeze({
 function shownHookWords(words) {
     if (words === undefined)
         return undefined;
-    const shown = stripSystemReminderTagTokens(displayUntrusted(stripSystemReminderTagTokens(words), { max: HOOK_WORDS_SHOWN_MAX })).trim();
+    const shown = stripSystemReminderTagTokens(shownWords(stripSystemReminderTagTokens(words))).trim();
     return shown === '' ? undefined : shown;
 }
 export function runBlockedText(blocked) {
@@ -29,8 +32,10 @@ export function runBlockedText(blocked) {
     if (reason === undefined)
         return RUN_BLOCKED_NO_REASON;
     const unwrapped = unwrapSystemReminder(reason);
-    if (unwrapped === reason)
-        return `${RUN_BLOCKED_REASONED}: ${reason}`;
-    const body = stripSystemReminderTagTokens(unwrapped).trim();
-    return body === '' ? RUN_BLOCKED_NO_REASON : `${RUN_BLOCKED_REASONED}: ${body}`;
+    if (unwrapped === reason) {
+        const shown = shownWords(reason);
+        return shown === '' ? RUN_BLOCKED_NO_REASON : `${RUN_BLOCKED_REASONED}: ${shown}`;
+    }
+    const body = shownHookWords(unwrapped);
+    return body === undefined ? RUN_BLOCKED_NO_REASON : `${RUN_BLOCKED_REASONED}: ${body}`;
 }

package/dist/promptSuggestionBatch.d.ts

@@ -0,0 +1,7 @@
+export declare const SUGGESTION_BATCH_CAP = 8;
+export declare const SUGGESTION_CHARS_CAP = 200;
+export interface PromptSuggestionBatch {
+    readonly list: readonly string[];
+    readonly truncatedCount?: number;
+}
+export declare function promptSuggestionBatchOf(raw: {} | null | undefined): PromptSuggestionBatch | undefined;

package/dist/promptSuggestionBatch.js

@@ -0,0 +1,9 @@
+export const SUGGESTION_BATCH_CAP = 8;
+export const SUGGESTION_CHARS_CAP = 200;
+export function promptSuggestionBatchOf(raw) {
+    const filtered = (Array.isArray(raw) ? raw : []).filter((s) => typeof s === 'string' && s.trim().length > 0);
+    const list = filtered.slice(0, SUGGESTION_BATCH_CAP).map((s) => (s.length > SUGGESTION_CHARS_CAP ? `${s.slice(0, SUGGESTION_CHARS_CAP)}…` : s));
+    if (list.length === 0)
+        return undefined;
+    return { list, ...(filtered.length > list.length ? { truncatedCount: filtered.length - list.length } : {}) };
+}

package/dist/promptSuggestionsTail.d.ts

@@ -0,0 +1,39 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { LaneProof } from './seam.js';
+export declare const PROMPT_SUGGESTIONS_TAIL_MAX_ATTEMPTS = 6;
+export declare const PROMPT_SUGGESTIONS_TAIL_BUDGET_MS = 12000;
+export interface PromptSuggestionsTailEvent {
+    readonly kind: 'prompt_suggestions';
+    readonly laneProof: LaneProof;
+    readonly suggestions: readonly string[];
+}
+export type PromptSuggestionsStreamSeen = 'frame' | 'done' | 'cut';
+export interface PromptSuggestionsTailInput {
+    readonly runs: Pick<AgentClient['runs'], 'get'>;
+    readonly runId: string;
+    readonly sessionId?: string | undefined;
+    readonly requested: boolean;
+    readonly stream: PromptSuggestionsStreamSeen;
+    readonly baseUrl: string | undefined;
+    readonly signal?: AbortSignal | undefined;
+    readonly sleep?: ((ms: number) => Promise<void>) | undefined;
+    readonly now?: (() => number) | undefined;
+}
+export type PromptSuggestionsTailOutcome = {
+    readonly kind: 'skipped';
+    readonly why: 'not_requested' | 'frame_on_stream' | 'settled_on_stream';
+} | {
+    readonly kind: 'settled';
+    readonly event?: PromptSuggestionsTailEvent;
+} | {
+    readonly kind: 'not_completed';
+    readonly attempts: number;
+} | {
+    readonly kind: 'gave_up';
+    readonly attempts: number;
+} | {
+    readonly kind: 'unavailable';
+    readonly attempts: number;
+};
+export declare function promptSuggestionsOnStream(baseUrl: string | undefined): boolean;
+export declare function followUpPromptSuggestions(input: PromptSuggestionsTailInput): Promise<PromptSuggestionsTailOutcome>;

package/dist/promptSuggestionsTail.js

@@ -0,0 +1,116 @@
+import { abortableSleep, requestDeadline } from './abortableSleep.js';
+import { engineCapString, engineCapValue } from './engineCapsCache.js';
+import { readOwnDataValue } from './ownKey.js';
+import { promptSuggestionBatchOf } from './promptSuggestionBatch.js';
+import { engineVersionTier } from './supportFloor.js';
+export const PROMPT_SUGGESTIONS_TAIL_MAX_ATTEMPTS = 6;
+export const PROMPT_SUGGESTIONS_TAIL_BUDGET_MS = 12_000;
+const RETRY_STEP_MS = 750;
+const RETRY_CAP_MS = 3_000;
+const ON_STREAM_SERVER_FLOOR = '7.149.0';
+const MAY_STILL_SUGGEST = Object.freeze(['completed', 'running']);
+export function promptSuggestionsOnStream(baseUrl) {
+    try {
+        const bit = engineCapValue(baseUrl, 'promptSuggestions');
+        if (bit.kind !== 'value' || bit.value !== true)
+            return false;
+        return engineVersionTier(engineCapString(baseUrl, 'version'), ON_STREAM_SERVER_FLOOR) === 'engine';
+    }
+    catch {
+        return false;
+    }
+}
+const freeze = (o) => Object.freeze(o);
+const own = (o, key) => {
+    try {
+        return typeof o === 'object' && o !== null ? readOwnDataValue(o, key) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+function eventOf(raw) {
+    const batch = promptSuggestionBatchOf(raw);
+    return batch === undefined ? undefined : freeze({ kind: 'prompt_suggestions', laneProof: freeze({ lane: 'main' }), suggestions: freeze([...batch.list]) });
+}
+function skipWhy(input) {
+    if (own(input, 'requested') !== true)
+        return 'not_requested';
+    const seen = own(input, 'stream');
+    if (seen === 'frame')
+        return 'frame_on_stream';
+    if (seen === 'done' && promptSuggestionsOnStream(own(input, 'baseUrl')))
+        return 'settled_on_stream';
+    return undefined;
+}
+export async function followUpPromptSuggestions(input) {
+    let attempts = 0;
+    try {
+        const why = skipWhy(input);
+        if (why !== undefined)
+            return freeze({ kind: 'skipped', why });
+        const runs = own(input, 'runs');
+        const runId = own(input, 'runId');
+        const get = typeof runs === 'object' && runs !== null ? runs.get : undefined;
+        if (typeof get !== 'function' || typeof runId !== 'string' || runId.length === 0)
+            return freeze({ kind: 'unavailable', attempts });
+        const sessionId = own(input, 'sessionId');
+        const signal = own(input, 'signal');
+        const sleepIn = own(input, 'sleep');
+        const nowIn = own(input, 'now');
+        const sleep = typeof sleepIn === 'function' ? sleepIn : (ms) => abortableSleep(ms, signal ?? new AbortController().signal);
+        const now = typeof nowIn === 'function' ? nowIn : Date.now;
+        const signalState = () => {
+            if (signal === undefined || signal === null)
+                return 'live';
+            try {
+                return signal.aborted === true ? 'aborted' : 'live';
+            }
+            catch {
+                return 'unreadable';
+            }
+        };
+        const t0 = now();
+        for (;;) {
+            if (signalState() !== 'live')
+                return freeze({ kind: 'unavailable', attempts });
+            const left = PROMPT_SUGGESTIONS_TAIL_BUDGET_MS - (now() - t0);
+            if (!(left > 0))
+                return freeze({ kind: 'gave_up', attempts });
+            attempts++;
+            const d = requestDeadline(left, signal);
+            let rec;
+            try {
+                rec = await d.race(Promise.resolve(get.call(runs, runId, {
+                    ...(typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {}),
+                    signal: d.signal,
+                })));
+            }
+            catch {
+                return freeze({ kind: d.expired() ? 'gave_up' : 'unavailable', attempts });
+            }
+            finally {
+                d.abort();
+            }
+            const suggestions = own(rec, 'suggestions');
+            if (Array.isArray(suggestions)) {
+                const event = eventOf(suggestions);
+                return freeze({ kind: 'settled', ...(event !== undefined ? { event } : {}) });
+            }
+            const status = own(rec, 'status');
+            if (typeof status === 'string' && !MAY_STILL_SUGGEST.includes(status))
+                return freeze({ kind: 'not_completed', attempts });
+            if (attempts >= PROMPT_SUGGESTIONS_TAIL_MAX_ATTEMPTS)
+                return freeze({ kind: 'gave_up', attempts });
+            const rest = PROMPT_SUGGESTIONS_TAIL_BUDGET_MS - (now() - t0);
+            if (!(rest > 0))
+                return freeze({ kind: 'gave_up', attempts });
+            if (signalState() !== 'live')
+                return freeze({ kind: 'unavailable', attempts });
+            await sleep(Math.min(RETRY_STEP_MS * attempts, RETRY_CAP_MS, rest));
+        }
+    }
+    catch {
+        return freeze({ kind: 'unavailable', attempts });
+    }
+}