@sema-agent/client-core 0.78.1 → 0.79.0

package/dist/adapt/arms.js

@@ -509,6 +509,7 @@ const toolEndResultArm = function* (m, { ctx, idOf, cards, panel }) {
     const closeParentRaw = m.parentToolCallId;
     const closeEventId = typeof closeEventIdRaw === 'string' ? closeEventIdRaw : undefined;
     const closeParent = typeof closeParentRaw === 'string' ? closeParentRaw : undefined;
+    const closeDenialKindRaw = m._sema_denial_kind;
     yield* cards.close(p, {
         output: m.output,
         structured,
@@ -516,6 +517,7 @@ const toolEndResultArm = function* (m, { ctx, idOf, cards, panel }) {
         isError: m.isError === true,
         eventId: closeEventId,
         parentToolCallId: closeParent,
+        ...(typeof closeDenialKindRaw === 'string' ? { denialKind: closeDenialKindRaw } : {}),
     });
     const s = structured !== undefined && structured !== null && typeof structured === 'object'
         ? structured
@@ -656,6 +658,11 @@ const streamEventArm = function* (m, { text }) {
 const turnUsageArm = function* (m, { text, flags }) {
     const ot = typeof m.outputTokens === 'number' ? m.outputTokens : undefined;
     yield* text.drainLive();
+    if (!isSubFlowSegmentEnd(m)) {
+        yield* text.takeAnswerSegment();
+        text.beginAssistantMessage();
+        text.closeSegmentAuthorityWindowOnNextText();
+    }
     if (ot !== undefined) {
         yield* flags.emitTurnUsageEnd(ot);
     }

package/dist/adapt/textStream.d.ts

@@ -32,6 +32,7 @@ export interface TextStream {
     readonly committedAnswerText: string;
     readonly lastCommittedAnswerText: string;
     beginAssistantMessage(): void;
+    closeSegmentAuthorityWindowOnNextText(): void;
     replaceThinkingSegment(content: string, anchor?: Frame): ThinkingSegmentReplacement;
     segmentId(): string;
     rotateSegmentIdentity(anchor: Frame): void;

package/dist/adapt/textStream.js

@@ -37,6 +37,7 @@ export function createTextStream(ctx, idOf) {
     let idleFlushUsedInSegment = false;
     let segmentCommitted = '';
     let previousSegmentCommitted = '';
+    let segmentWindowCloseArmed = false;
     let segmentSealed = '';
     const flushEveryMs = typeof ctx.coalesceIntervalMs === 'number' && ctx.coalesceIntervalMs >= 0
         ? ctx.coalesceIntervalMs
@@ -145,6 +146,12 @@ export function createTextStream(ctx, idOf) {
     }
     return {
         *feedText(delta, frame) {
+            if (segmentWindowCloseArmed) {
+                segmentWindowCloseArmed = false;
+                previousSegmentCommitted = '';
+                segmentCommitted = '';
+                committedTextRows = [];
+            }
             if (thinking.length > 0 || thinkingPending.length > 0) {
                 yield* drainLive();
                 yield* takeThinking();
@@ -372,6 +379,9 @@ export function createTextStream(ctx, idOf) {
             previousSegmentCommitted += segmentCommitted;
             segmentCommitted = '';
         },
+        closeSegmentAuthorityWindowOnNextText: () => {
+            segmentWindowCloseArmed = true;
+        },
         get committedAnswerText() {
             return committedText;
         },

package/dist/adapt/toolCards.d.ts

@@ -14,6 +14,7 @@ export interface ToolEndPayload {
     isError?: boolean;
     eventId?: string | undefined;
     parentToolCallId?: string | undefined;
+    denialKind?: string | undefined;
 }
 export interface OpenCardView {
     has(id: string): boolean;

package/dist/adapt/toolCards.js

@@ -2,6 +2,7 @@ import { deriveTranscriptId } from '../seam.js';
 import { degradedToolResultBody, detectEngineBgShellReceipt, reportFindingsToolUseResult, structuredToToolUseResult, todoWriteToolUseResult, wireOutputToBody, } from '../toolResult.js';
 import { chrome, mainLane, transcript } from './ids.js';
 import { flattenWireOutput } from './wireShapes.js';
+import { isCcToolDenialKind } from '../gateVocabulary.js';
 export function createToolCardLedger(ctx, idOf) {
     const pending = new Map();
     let assistantResponseId = null;
@@ -50,6 +51,7 @@ export function createToolCardLedger(ctx, idOf) {
             ...(parentToolCallId !== undefined ? { parent_tool_use_id: parentToolCallId } : {}),
             toolUseResult: rich !== null ? rich.toolUseResult : (body.toolUseResult ?? body.content),
             ...(body.degraded !== undefined ? { _sema_degraded: body.degraded } : {}),
+            ...(isCcToolDenialKind(end?.denialKind) ? { _sema_denial_kind: end.denialKind } : {}),
         }, ctx.now());
     }
     function* closeCard(p, end) {

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -2,6 +2,7 @@ import { wiringManifestViewOf } from './wiringManifestView.js';
 import { stamp, snapshotSegmentIdentity, } from '../types.js';
 import { turnUsageToModelUsage } from './turnUsageToModelUsage.js';
 import { gateOutcomeOf } from '../../gateOutcome.js';
+import { isCcToolDenialKind } from '../../gateVocabulary.js';
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { readMcpLiveness } from '../../mcpLiveness.js';
 import { SEGMENT_END_IDENTITY_KEYS } from '../types.js';
@@ -170,6 +171,8 @@ export function eventToSdkMessage(ev, ctx) {
             const toolEndDelivered = ev.delivered;
             const toolEndGatedCallId = ev.gatedCallId;
             const collateralAbort = ev._sema_collateral_abort;
+            const denialKindRaw = ev._sema_denial_kind;
+            const denialKind = isCcToolDenialKind(denialKindRaw) ? denialKindRaw : undefined;
             return projected(stamp(ctx, armBody({
                 type: 'tool_end_result',
                 toolCallId: ev.toolCallId,
@@ -190,6 +193,7 @@ export function eventToSdkMessage(ev, ctx) {
                     ? { gatedCallId: toolEndGatedCallId }
                     : {}),
                 ...(collateralAbort === true ? { _sema_collateral_abort: true } : {}),
+                ...(denialKind !== undefined ? { _sema_denial_kind: denialKind } : {}),
                 ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
                 ...(ev.parentToolCallId !== undefined
                     ? { parentToolCallId: ev.parentToolCallId }

package/dist/adapter/downstream/terminalToSdkResult.d.ts

@@ -1,4 +1,5 @@
-import type { AgentEvent, TaskStats } from '@sema-agent/sdk';
+import type { AgentEvent, DeniedBy, TaskStats } from '@sema-agent/sdk';
+import { type CcToolDenialKind } from '../../gateVocabulary.js';
 import { type SDKMessage, type EmitContext } from '../types.js';
 import { type SemaModelUsage } from './turnUsageToModelUsage.js';
 export interface SemaFlatUsage {
@@ -15,6 +16,10 @@ export interface TerminalStreamObserved {
     readonly usageMissingObserved?: boolean;
     readonly nestedUsageByTask?: ReadonlyMap<string, MutableSubagentUsageRow>;
     readonly toolInputByCallId?: ReadonlyMap<string, unknown>;
+    readonly gateDeniedByByCallId?: ReadonlyMap<string, string>;
+    readonly denialKindByCallId?: ReadonlyMap<string, string>;
+    readonly successfulToolEndObserved?: boolean;
+    readonly streamSawRunOpen?: boolean;
 }
 export declare const TOOL_INPUT_JOIN_MAX_CALLS = 4096;
 export interface SemaPermissionDenial {
@@ -23,6 +28,9 @@ export interface SemaPermissionDenial {
     readonly tool_input?: Record<string, unknown>;
     readonly _sema_tool_input_source?: 'tool_start';
     readonly _sema_tool_arg?: string;
+    readonly deniedBy?: DeniedBy;
+    readonly _sema_denied_by_source?: 'tool_end';
+    readonly toolDenialKind?: CcToolDenialKind;
 }
 export interface SemaCostBreakdown {
     readonly llmRootMicroUsd?: number;

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -1,3 +1,4 @@
+import { isCcToolDenialKind, isGateDeniedByWord } from '../../gateVocabulary.js';
 import { stamp } from '../types.js';
 import { putOwnKey } from '../../ownKey.js';
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
@@ -59,7 +60,10 @@ function joinableToolInput(args) {
 }
 const GATE_DENIED_DECISIONS = new Set(['deny']);
 const GATE_NON_DENIAL_DECISIONS = new Set(['allow', 'approve', 'edit', 'reject']);
-function permissionDenialParts(stats, toolInputByCallId) {
+function permissionDenialParts(stats, observed) {
+    const toolInputByCallId = observed?.toolInputByCallId;
+    const gateDeniedByByCallId = observed?.gateDeniedByByCallId;
+    const denialKindByCallId = observed?.denialKindByCallId;
     const hr = stats?.humanReview;
     const gates = hr !== null && typeof hr === 'object' ? hr.gates : undefined;
     if (!Array.isArray(gates))
@@ -93,20 +97,42 @@ function permissionDenialParts(stats, toolInputByCallId) {
             ? joinableToolInput(toolInputByCallId.get(toolUseId))
             : undefined;
         const toolInput = ledgerInput ?? joinedInput;
+        const ledgerDeniedByRaw = row.deniedBy;
+        const ledgerDeniedBy = typeof ledgerDeniedByRaw === 'string' && isGateDeniedByWord(ledgerDeniedByRaw)
+            ? ledgerDeniedByRaw
+            : undefined;
+        const joinedDeniedByRaw = ledgerDeniedBy === undefined && toolUseId !== undefined && gateDeniedByByCallId?.has(toolUseId) === true
+            ? gateDeniedByByCallId.get(toolUseId)
+            : undefined;
+        const joinedDeniedBy = typeof joinedDeniedByRaw === 'string' && isGateDeniedByWord(joinedDeniedByRaw)
+            ? joinedDeniedByRaw
+            : undefined;
+        const deniedBy = ledgerDeniedBy ?? joinedDeniedBy;
+        const joinedKindRaw = toolUseId !== undefined && denialKindByCallId?.has(toolUseId) === true
+            ? denialKindByCallId.get(toolUseId)
+            : undefined;
+        const toolDenialKind = isCcToolDenialKind(joinedKindRaw) ? joinedKindRaw : undefined;
         denials.push({
             ...(toolName !== undefined ? { tool_name: toolName } : {}),
             ...(toolUseId !== undefined ? { tool_use_id: toolUseId } : {}),
             ...(toolInput !== undefined ? { tool_input: toolInput } : {}),
             ...(joinedInput !== undefined ? { _sema_tool_input_source: 'tool_start' } : {}),
+            ...(deniedBy !== undefined ? { deniedBy } : {}),
+            ...(joinedDeniedBy !== undefined && ledgerDeniedBy === undefined
+                ? { _sema_denied_by_source: 'tool_end' }
+                : {}),
+            ...(toolDenialKind !== undefined ? { toolDenialKind } : {}),
             ...(toolArg !== undefined ? { _sema_tool_arg: toolArg } : {}),
         });
     }
     const ccList = denials.filter((d) => d.tool_name !== undefined && d.tool_use_id !== undefined && d.tool_input !== undefined);
     const claimable = complete && ccList.length === denials.length;
+    const zeroOutputDenied = denials.length > 0 && observed?.streamSawRunOpen === true && observed.successfulToolEndObserved === false;
     return {
         permission_denials: ccList,
         ...(denials.length > 0 ? { _sema_permission_denials: denials } : {}),
         ...(claimable ? {} : { _sema_permission_denials_absent: true }),
+        ...(zeroOutputDenied ? { _sema_zero_output_denied: true } : {}),
     };
 }
 const putOwn = putOwnKey;
@@ -366,7 +392,7 @@ function errorResult(ctx, parts) {
         total_cost_usd: costOrNull(parts.stats),
         usage: flattenUsage(parts.stats),
         modelUsage: modelUsageFor(parts.stats, parts.model),
-        ...permissionDenialParts(parts.stats, parts.observed?.toolInputByCallId),
+        ...permissionDenialParts(parts.stats, parts.observed),
         ...costFactParts(parts.stats, parts.observed),
         ...(parts.facts ?? {}),
         ...nestedUsageByTaskParts(parts.stats, parts.observed?.nestedUsageByTask),
@@ -486,7 +512,7 @@ export function doneToSdkResult(ev, ctx, observed) {
         total_cost_usd: costOrNull(stats),
         usage: flattenUsage(stats),
         modelUsage: modelUsageFor(stats, r.model),
-        ...permissionDenialParts(stats, observed?.toolInputByCallId),
+        ...permissionDenialParts(stats, observed),
         ...costFactParts(stats, observed),
         ...effectiveFactParts(rec),
         ...nestedUsageByTaskParts(stats, observed?.nestedUsageByTask),

package/dist/adapter/runStream.js

@@ -5,6 +5,8 @@ import { readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from
 import { coerceOutput, publishSubagentContentEvent } from '../subagentContentStore.js';
 import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isLimitsExceededCode } from '../engineErrorCodes.js';
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
+import { gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
+import { isCcToolDenialKind, isGateDeniedByWord } from '../gateVocabulary.js';
 const mainLane = () => ({ lane: 'main' });
 function emitChromeFireAndForget(ctx, event) {
     try {
@@ -178,6 +180,12 @@ async function* runStreamInner(events, ctx, handle = {}) {
     const toolInputByCallId = new Map();
     const toolInputAmbiguous = new Set();
     let toolInputOverflowed = false;
+    const gateDeniedByByCallId = new Map();
+    const denialKindByCallId = new Map();
+    const denialAmbiguous = new Set();
+    let denialJoinOverflowed = false;
+    let successfulToolEndObserved = false;
+    let streamSawRunOpen = false;
     const sameArgs = (a, b) => {
         if (a === b)
             return true;
@@ -189,6 +197,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
         }
     };
     for await (const ev of events) {
+        if (ev.type === 'tool_end' && ev.isError !== true)
+            successfulToolEndObserved = true;
         const seq = eventSeq(ev);
         if (seq !== undefined) {
             if (seen.has(seq)) {
@@ -213,6 +223,43 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 }
             }
         }
+        if (ev.type === 'meta')
+            streamSawRunOpen = true;
+        if (ev.type === 'tool_end') {
+            const endCallId = ev.toolCallId;
+            if (typeof endCallId === 'string' && endCallId.length > 0) {
+                const deniedByRaw = gateDeniedBy(gateOutcomeOf(ev));
+                const deniedBy = isGateDeniedByWord(deniedByRaw) ? deniedByRaw : undefined;
+                const kindRaw = ev._sema_denial_kind;
+                const kind = isCcToolDenialKind(kindRaw) ? kindRaw : undefined;
+                if (deniedBy !== undefined || kind !== undefined) {
+                    const isNew = (deniedBy !== undefined && !gateDeniedByByCallId.has(endCallId)) ||
+                        (kind !== undefined && !denialKindByCallId.has(endCallId));
+                    if (isNew &&
+                        (gateDeniedByByCallId.size >= TOOL_INPUT_JOIN_MAX_CALLS ||
+                            denialKindByCallId.size >= TOOL_INPUT_JOIN_MAX_CALLS)) {
+                        denialJoinOverflowed = true;
+                    }
+                    if (!denialJoinOverflowed && !denialAmbiguous.has(endCallId)) {
+                        const seenDeniedBy = gateDeniedByByCallId.get(endCallId);
+                        const seenKind = denialKindByCallId.get(endCallId);
+                        const conflict = (deniedBy !== undefined && seenDeniedBy !== undefined && seenDeniedBy !== deniedBy) ||
+                            (kind !== undefined && seenKind !== undefined && seenKind !== kind);
+                        if (conflict) {
+                            gateDeniedByByCallId.delete(endCallId);
+                            denialKindByCallId.delete(endCallId);
+                            denialAmbiguous.add(endCallId);
+                        }
+                        else {
+                            if (deniedBy !== undefined && seenDeniedBy === undefined)
+                                gateDeniedByByCallId.set(endCallId, deniedBy);
+                            if (kind !== undefined && seenKind === undefined)
+                                denialKindByCallId.set(endCallId, kind);
+                        }
+                    }
+                }
+            }
+        }
         if ((ev.type === 'text_delta' ||
             ev.type === 'reasoning_delta' ||
             ev.type === 'text' ||
@@ -254,8 +301,10 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 reportDroppedFrame('turn_end_usage_absent', ev.type, ctx);
                 continue;
             }
-            const isSubFlow = ev.parentToolCallId !== undefined ||
-                ev.sourceTaskId !== undefined;
+            const identityEnvelope = ev;
+            const isSubFlow = identityEnvelope.parentToolCallId !== undefined ||
+                identityEnvelope.sourceTaskId !== undefined ||
+                identityEnvelope.bgAgentId !== undefined;
             {
                 if (measured !== undefined) {
                     handle.latestUsage = usage;
@@ -379,7 +428,15 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     emitChromeFireAndForget(ctx, { kind: 'run_cost_reconciled', laneProof: mainLane(), ...costFacts.reconcile });
                 }
             }
-            const resultFrame = terminalToSdkResult(ev, ctx, { usageMissingObserved, nestedUsageByTask, toolInputByCallId });
+            const resultFrame = terminalToSdkResult(ev, ctx, {
+                usageMissingObserved,
+                nestedUsageByTask,
+                toolInputByCallId,
+                gateDeniedByByCallId,
+                denialKindByCallId,
+                successfulToolEndObserved,
+                streamSawRunOpen,
+            });
             const outcome = resultFrame.
                 _sema_outcome;
             if (outcome === 'unknown') {

package/dist/agentSession/contract.d.ts

@@ -1,4 +1,5 @@
 import type { AgentClient, AgentClientConfig } from '@sema-agent/sdk';
+import type { RequestLane } from '../request/taskRequest.js';
 export interface ProvidedClientWire {
     readonly client: AgentClient;
     readonly baseUrl: string;
@@ -24,7 +25,7 @@ export interface AgentSessionIdentity {
 }
 export interface AgentSessionConfig {
     readonly wire: AgentSessionWire;
-    readonly lane: 'interactive' | 'print';
+    readonly lane: Exclude<RequestLane, 'utility'>;
     readonly hostSurface: AgentSessionHostSurface;
     readonly sessionKey?: string;
 }

package/dist/engineNoticeCodes.js

@@ -51,6 +51,7 @@ export const ENGINE_NOTICE_CODES = Object.freeze([
     'memory.consolidation_refused',
     'memory.consolidation_withheld',
     'memory.restore_withheld',
+    'memory.project_scope_absent',
     'route.fallback_to_primary',
     'route.classifier_unroutable',
     'route.base_url_changed_key_unchanged',
@@ -124,6 +125,7 @@ export const ENGINE_NOTICE_AUDIENCE = Object.freeze({
     'memory.consolidation_refused': 'operator',
     'memory.consolidation_withheld': 'operator',
     'memory.restore_withheld': 'operator',
+    'memory.project_scope_absent': 'operator',
     'route.fallback_to_primary': 'operator',
     'route.classifier_unroutable': 'operator',
     'route.base_url_changed_key_unchanged': 'operator',

package/dist/gateVocabulary.d.ts

@@ -1,5 +1,10 @@
 import type { DeniedBy } from '@sema-agent/sdk';
+export declare const CC_TOOL_DENIAL_KINDS: readonly ["user-rejected", "permission-rule", "automode-blocked", "automode-unavailable", "automode-parsing-error", "interrupted", "cancelled"];
+export type CcToolDenialKind = (typeof CC_TOOL_DENIAL_KINDS)[number];
+export declare function isCcToolDenialKind(v: unknown): v is CcToolDenialKind;
+export declare function isCcToolDenialKindADenial(v: unknown): boolean;
 export declare const GATE_DENIED_BY_WORDS: readonly DeniedBy[];
+export declare function isGateDeniedByWord(v: unknown): v is DeniedBy;
 export declare function gateDeniedByDetail(deniedBy: unknown): string;
 export declare const ASK_ORIGIN_WORDS: readonly string[];
 export declare function askOriginDetail(origin: unknown, message?: unknown): string;
@@ -7,3 +12,4 @@ export declare const RULE_STORE_UNREADABLE_KINDS: readonly ["store", "call"];
 export type RuleStoreUnreadableKind = (typeof RULE_STORE_UNREADABLE_KINDS)[number];
 export declare function isRuleStoreUnreadableKind(v: unknown): v is RuleStoreUnreadableKind;
 export declare function ruleStoreUnreadableDetail(kind: RuleStoreUnreadableKind): string;
+export declare function mandatedApprovalDetail(): string;

package/dist/gateVocabulary.js

@@ -1,3 +1,18 @@
+export const CC_TOOL_DENIAL_KINDS = Object.freeze([
+    'user-rejected',
+    'permission-rule',
+    'automode-blocked',
+    'automode-unavailable',
+    'automode-parsing-error',
+    'interrupted',
+    'cancelled',
+]);
+export function isCcToolDenialKind(v) {
+    return typeof v === 'string' && CC_TOOL_DENIAL_KINDS.includes(v);
+}
+export function isCcToolDenialKindADenial(v) {
+    return isCcToolDenialKind(v) && v !== 'interrupted' && v !== 'cancelled';
+}
 export const GATE_DENIED_BY_WORDS = Object.freeze([
     'policy',
     'hook',
@@ -22,6 +37,9 @@ const DENIED_BY_SENTENCES = Object.freeze({
     ask_resolution: 'denied when the approval was resolved',
     read_boundary: 'denied by the read boundary',
 });
+export function isGateDeniedByWord(v) {
+    return typeof v === 'string' && GATE_DENIED_BY_WORDS.includes(v);
+}
 export function gateDeniedByDetail(deniedBy) {
     if (typeof deniedBy === 'string' && Object.hasOwn(DENIED_BY_SENTENCES, deniedBy)) {
         return DENIED_BY_SENTENCES[deniedBy];
@@ -90,3 +108,6 @@ export function ruleStoreUnreadableDetail(kind) {
     const word = typeof kind === 'string' && kind.length > 0 ? kind : '(none)';
     return `your standing deny/ask rules could not be applied to this call; the reported reason ${word} is not one of the mechanisms this client's closed set knows, so answer this ask as usual`;
 }
+export function mandatedApprovalDetail() {
+    return 'no saved allow rule and no standing posture can retire this question, so it is asked every time — answering it here settles this one call';
+}

package/dist/hitl/askGateWire.d.ts

@@ -2,9 +2,12 @@ import type { AgentEvent } from '@sema-agent/sdk';
 import { type AskGateWireDeps } from './frameRouter.js';
 export { HITL_REJECT_MESSAGE, ENGINE_ABORT_TOOL_RESULT } from './frameRouter.js';
 export { HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE } from './frameRouter.js';
+export { HITL_POLICY_DENY_MESSAGE } from './frameRouter.js';
 export type { AskGateWireDeps, ParkReattachNotice } from './frameRouter.js';
 export type { AskAnsweredOutput } from './gateLedger.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
+export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
+export type { GateDenyAttribution } from './gateLedger.js';
 export { toAnsweredOutput, isAlreadyResolvedGateReason, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export type { HopBudget, HopRound } from './parkResolver.js';
 export type { GateOutcome, GateFailureCode } from './parkResolver.js';

package/dist/hitl/askGateWire.js

@@ -3,7 +3,9 @@ import { flushHeldWithInterruptRewrite, isHostProgressFrame, routeFrame, } from
 import { resolvePark, nextHopBudget, stalledTerminal, MAX_GATE_HOPS } from './parkResolver.js';
 export { HITL_REJECT_MESSAGE, ENGINE_ABORT_TOOL_RESULT } from './frameRouter.js';
 export { HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE } from './frameRouter.js';
+export { HITL_POLICY_DENY_MESSAGE } from './frameRouter.js';
 export { SEMA_COLLATERAL_ABORT_KEY } from './gateLedger.js';
+export { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 export { toAnsweredOutput, isAlreadyResolvedGateReason, GATE_FAILURE_CODES, nextHopBudget, MAX_GATE_HOPS, MAX_TOTAL_PARKS } from './parkResolver.js';
 export async function* bridgeAskUserQuestionGates(source, deps, opts) {
     const led = createGateLedger();

package/dist/hitl/frameRouter.d.ts

@@ -3,6 +3,7 @@ import type { HitlClientLike } from './hitlBridge.js';
 import { type RespondToolApprovalFn, type ToolApprovalFrame, type ToolApprovalFrameLaneOpts, type ToolApprovalFrameOutcome } from './toolApprovalWire.js';
 import type { GateLedger } from './gateLedger.js';
 export declare const HITL_REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+export declare const HITL_POLICY_DENY_MESSAGE: string;
 export declare const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool use]";
 export declare const ENGINE_ABORT_TOOL_RESULT = "Operation aborted";
 export declare function toolEndOutputText(output: unknown): string | undefined;

package/dist/hitl/frameRouter.js

@@ -4,9 +4,34 @@ import { classifierDenyFromToolEnd } from '../classifierVerdictWire.js';
 import { GATE_PARKED_ERROR_CODE } from '../engineErrorCodes.js';
 import { readRunTerminal, runTerminalCode, runTerminalGateKind, runTerminalGateToolName } from '../runTerminal.js';
 import { surfaceForCurrentSession } from './hitlHostSurface.js';
+import { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 export const HITL_REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
-function rejectMessageForRender() {
-    return HITL_REJECT_MESSAGE;
+export const HITL_POLICY_DENY_MESSAGE = 'Permission for this tool use was denied: it requires interactive approval, and permission prompts are ' +
+    'not available in this session. The action was NOT performed. Do not claim it succeeded, and do not retry ' +
+    'it in this session \u2014 report the limitation to the user, or suggest an alternative.';
+function denyOutputForRender(attribution) {
+    if (attribution?.settledBy !== 'policy')
+        return HITL_REJECT_MESSAGE;
+    const reason = attribution.reason;
+    return reason !== undefined && reason.trim() !== ''
+        ? `${HITL_POLICY_DENY_MESSAGE}\n${reason}`
+        : HITL_POLICY_DENY_MESSAGE;
+}
+function denialKindForTranscript(attribution) {
+    if (attribution?.settledBy === 'human')
+        return 'user-rejected';
+    if (attribution?.settledBy === 'policy')
+        return 'permission-rule';
+    return undefined;
+}
+function denyStampedEnd(ev, attribution) {
+    const kind = denialKindForTranscript(attribution);
+    return {
+        ...ev,
+        output: denyOutputForRender(attribution),
+        structured: undefined,
+        ...(kind !== undefined ? { [SEMA_DENIAL_KIND_KEY]: kind } : {}),
+    };
 }
 export const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool use]';
 const RUN_CANCELLED_ERROR_CODE = 'cancelled';
@@ -146,11 +171,12 @@ const TOOL_END_ARMS = [
         run(ev, callId, led) {
             if (ev.isError !== true || !isDenyStampCandidate(ev) || led.isDenied(callId))
                 return undefined;
-            if (!led.takeDenyStamp())
+            const stamp = led.takeDenyStamp();
+            if (stamp === undefined)
                 return undefined;
             led.markEnded(callId);
             led.dropHeld(callId);
-            return { kind: 'yield', events: [{ ...ev, output: rejectMessageForRender(), structured: undefined }] };
+            return { kind: 'yield', events: [denyStampedEnd(ev, stamp)] };
         },
     },
     {
@@ -158,11 +184,12 @@ const TOOL_END_ARMS = [
         run(ev, callId, led) {
             if (ev.isError !== true || !isGatedToolEnd(ev))
                 return undefined;
-            if (!led.takeDenied(callId))
+            const denial = led.takeDenied(callId);
+            if (denial === undefined)
                 return undefined;
             led.markEnded(callId);
             led.dropHeld(callId);
-            return { kind: 'yield', events: [{ ...ev, output: rejectMessageForRender(), structured: undefined }] };
+            return { kind: 'yield', events: [denyStampedEnd(ev, denial)] };
         },
     },
     {
@@ -238,10 +265,14 @@ async function routeToolApprovalFrame(ev, ctx) {
         }
     }
     if (decision === 'deny' && !fromSubagent) {
+        const attribution = {
+            ...(outcome.denySettledBy !== undefined ? { settledBy: outcome.denySettledBy } : {}),
+            ...(outcome.denyReason !== undefined ? { reason: outcome.denyReason } : {}),
+        };
         if (gatedCallId !== undefined)
-            led.markDenied(gatedCallId);
+            led.markDenied(gatedCallId, attribution);
         else
-            led.armDenyStamp();
+            led.armDenyStamp(attribution);
     }
     return { kind: 'skip' };
 }

package/dist/hitl/gateLedger.d.ts

@@ -1,5 +1,10 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 export declare const SEMA_COLLATERAL_ABORT_KEY = "_sema_collateral_abort";
+export declare const SEMA_DENIAL_KIND_KEY = "_sema_denial_kind";
+export interface GateDenyAttribution {
+    settledBy?: 'human' | 'policy';
+    reason?: string;
+}
 export interface AskAnsweredOutput {
     type: 'ask-user-question';
     questions: unknown[];
@@ -25,11 +30,11 @@ export interface GateLedger {
     dropHeldForDecidedPark(candidateCallId: string | undefined, trustedCallId?: string): void;
     heldCount(): number;
     flushHeld(): Generator<AgentEvent>;
-    markDenied(callId: string): void;
+    markDenied(callId: string, attribution?: GateDenyAttribution): void;
     isDenied(callId: string): boolean;
-    takeDenied(callId: string): boolean;
-    armDenyStamp(): void;
-    takeDenyStamp(): boolean;
+    takeDenied(callId: string): GateDenyAttribution | undefined;
+    armDenyStamp(attribution?: GateDenyAttribution): void;
+    takeDenyStamp(): GateDenyAttribution | undefined;
     pushFsCall(callId: string): void;
     dropFsCall(callId: string): void;
     lastPendingFsCall(): string | undefined;

package/dist/hitl/gateLedger.js

@@ -1,5 +1,15 @@
 export const SEMA_COLLATERAL_ABORT_KEY = '_sema_collateral_abort';
+export const SEMA_DENIAL_KIND_KEY = '_sema_denial_kind';
 export const START_ARGS_MAX_ENTRIES = 256;
+function normalizeDenyAttribution(a) {
+    if (a === undefined)
+        return undefined;
+    const settledBy = a.settledBy === 'human' || a.settledBy === 'policy' ? a.settledBy : undefined;
+    const reason = typeof a.reason === 'string' && a.reason.trim() !== '' ? a.reason : undefined;
+    if (settledBy === undefined && reason === undefined)
+        return undefined;
+    return { ...(settledBy !== undefined ? { settledBy } : {}), ...(reason !== undefined ? { reason } : {}) };
+}
 export function createGateLedger() {
     const startedCalls = new Set();
     const endedCalls = new Set();
@@ -7,6 +17,7 @@ export function createGateLedger() {
     const gatedStartArgsByCall = new Map();
     const startArgsByCall = new Map();
     const deniedCalls = new Set();
+    const denyAttributionByCall = new Map();
     const pendingFsCalls = [];
     const resolvedAnswers = new Map();
     const decidedGates = new Set();
@@ -61,6 +72,7 @@ export function createGateLedger() {
         heldSinceLastPark = false;
     };
     let denyStampNextFsEnd = false;
+    let denyStampAttribution;
     let seq;
     return {
         noteSeq(ev) {
@@ -146,23 +158,35 @@ export function createGateLedger() {
             heldAskEnds.clear();
             retireBatchState();
         },
-        markDenied(callId) {
+        markDenied(callId, attribution) {
             deniedCalls.add(callId);
+            const a = normalizeDenyAttribution(attribution);
+            if (a !== undefined)
+                denyAttributionByCall.set(callId, a);
+            else
+                denyAttributionByCall.delete(callId);
         },
         isDenied(callId) {
             return deniedCalls.has(callId);
         },
         takeDenied(callId) {
-            return deniedCalls.delete(callId);
+            if (!deniedCalls.delete(callId))
+                return undefined;
+            const a = denyAttributionByCall.get(callId);
+            denyAttributionByCall.delete(callId);
+            return a ?? {};
         },
-        armDenyStamp() {
+        armDenyStamp(attribution) {
             denyStampNextFsEnd = true;
+            denyStampAttribution = normalizeDenyAttribution(attribution);
         },
         takeDenyStamp() {
             if (!denyStampNextFsEnd)
-                return false;
+                return undefined;
             denyStampNextFsEnd = false;
-            return true;
+            const a = denyStampAttribution;
+            denyStampAttribution = undefined;
+            return a ?? {};
         },
         pushFsCall(callId) {
             pendingFsCalls.push(callId);

package/dist/hitl/parkResolver.js

@@ -164,7 +164,12 @@ async function surfaceParkGate(park, ctx, gatedCallId, onPresented) {
         const outcome = await surfaceFsApprovalAndDecide({ client: deps.client, ...(onPresented ? { onPresented } : {}) }, taskId, argsByCallOf(led), ctx.signal, gatedCallId);
         const outcomeDenied = 'denied' in outcome ? outcome.denied : undefined;
         if (outcome.kind === 'decided' && outcomeDenied === true && outcome.gatedCallId) {
-            led.markDenied(outcome.gatedCallId);
+            const denySettledBy = 'denySettledBy' in outcome ? outcome.denySettledBy : undefined;
+            const denyReason = 'denyReason' in outcome ? outcome.denyReason : undefined;
+            led.markDenied(outcome.gatedCallId, {
+                ...(denySettledBy !== undefined ? { settledBy: denySettledBy } : {}),
+                ...(denyReason !== undefined ? { reason: denyReason } : {}),
+            });
         }
         return outcome;
     }