@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/permissionsDeclaration.js

@@ -5,6 +5,7 @@ import { allowRulesGate, allowWireForm } from './permissionsAllowGrantCapability
 import { SETTINGS_IS_AT_LEAST } from './generated/settingsSchemaFns.js';
 import { THROWN_SLOT_UNREADABLE, asAssemblyRefusal, assemblyRefusalOf, isSlotCarrier, readThrownSlot, withAssemblyRefusal } from './wireFailureShape.js';
 import { appendOwnElement } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const SETTINGS_SOURCE_TIERS = Object.freeze({
     policySettings: 'managed',
     flagSettings: 'global',
@@ -530,7 +531,24 @@ function allowHeldBySettingsReadCount(report) {
     }
     return n;
 }
-export function permissionsAllowKeptNotice(report, settingsRead, facts) {
+const ALLOW_KEPT_MANAGED_KEYS = Object.freeze({
+    in_progress: Object.freeze({ one: 'session.hostSettings.allowKept.managed.inProgress.one', other: 'session.hostSettings.allowKept.managed.inProgress.other' }),
+    failed: Object.freeze({ one: 'session.hostSettings.allowKept.managed.failed.one', other: 'session.hostSettings.allowKept.managed.failed.other' }),
+    unknown: Object.freeze({ one: 'session.hostSettings.allowKept.managed.unknown.one', other: 'session.hostSettings.allowKept.managed.unknown.other' }),
+});
+const ALLOW_KEPT_GENERIC_KEYS = Object.freeze({
+    one: 'session.hostSettings.allowKept.generic.one',
+    other: 'session.hostSettings.allowKept.generic.other',
+});
+const ALLOW_KEPT_COUNTED_KEYS = Object.freeze({
+    one: 'session.hostSettings.allowKept.why.counted.one',
+    other: 'session.hostSettings.allowKept.why.counted.other',
+});
+const ALLOW_KEPT_COUNTED_WHERE_KEYS = Object.freeze({
+    one: 'session.hostSettings.allowKept.why.countedWhere.one',
+    other: 'session.hostSettings.allowKept.why.countedWhere.other',
+});
+export function permissionsAllowKeptNotice(report, settingsRead, facts, lang) {
     const held = allowHeldBySettingsReadCount(report);
     if (held <= 0)
         return undefined;
@@ -543,16 +561,22 @@ 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 `;
+    const plural = held === 1 ? 'one' : 'other';
     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). ` +
-            'Run again once it has been received (deny and ask rules, and rules given with --allowedTools, are still sent).');
+        return renderMessage(msg(ALLOW_KEPT_MANAGED_KEYS[fetchState][plural], { held }), lang);
     }
-    const why = settingsRead === 'partial'
-        ? `the settings read reported ${count === undefined ? 'problems' : `${String(count)} problem${count === 1 ? '' : 's'}`}${where === undefined ? '' : ` (${where})`}`
-        : 'the health of this settings read could not be checked';
-    return (`${head}${why}; an allow rule from a settings file is only sent from a settings read with no problems. Fix the reported settings, then run again ` +
-        '(deny and ask rules from this read, and rules given with --allowedTools, are still sent).');
+    const why = settingsRead !== 'partial'
+        ? msg('session.hostSettings.allowKept.why.unreadable')
+        : count === undefined
+            ? where === undefined
+                ? msg('session.hostSettings.allowKept.why.problems')
+                : msg('session.hostSettings.allowKept.why.problemsWhere', { where })
+            : where === undefined
+                ? msg(ALLOW_KEPT_COUNTED_KEYS[count === 1 ? 'one' : 'other'], { count })
+                : msg(ALLOW_KEPT_COUNTED_WHERE_KEYS[count === 1 ? 'one' : 'other'], { count, where });
+    return renderMessage(msg(ALLOW_KEPT_GENERIC_KEYS[plural], { held, why }), lang);
 }

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", "workspace_untrusted", "governance_unreadable", "policy_disable_all"];
+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[];

package/dist/pluginHooksWire.js

@@ -3,6 +3,7 @@ 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'];
@@ -49,7 +50,11 @@ export const SETTINGS_HOOK_DROP_REASONS = [
     '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))
@@ -144,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) {
@@ -493,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;
@@ -522,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;
@@ -567,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))
@@ -899,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',
@@ -931,6 +963,7 @@ const DROP_TEXT = {
     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) {
@@ -1011,6 +1044,7 @@ function namedPathsOfRow(d) {
         case 'workspace_untrusted':
         case 'governance_unreadable':
         case 'policy_disable_all':
+        case 'no_executor':
             return [];
     }
 }

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

@@ -1,10 +1,13 @@
-import { displayUntrusted } from './displayUntrusted.js';
+import { displayUntrustedCapped } from './displayUntrusted.js';
 import { stripSystemReminderTagTokens, unwrapSystemReminder } from './systemReminderTag.js';
 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 displayUntrustedCapped(words, 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 });
+    }
+}

package/dist/request/taskRequest.js

@@ -548,8 +548,12 @@ export function refilterHostSettings(request, fresh, lane) {
             }
         }
     }
-    if (Object.hasOwn(nextSettings, 'env')) {
-        const sentEnv = nextSettings.env;
+    const nowEnv = intake.carried.env;
+    const envUnwired = intake.dispositions['settings.env'] === 'unwired';
+    const envMaybeAdded = nowEnv !== undefined && !envUnwired && hostRefuseRowSeated('settings.env', lane, true);
+    const hasSentEnv = Object.hasOwn(nextSettings, 'env');
+    if (hasSentEnv || envMaybeAdded) {
+        const sentEnv = hasSentEnv ? nextSettings.env : {};
         if (!isPlainRecord(sentEnv))
             return unjudged();
         let names;
@@ -559,14 +563,14 @@ export function refilterHostSettings(request, fresh, lane) {
         catch {
             return unjudged();
         }
-        const nowEnv = intake.carried.env;
-        const envUnwired = intake.dispositions['settings.env'] === 'unwired';
         const sentKeys = Object.keys(sentEnv);
         const kept = sentKeys.filter((k) => names.includes(k) && (envUnwired || (nowEnv !== undefined && Object.hasOwn(nowEnv, k))));
-        if (kept.length !== sentKeys.length) {
+        const added = envMaybeAdded && nowEnv !== undefined ? names.filter((n) => !sentKeys.includes(n) && Object.hasOwn(nowEnv, n)) : [];
+        if (kept.length !== sentKeys.length || added.length > 0) {
             const { env: _sentEnv, ...restSettings } = nextSettings;
             void _sentEnv;
-            nextSettings = kept.length === 0 ? restSettings : { ...restSettings, env: Object.fromEntries(kept.map((k) => [k, sentEnv[k]])) };
+            const rows = [...kept.map((k) => [k, sentEnv[k]]), ...added.map((n) => [n, nowEnv?.[n]])];
+            nextSettings = rows.length === 0 ? restSettings : { ...restSettings, env: Object.fromEntries(rows) };
         }
     }
     if (nextSettings === settings)

package/dist/requestCoordinate.d.ts

@@ -0,0 +1 @@
+export declare function requestCoordinateText(root: string, segs: readonly (string | number)[], label?: (seg: string) => string): string;

package/dist/requestCoordinate.js

@@ -0,0 +1,13 @@
+const PLAIN_SEGMENT = /^[^.[\]"\s\p{Cc}]+$/u;
+export function requestCoordinateText(root, segs, label) {
+    let out = root;
+    for (const seg of segs) {
+        if (typeof seg === 'number') {
+            out += `[${seg}]`;
+            continue;
+        }
+        const shown = label === undefined ? seg : label(seg);
+        out += PLAIN_SEGMENT.test(shown) ? `.${shown}` : `[${JSON.stringify(shown)}]`;
+    }
+    return out;
+}