@sema-agent/client-core 0.110.0 → 0.111.0

package/dist/notifications.js

@@ -5,8 +5,9 @@ import { panelEndFact } from './panelReduce.js';
 import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreWorkflowRunParkedEnd, isCoreWorkflowRunTerminal } from './terminalStatuses.js';
 import { cycleSeqValue } from './cycleOrder.js';
 import { CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS } from './generated/engineFactTables.js';
-import { guardedRead, ownSnapshot, ownSnapshotRecord, ownSnapshotTyped, readOwnDataValue, workflowCompletionExtrasOf } from './ownKey.js';
-import { displayUntrusted } from './displayUntrusted.js';
+import { guardedRead, ownSnapshot, ownSnapshotRecord, ownSnapshotTyped, readOwnDataNonEmptyString, readOwnDataValue, resupplyTruncatedFactsOf, resupplyTruncatedOf, workflowCompletionExtrasOf } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { displayUntrustedCapped } from './displayUntrusted.js';
 function escapeXml(v) {
     return v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -213,6 +214,7 @@ export function normalizeTaskNotification(raw) {
         ? n.lines.filter((l) => typeof l === 'string')
         : [];
     const recentSteps = deriveNotificationResidualLines(n);
+    const failureReason = failureReasonOf(status, n.error);
     return {
         taskId,
         status,
@@ -230,6 +232,7 @@ export function normalizeTaskNotification(raw) {
             ? { diagnostics: n.diagnostics }
             : {}),
         ...(typeof n.result === 'string' && n.result.length > 0 ? { result: n.result } : {}),
+        ...(failureReason !== undefined ? { error: failureReason } : {}),
         ...(typeof n.stoppedBy === 'string' && n.stoppedBy.length > 0 ? { stoppedBy: n.stoppedBy } : {}),
         ...(n.partial === true ? { partial: true } : {}),
         ...(typeof n.exitCode === 'number' ? { exitCode: n.exitCode } : {}),
@@ -422,6 +425,7 @@ export function enqueuePlanReviewOutcome(value, meta) {
         queuePortMisses++;
         return false;
     }
+    const questionId = meta === undefined ? undefined : guardedRead(() => readOwnDataNonEmptyString(meta, 'questionId'));
     p.enqueueMetaPrompt({
         value,
         mode: 'prompt',
@@ -436,12 +440,34 @@ export function enqueuePlanReviewOutcome(value, meta) {
                     decision: meta.decision,
                     effect: meta.effect,
                     ...(meta.effect === 'still_parked' && meta.cause === 'stored_form_unsupported' ? { cause: meta.cause } : {}),
+                    ...(questionId !== undefined ? { questionId } : {}),
                 }),
             }
             : {}),
     });
     return true;
 }
+export function resupplyTruncatedSentence(facts, lang) {
+    try {
+        const f = resupplyTruncatedFactsOf(facts);
+        if (f === undefined)
+            return undefined;
+        const count = f.droppedKeys.length;
+        return renderMessage(msg(count === 1 ? 'notice.resupply.truncated.one' : 'notice.resupply.truncated.other', count === 1 ? { bytes: f.bytes } : { bytes: f.bytes, count }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resupplyTruncatedArmBody(carrier, source, taskId) {
+    const facts = resupplyTruncatedOf(carrier);
+    if (facts === undefined)
+        return undefined;
+    const text = resupplyTruncatedSentence(facts);
+    if (text === undefined)
+        return undefined;
+    return { source, taskId, bytes: facts.bytes, droppedKeys: facts.droppedKeys, text };
+}
 export function dropQueuedNotificationsForRun(taskId) {
     const needle = `<${TASK_ID_TAG}>${escapeXml(taskId)}</${TASK_ID_TAG}>`;
     const p = port();
@@ -494,20 +520,25 @@ export function workflowRunTerminalReadingOf(body) {
     if (isCoreWorkflowRunParkedEnd(status, guardedRead(() => readOwnDataValue(snap, 'errorCode'))))
         return Object.freeze({ state: 'awaiting approval' });
     const result = guardedRead(() => readOwnDataValue(snap, 'result'));
-    const error = status === 'failed' ? guardedRead(() => readOwnDataValue(snap, 'error')) : undefined;
-    const shownError = typeof error === 'string' && error.length > 0 ? shownRunError(error) : '';
+    const shownError = failureReasonOf(status, guardedRead(() => readOwnDataValue(snap, 'error')));
+    const resultFull = guardedRead(() => readOwnDataValue(snap, 'resultFull'));
     return Object.freeze({
         state: status,
         ...(typeof result === 'string' && result.length > 0 ? { result } : {}),
-        ...(shownError.length > 0 ? { error: shownError } : {}),
+        ...(shownError !== undefined ? { error: shownError } : {}),
         pointer: 'absent',
+        ...(typeof resultFull === 'string' && resultFull.length > 0 ? { truncated: true } : {}),
     });
 }
 const WORKFLOW_RUN_ERROR_MAX = 200;
 function shownRunError(raw) {
-    const opts = { foldLines: false, escapeBackslashes: 'auto' };
-    const whole = displayUntrusted(raw, opts);
-    return whole.length <= WORKFLOW_RUN_ERROR_MAX ? whole : `${displayUntrusted(raw, { ...opts, max: WORKFLOW_RUN_ERROR_MAX - 1 })}…`;
+    return displayUntrustedCapped(raw, WORKFLOW_RUN_ERROR_MAX, { foldLines: false, escapeBackslashes: 'auto' });
+}
+function failureReasonOf(status, raw) {
+    if (status !== 'failed' || typeof raw !== 'string' || raw.length === 0)
+        return undefined;
+    const shown = shownRunError(raw);
+    return shown.length > 0 ? shown : undefined;
 }
 function workflowPollDecisionOf(delivered, reading) {
     if (delivered)
@@ -518,7 +549,13 @@ function workflowPollDecisionOf(delivered, reading) {
         return { act: 'wait', why: 'awaiting approval' };
     if (reading.state === 'unknown')
         return { act: 'wait', why: 'unknown' };
-    return { act: 'emit', status: reading.state, ...(reading.result !== undefined ? { result: reading.result } : {}), ...(reading.error !== undefined ? { error: reading.error } : {}) };
+    return {
+        act: 'emit',
+        status: reading.state,
+        ...(reading.result !== undefined ? { result: reading.result } : {}),
+        ...(reading.error !== undefined ? { error: reading.error } : {}),
+        ...(reading.truncated === true ? { truncated: true } : {}),
+    };
 }
 function workflowPollCompletionSummary(status, error) {
     const head = `workflow ${status} (read from its run record; no handle to the full record is available)`;
@@ -826,7 +863,7 @@ async function tickWatchInner(now) {
             if (outstandingRuns.delete(runId))
                 notifyOutstanding();
             if (decision.act === 'emit') {
-                enqueueWorkflowCompletion({ runId, status: decision.status, summary: workflowPollCompletionSummary(decision.status, decision.error) }, { ...(decision.result !== undefined ? { result: decision.result } : {}), ...(decision.error !== undefined ? { error: decision.error } : {}) });
+                enqueueWorkflowCompletion({ runId, status: decision.status, summary: workflowPollCompletionSummary(decision.status, decision.error) }, { ...(decision.result !== undefined ? { result: decision.result } : {}), ...(decision.error !== undefined ? { error: decision.error } : {}) }, { truncated: decision.truncated === true });
             }
         }
         catch {
@@ -890,9 +927,17 @@ export function enqueueEngineWorkflowNotification(raw) {
         traceNotif('workflow-notification dropped:payload-unreadable');
         return;
     }
-    enqueueWorkflowCompletion(c, completionIdOnly(workflowCompletionExtrasOf(c)));
+    const extras = workflowCompletionExtrasOf(c);
+    if (notifiedRunIds.has(c.runId)) {
+        const supplement = takeWorkflowPointerSupplement(c.runId, c.status, extras.diagnostics, extras.completionId);
+        if (supplement !== undefined) {
+            port()?.enqueuePendingNotification(taskNotificationQueueCommand(supplement));
+            return;
+        }
+    }
+    enqueueWorkflowCompletion(c, completionIdOnly(extras));
 }
-function enqueueWorkflowCompletion(c, body) {
+function enqueueWorkflowCompletion(c, body, poll) {
     if (notifiedRunIds.has(c.runId)) {
         workflowDedupDropped++;
         traceNotif(`workflow notification suppressed (run already notified) runId=${c.runId} status=${c.status}`);
@@ -900,11 +945,68 @@ function enqueueWorkflowCompletion(c, body) {
     }
     markRunNotified(c.runId);
     cardEnqueuedRunIds.add(c.runId);
+    if (poll !== undefined)
+        notePointerOwed(c.runId, poll.truncated);
     port()?.enqueuePendingNotification(taskNotificationQueueCommand({ taskId: c.runId, taskType: 'workflow', status: c.status, summary: c.summary, ...body }));
 }
+const pointerOwedRuns = new Map();
+const POINTER_OWED_MAX = 512;
+function notePointerOwed(runId, truncated) {
+    pointerOwedRuns.delete(runId);
+    pointerOwedRuns.set(runId, { truncated });
+    while (pointerOwedRuns.size > POINTER_OWED_MAX) {
+        const oldest = pointerOwedRuns.keys().next();
+        if (oldest.done === true)
+            break;
+        pointerOwedRuns.delete(oldest.value);
+    }
+}
+const WORKFLOW_RECORD_REF_SENTENCE = /Full record \(the result and every agent's row\): read it with ReadToolResult \(ref "([A-Za-z0-9_.~-]{1,518})"\) before assuming an empty or unexpected result\./g;
+export function workflowRecordRefOf(diagnostics) {
+    if (typeof diagnostics !== 'string' || diagnostics.length === 0)
+        return undefined;
+    try {
+        let ref;
+        for (const m of diagnostics.matchAll(WORKFLOW_RECORD_REF_SENTENCE))
+            ref = m[1];
+        return ref;
+    }
+    catch {
+        return undefined;
+    }
+}
+function workflowPointerSupplementSummary(ref, truncated) {
+    const head = `Full record of this workflow run (the result and every agent's row): read it with ReadToolResult (ref "${ref}")`;
+    return truncated ? `${head} — the result delivered earlier was cut short; the full text is in this record.` : `${head}.`;
+}
+export function takeWorkflowPointerSupplement(runId, status, diagnostics, completionId) {
+    try {
+        const owed = pointerOwedRuns.get(runId);
+        if (owed === undefined)
+            return undefined;
+        const ref = workflowRecordRefOf(diagnostics);
+        if (ref === undefined)
+            return undefined;
+        pointerOwedRuns.delete(runId);
+        return freezeTaskNotificationFields({
+            taskId: runId,
+            taskType: 'workflow',
+            status,
+            summary: workflowPointerSupplementSummary(ref, owed.truncated),
+            ...(completionId !== undefined ? { completionId } : {}),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function settleWorkflowPointerOwed(runId) {
+    pointerOwedRuns.delete(runId);
+}
 export function _resetEngineTaskNotificationForTest() {
     notifiedRunIds.clear();
     notifiedBgCycleHigh.clear();
+    pointerOwedRuns.clear();
     cardEnqueuedRunIds.clear();
     outstandingRuns.clear();
     outstandingBgTasks.clear();

package/dist/ownKey.d.ts

@@ -79,3 +79,9 @@ export declare function workflowCompletionExtrasOf(c: object): {
     completionId?: string;
     diagnostics?: string;
 };
+export interface ResupplyTruncatedFacts {
+    readonly bytes: number;
+    readonly droppedKeys: readonly string[];
+}
+export declare function resupplyTruncatedFactsOf(slot: {} | null | undefined): ResupplyTruncatedFacts | undefined;
+export declare function resupplyTruncatedOf(carrier: object | null | undefined): ResupplyTruncatedFacts | undefined;

package/dist/ownKey.js

@@ -453,3 +453,34 @@ export function workflowCompletionExtrasOf(c) {
         ...(diagnostics !== undefined ? { diagnostics } : {}),
     };
 }
+const DROPPED_KEYS_MAX = 256;
+const DROPPED_KEY_NAME_MAX = 128;
+export function resupplyTruncatedFactsOf(slot) {
+    try {
+        if (typeof slot !== 'object' || slot === null || Array.isArray(slot))
+            return undefined;
+        const bytes = guardedRead(() => readOwnDataValue(slot, 'bytes'));
+        if (typeof bytes !== 'number' || !Number.isSafeInteger(bytes) || bytes <= 0)
+            return undefined;
+        const keys = guardedRead(() => readOwnDataValue(slot, 'droppedKeys'));
+        if (!Array.isArray(keys))
+            return undefined;
+        const length = guardedRead(() => keys.length);
+        if (typeof length !== 'number' || length < 1 || length > DROPPED_KEYS_MAX)
+            return undefined;
+        const names = [];
+        for (let i = 0; i < length; i++) {
+            const name = guardedRead(() => readOwnDataValue(keys, String(i)));
+            if (typeof name !== 'string' || name.length === 0 || name.length > DROPPED_KEY_NAME_MAX)
+                return undefined;
+            appendOwnElement(names, name);
+        }
+        return Object.freeze({ bytes, droppedKeys: Object.freeze(names) });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resupplyTruncatedOf(carrier) {
+    return resupplyTruncatedFactsOf(guardedRead(() => readOwnDataValue(carrier, 'payloadTruncated')));
+}

package/dist/pendingUserRow.d.ts

@@ -0,0 +1,4 @@
+export declare const PENDING_USER_ROW_ID_PREFIX = "pending-";
+export declare function pendingUserRowIdOf(uuid: string): string | undefined;
+export declare function pendingUserRowUuidOf(id: string | null | undefined): string | undefined;
+export declare function isPendingUserRowId(id: string | null | undefined): boolean;

package/dist/pendingUserRow.js

@@ -0,0 +1,16 @@
+export const PENDING_USER_ROW_ID_PREFIX = 'pending-';
+const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export function pendingUserRowIdOf(uuid) {
+    if (typeof uuid !== 'string' || !UUID_V4.test(uuid))
+        return undefined;
+    return PENDING_USER_ROW_ID_PREFIX + uuid;
+}
+export function pendingUserRowUuidOf(id) {
+    if (typeof id !== 'string' || !id.startsWith(PENDING_USER_ROW_ID_PREFIX))
+        return undefined;
+    const uuid = id.slice(PENDING_USER_ROW_ID_PREFIX.length);
+    return pendingUserRowIdOf(uuid) === id ? uuid : undefined;
+}
+export function isPendingUserRowId(id) {
+    return pendingUserRowUuidOf(id) !== undefined;
+}

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", "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,