@sema-agent/client-core 0.89.0 → 0.91.0

package/dist/displayUntrusted.js

@@ -1473,7 +1473,7 @@ function quotedAddressEnd(S, from, to) {
     }
     return to;
 }
-function labelCandidates(S, pass, regions, out) {
+function labelCandidates(S, pass, regions, out, blocks) {
     const text = S.text;
     const unitAt = (k) => S.unitAt(k);
     const re = pass === 'label' ? SECRET_LABELLED_WORD : SECRET_SCHEME_WORD;
@@ -1642,6 +1642,11 @@ function labelCandidates(S, pass, regions, out) {
         if (schemePass && labelStartsAt(text, hit.index))
             continue;
         const from = hit.index + hit[0].length;
+        if (blocks !== undefined && (text.charCodeAt(from) === 0x7c || text.charCodeAt(from) === 0x3e) && isColonSeparator(hit[0].slice((hit[1] ?? '').length))) {
+            const blk = blockScalarExtent(blocks, S.rawStart(from), S.rawStart(hit.index));
+            if (blk !== null)
+                blocks.out.push({ start: blk.start, end: blk.end, kind: 'secret', cls: 'word', tokenEnd: blk.end, pretrimmed: true });
+        }
         if (credentialWordStartsAt(text, from, idx.tokenInner)) {
             pushInnerRemainder(from);
             re.lastIndex = from;
@@ -1886,6 +1891,149 @@ function lineBreakLengthBefore(text, at) {
         return 2;
     return 0;
 }
+const isRawBlank = (c) => (isRegexSpace(c) && c !== 0xfeff) || isNameBlank(c);
+function isColonSeparator(sep) {
+    let colon = false;
+    for (let k = 0; k < sep.length; k++) {
+        const c = sep.charCodeAt(k);
+        if (c === 0x3d || c === 0xff1d)
+            return false;
+        if (c === 0x3a || c === 0xff1a)
+            colon = true;
+    }
+    return colon;
+}
+function blockBreakAt(raw, at, escaped) {
+    const n = lineBreakLengthAt(raw, at);
+    return n > 0 && (raw.charCodeAt(at) === 0x5c) === escaped ? n : 0;
+}
+function blockMarks(scan) {
+    if (scan.marks !== null)
+        return scan.marks;
+    const V = scan.view;
+    const seq = new Uint8Array(scan.raw.length);
+    const payload = new Uint8Array(scan.raw.length);
+    for (let k = 0; k < V.view.length; k++) {
+        if (V.dropped[k] !== 1 || V.units[k] !== UNIT_SEQUENCE)
+            continue;
+        for (let x = V.starts[k] ?? 0; x < (V.ends[k] ?? 0); x++)
+            seq[x] = 1;
+    }
+    for (const [a, b] of V.contents)
+        for (let x = a; x < b; x++)
+            payload[x] = 1;
+    scan.marks = { seq, payload };
+    return scan.marks;
+}
+function blockLines(scan, escaped) {
+    const slot = escaped ? 1 : 0;
+    const have = scan.lines[slot];
+    if (have !== null)
+        return have;
+    const raw = scan.raw;
+    const unit = scan.view.rawUnit;
+    const { seq, payload } = blockMarks(scan);
+    const starts = [];
+    const ends = [];
+    const indent = [];
+    let pos = 0;
+    for (;;) {
+        let k = pos;
+        let n = 0;
+        let width = 0;
+        let lead = true;
+        let visible = false;
+        while (k < raw.length && (n = blockBreakAt(raw, k, escaped)) === 0) {
+            if (lead) {
+                const c = raw.charCodeAt(k);
+                if (payload[k] === 1)
+                    visible = true;
+                if (seq[k] === 1) {
+                }
+                else if (isRawBlank(c))
+                    width++;
+                else if (unit[k] !== 1) {
+                    visible = true;
+                    lead = false;
+                }
+            }
+            k++;
+        }
+        starts.push(pos);
+        ends.push(k);
+        indent.push(visible ? width : -1);
+        if (k >= raw.length)
+            break;
+        pos = k + n;
+    }
+    const nextContent = new Int32Array(starts.length + 1);
+    nextContent[starts.length] = starts.length;
+    for (let i = starts.length - 1; i >= 0; i--)
+        nextContent[i] = (indent[i] ?? -1) !== -1 ? i : (nextContent[i + 1] ?? starts.length);
+    const built = { starts, ends, indent, nextContent, memo: new Map() };
+    scan.lines[slot] = built;
+    return built;
+}
+function blockLineOf(lines, p) {
+    let lo = 0;
+    let hi = lines.starts.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if ((lines.starts[mid] ?? 0) <= p)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return lo;
+}
+function blockScalarExtent(scan, at, labelAt) {
+    const raw = scan.raw;
+    const mark = raw.charCodeAt(at);
+    if (mark !== 0x7c && mark !== 0x3e)
+        return null;
+    const unit = scan.view.rawUnit;
+    let k = at + 1;
+    while (k < raw.length && lineBreakLengthAt(raw, k) === 0) {
+        const c = raw.charCodeAt(k);
+        if (c === 0x2d || c === 0x2b || (c >= 0x30 && c <= 0x39) || (unit[k] === 1 && !isRawBlank(c)))
+            k++;
+        else
+            break;
+    }
+    while (k < raw.length && lineBreakLengthAt(raw, k) === 0 && (isRawBlank(raw.charCodeAt(k)) || unit[k] === 1))
+        k++;
+    if (k >= raw.length)
+        return null;
+    let escaped;
+    if (lineBreakLengthAt(raw, k) > 0)
+        escaped = raw.charCodeAt(k) === 0x5c;
+    else if (raw.charCodeAt(k) === 0x23) {
+        const real = blockLines(scan, false);
+        if ((real.ends[blockLineOf(real, k)] ?? raw.length) < raw.length)
+            escaped = false;
+        else {
+            const lit = blockLines(scan, true);
+            if ((lit.ends[blockLineOf(lit, k)] ?? raw.length) >= raw.length)
+                return null;
+            escaped = true;
+        }
+    }
+    else
+        return null;
+    const lines = blockLines(scan, escaped);
+    const head = blockLineOf(lines, at);
+    const limit = Math.max(0, lines.indent[blockLineOf(lines, labelAt)] ?? 0);
+    const key = head * (raw.length + 1) + limit;
+    let end = lines.memo.get(key);
+    if (end === undefined) {
+        end = lines.ends[head] ?? raw.length;
+        for (let i = lines.nextContent[head + 1] ?? lines.starts.length; i < lines.starts.length && (lines.indent[i] ?? -1) > limit; i = lines.nextContent[i + 1] ?? lines.starts.length) {
+            end = lines.ends[i] ?? end;
+        }
+        lines.memo.set(key, end);
+    }
+    return { start: at, end };
+}
 function pemBodyEndWithoutTrailer(text, from) {
     let pos = from;
     let inBody = false;
@@ -2779,6 +2927,7 @@ function collectCandidates(text, o, nested) {
     const screen = screenSurfaces(text, o);
     surfaces.push(...screen.surfaces);
     const raw = [];
+    const blocks = { raw: text, view: V, out: raw, lines: [null, null], marks: null };
     const regionSurface = screen.surfaces[0] ?? separated;
     const pemBlocksSeen = [];
     for (const S of surfaces) {
@@ -2792,9 +2941,9 @@ function collectCandidates(text, o, nested) {
         if (o.words) {
             editsToCandidates(pemEdits(S, (blk) => { if (S === regionSurface)
                 pemBlocksSeen.push(pemBlockToRaw(S, blk)); }), 'pem', cands);
-            labelCandidates(S, 'scheme', regions, cands);
-            labelCandidates(S, 'token', regions, cands);
-            labelCandidates(S, 'label', regions, cands);
+            labelCandidates(S, 'scheme', regions, cands, blocks);
+            labelCandidates(S, 'token', regions, cands, blocks);
+            labelCandidates(S, 'label', regions, cands, blocks);
             editsToCandidates(authParamEdits(S.text), 'param', cands);
             editsToCandidates(proseLiteralEdits(S.text), 'prose', cands);
         }

package/dist/engineCapReader.js

@@ -1,4 +1,15 @@
 import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
+function freezeReading(reading, seen = new Set()) {
+    if (reading === null || typeof reading !== 'object' || seen.has(reading))
+        return reading;
+    seen.add(reading);
+    Object.freeze(reading);
+    for (const d of Object.values(Object.getOwnPropertyDescriptors(reading))) {
+        if ('value' in d)
+            freezeReading(d.value, seen);
+    }
+    return reading;
+}
 export function createEngineCapReader(spec) {
     const readingByBase = new Map();
     return {
@@ -23,7 +34,7 @@ export function createEngineCapReader(spec) {
                 readingByBase.delete(baseUrl);
                 return;
             }
-            readingByBase.set(baseUrl, reading);
+            readingByBase.set(baseUrl, freezeReading(reading));
         },
         observed(baseUrl) {
             if (typeof baseUrl !== 'string' || baseUrl === '')

package/dist/engineCapsCache.d.ts

@@ -1,6 +1,8 @@
 export declare function engineCapsGeneration(baseUrl: string): number;
 export declare function kickEngineCapsProbe(baseUrl: string, probe: () => Promise<unknown>): void;
-export declare function engineCapsSettled(baseUrl: string | undefined): Promise<void>;
+export declare function engineCapsSettled(baseUrl: string | undefined, opts?: {
+    withinMs?: number;
+}): Promise<'settled' | 'timed_out'>;
 export type EngineCapState = 'true' | 'false' | 'unprobed' | 'absent' | 'non_boolean';
 export declare function engineCapState(baseUrl: string | undefined, key: string): EngineCapState;
 export declare function engineCapTrue(baseUrl: string | undefined, key: string): boolean;

package/dist/engineCapsCache.js

@@ -43,21 +43,71 @@ export function kickEngineCapsProbe(baseUrl, probe) {
         }
     })();
 }
-export async function engineCapsSettled(baseUrl) {
-    if (!baseUrl)
-        return;
+const MAX_WITHIN_MS = 2_147_483_647;
+function waitBudgetOf(opts) {
+    try {
+        if (opts === undefined || opts === null)
+            return undefined;
+        if (typeof opts !== 'object')
+            return 0;
+        const v = opts.withinMs;
+        if (v === undefined)
+            return undefined;
+        if (typeof v !== 'number' || !Number.isFinite(v) || !(v > 0))
+            return 0;
+        return v > MAX_WITHIN_MS ? MAX_WITHIN_MS : v;
+    }
+    catch {
+        return 0;
+    }
+}
+async function relaySettled(baseUrl, deadline) {
     for (;;) {
         const entry = settleByBase.get(baseUrl);
         if (entry === undefined)
-            return;
+            return 'settled';
         const awaitedGen = entry.gen;
-        await Promise.race([
+        const landed = Promise.race([
             entry.promise.then(() => undefined, () => undefined),
             entry.superseded,
         ]);
+        if (deadline === undefined) {
+            await landed;
+        }
+        else {
+            const first = await Promise.race([landed.then(() => 'landed'), deadline]);
+            if (first === 'timed_out')
+                return 'timed_out';
+        }
         const next = settleByBase.get(baseUrl);
         if (next === undefined || next.gen <= awaitedGen)
-            return;
+            return 'settled';
+    }
+}
+export async function engineCapsSettled(baseUrl, opts) {
+    const budget = waitBudgetOf(opts);
+    if (!baseUrl)
+        return 'settled';
+    if (budget === undefined)
+        return relaySettled(baseUrl, undefined);
+    if (settleByBase.get(baseUrl) === undefined)
+        return 'settled';
+    if (budget === 0)
+        return 'timed_out';
+    let timer;
+    try {
+        const deadline = new Promise((resolve) => {
+            timer = setTimeout(() => resolve('timed_out'), budget);
+        });
+        deadline.catch(() => undefined);
+        return await relaySettled(baseUrl, deadline);
+    }
+    catch {
+        return 'timed_out';
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
     }
 }
 export function engineCapState(baseUrl, key) {

package/dist/engineClosedSets.d.ts

@@ -0,0 +1,2 @@
+export declare const ASK_EVIDENCE_ABSENCE_VALUES: readonly ["not_wired", "not_adjudicated", "unavailable", "no_match", "not_reported"];
+export declare const SYSTEM_INJECTION_PRIORITIES: readonly ["now", "next", "later"];

package/dist/engineClosedSets.js

@@ -0,0 +1,3 @@
+import { CORE_ASK_EVIDENCE_ABSENCE_VALUES, CORE_SYSTEM_INJECTION_PRIORITIES } from './generated/engineFactTables.js';
+export const ASK_EVIDENCE_ABSENCE_VALUES = CORE_ASK_EVIDENCE_ABSENCE_VALUES;
+export const SYSTEM_INJECTION_PRIORITIES = CORE_SYSTEM_INJECTION_PRIORITIES;

package/dist/engineErrorCodes.d.ts

@@ -49,6 +49,9 @@ export declare function isRewindFamilyCode(code: string | undefined): boolean;
 export declare const RESUME_USAGE_WINDOW_EXHAUSTED = "resume.usage_window_exhausted";
 export declare const RESUME_PREFLIGHT_REJECTED = "resume.preflight_rejected";
 export declare const RESUME_SESSION_NOT_FOUND = "resume.session_not_found";
+export declare const REQUEST_FIELD_CONFLICT = "request.field_conflict";
+export declare const CHECKPOINT_UNSUPPORTED_VERSION = "checkpoint.unsupported_version";
+export declare function refusalSaysStillPending(err: object): boolean;
 export type StatusDerivedCoarseCode = (typeof STATUS_DERIVED_COARSE_CODES)[number];
 export declare const RESUME_PLACEMENT_MISMATCH = "resume.placement_mismatch";
 export declare const RESUME_CONTEXT_UNAVAILABLE = "conflict.resume_context_unavailable";

package/dist/engineErrorCodes.js

@@ -107,6 +107,16 @@ export function isRewindFamilyCode(code) {
 export const RESUME_USAGE_WINDOW_EXHAUSTED = 'resume.usage_window_exhausted';
 export const RESUME_PREFLIGHT_REJECTED = 'resume.preflight_rejected';
 export const RESUME_SESSION_NOT_FOUND = 'resume.session_not_found';
+export const REQUEST_FIELD_CONFLICT = 'request.field_conflict';
+export const CHECKPOINT_UNSUPPORTED_VERSION = 'checkpoint.unsupported_version';
+export function refusalSaysStillPending(err) {
+    try {
+        return Object.hasOwn(err, 'retriable') && err.retriable === true;
+    }
+    catch {
+        return false;
+    }
+}
 export const RESUME_PLACEMENT_MISMATCH = 'resume.placement_mismatch';
 export const RESUME_CONTEXT_UNAVAILABLE = 'conflict.resume_context_unavailable';
 export const RESUME_RETRY_LATER_CODES = Object.freeze([

package/dist/engineNoticeCodes.d.ts

@@ -130,13 +130,6 @@ export interface ReadDenyUnappliedFactsView {
     runId: string;
 }
 export declare function readReadDenyUnapplied(notice: unknown): ReadDenyUnappliedFactsView | undefined;
-export interface LegacyModeSeedMigratedFactsView {
-    permissionMode?: string;
-    droppedKeys: readonly string[];
-    sessionId: string;
-    runId: string;
-}
-export declare function readLegacyModeSeedMigrated(notice: unknown): LegacyModeSeedMigratedFactsView | undefined;
 export interface ToolTurnRepairView {
     form: string;
     toolCallIds: readonly string[];
@@ -172,9 +165,10 @@ export interface UserInputUndrainedFactsView {
     taskId?: string;
     sessionId?: string;
     runId?: string;
+    childSessionId?: string;
 }
 export declare function readUserInputUndrained(notice: unknown): UserInputUndrainedFactsView | undefined;
-export declare function userInputUndrainedNotice(facts: Pick<UserInputUndrainedFactsView, 'kind' | 'count' | 'cause'>): string | undefined;
+export declare function userInputUndrainedNotice(facts: Pick<UserInputUndrainedFactsView, 'kind' | 'count' | 'cause' | 'childSessionId'>): string | undefined;
 export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'mcp.injection_dropped': typeof readMcpInjectionDrop;
     readonly 'delegation.ask_unresolvable': typeof readAskUnresolvable;
@@ -190,7 +184,6 @@ export declare const ENGINE_NOTICE_FACT_READERS: Readonly<{
     readonly 'config.permission_mode_unavailable': typeof readPermissionModeUnavailable;
     readonly 'permission.ask_released_by_mode': typeof readAskReleasedByMode;
     readonly 'permission.read_deny_unapplied': typeof readReadDenyUnapplied;
-    readonly 'resume.legacy_mode_seed_migrated': typeof readLegacyModeSeedMigrated;
     readonly 'context.tool_turn_repaired': typeof readToolTurnRepaired;
     readonly 'server.model_unreachable': typeof readModelUnreachable;
     readonly 'task.tool_turn_incomplete': typeof readToolTurnIncomplete;

package/dist/engineNoticeCodes.js

@@ -454,31 +454,6 @@ function readReadDenyUnappliedOf(notice) {
     }
     return { mode, toolCallId, tiers, rows, rowCount, sessionId, runId };
 }
-export function readLegacyModeSeedMigrated(notice) {
-    return guardedRead(notice, readLegacyModeSeedMigratedOf);
-}
-function readLegacyModeSeedMigratedOf(notice) {
-    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
-        return undefined;
-    const n = notice;
-    if (ownSeat(n, 'code') !== 'resume.legacy_mode_seed_migrated')
-        return undefined;
-    const d = ownSeat(n, 'detail');
-    if (typeof d !== 'object' || d === null || Array.isArray(d))
-        return undefined;
-    const o = d;
-    const m = o.migrated;
-    if (typeof m !== 'object' || m === null || Array.isArray(m))
-        return undefined;
-    const mo = m;
-    const droppedKeys = nameList(mo.droppedKeys);
-    const sessionId = nonEmpty(o.sessionId);
-    const runId = nonEmpty(o.runId);
-    if (droppedKeys === undefined || sessionId === undefined || runId === undefined)
-        return undefined;
-    const permissionMode = nonEmpty(optionalSeat(mo, 'permissionMode'));
-    return { ...(permissionMode !== undefined ? { permissionMode } : {}), droppedKeys, sessionId, runId };
-}
 export function readToolTurnRepaired(notice) {
     return guardedRead(notice, readToolTurnRepairedOf);
 }
@@ -601,6 +576,7 @@ function readUserInputUndrainedOf(notice) {
     const taskId = nonEmpty(optionalOwnSeat(o, 'taskId'));
     const sessionId = nonEmpty(optionalOwnSeat(o, 'sessionId'));
     const runId = nonEmpty(optionalOwnSeat(o, 'runId'));
+    const childSessionId = nonEmpty(optionalOwnSeat(o, 'childSessionId'));
     return {
         kind,
         count,
@@ -608,6 +584,7 @@ function readUserInputUndrainedOf(notice) {
         ...(taskId !== undefined ? { taskId } : {}),
         ...(sessionId !== undefined ? { sessionId } : {}),
         ...(runId !== undefined ? { runId } : {}),
+        ...(childSessionId !== undefined ? { childSessionId } : {}),
     };
 }
 const messagesPhrase = (n, noun) => `${n} ${noun}${n === 1 ? '' : 's'}`;
@@ -623,12 +600,17 @@ const _steerSentencePin = true;
 void _steerSentencePin;
 const followUpUndrainedSentence = (n) => `${messagesPhrase(n, 'follow-up message')} you queued ${verbBe(n)} not used before the run ended and will not be delivered. ` +
     `Send ${itThem(n)} again if you still need ${itThem(n)}.`;
+const subagentSteerUndrainedSentence = (n) => `${messagesPhrase(n, 'message')} you sent while the run was in progress ${verbBe(n)} not used before a sub-agent's run ended and will not be delivered. ` +
+    `Send ${itThem(n)} again if you still need ${itThem(n)}.`;
+const subagentFollowUpUndrainedSentence = (n) => `${messagesPhrase(n, 'follow-up message')} you queued ${verbBe(n)} not used before a sub-agent's run ended and will not be delivered. ` +
+    `Send ${itThem(n)} again if you still need ${itThem(n)}.`;
 const unrecognizedUndrainedSentence = (n, kind) => `${kind === 'followUp' ? `${messagesPhrase(n, 'follow-up message')} you queued` : `${messagesPhrase(n, 'message')} you sent during a run`} may not have been used, ` +
     `and the reason was not reported in a form this version recognizes. Check the run's transcript before sending ${itThem(n)} again.`;
 export function userInputUndrainedNotice(facts) {
     let kind;
     let count;
     let cause;
+    let child;
     try {
         if (facts === null || typeof facts !== 'object' || Array.isArray(facts))
             return undefined;
@@ -639,12 +621,23 @@ export function userInputUndrainedNotice(facts) {
     catch {
         return undefined;
     }
+    try {
+        child = Object.hasOwn(facts, 'childSessionId') ? facts.childSessionId : undefined;
+    }
+    catch {
+        child = undefined;
+    }
+    const fromSubagent = typeof child === 'string' && child.length > 0;
     const n = positiveInt(count);
     if (n === undefined || (kind !== 'steer' && kind !== 'followUp'))
         return undefined;
     if (kind === 'followUp') {
-        return cause === undefined || cause === 'leg_end' ? followUpUndrainedSentence(n) : unrecognizedUndrainedSentence(n, kind);
+        if (cause === undefined || cause === 'leg_end')
+            return fromSubagent ? subagentFollowUpUndrainedSentence(n) : followUpUndrainedSentence(n);
+        return unrecognizedUndrainedSentence(n, kind);
     }
+    if (cause === 'leg_end' && fromSubagent)
+        return subagentSteerUndrainedSentence(n);
     if (typeof cause === 'string' && Object.hasOwn(STEER_UNDRAINED_SENTENCE, cause)) {
         return STEER_UNDRAINED_SENTENCE[cause](n);
     }
@@ -665,7 +658,6 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'config.permission_mode_unavailable': readPermissionModeUnavailable,
     'permission.ask_released_by_mode': readAskReleasedByMode,
     'permission.read_deny_unapplied': readReadDenyUnapplied,
-    'resume.legacy_mode_seed_migrated': readLegacyModeSeedMigrated,
     'context.tool_turn_repaired': readToolTurnRepaired,
     'server.model_unreachable': readModelUnreachable,
     'task.tool_turn_incomplete': readToolTurnIncomplete,

package/dist/fileHistoryLegNotice.d.ts

@@ -0,0 +1,20 @@
+import type { AgentEvent } from '@sema-agent/sdk';
+import { type FileHistoryCaptureReading } from './fileHistoryCaptureCapability.js';
+export type FileHistoryDeclarationFact = 'sent' | 'not_sent' | 'unknown';
+export declare const FILE_HISTORY_LEG_VERDICTS: readonly ["not_honored", "not_offered", "honored", "not_declared", "unknown"];
+export type FileHistoryLegNoticeVerdict = (typeof FILE_HISTORY_LEG_VERDICTS)[number];
+export interface FileHistoryLegNoticeInput {
+    readonly capability: FileHistoryCaptureReading;
+    readonly declaration: FileHistoryDeclarationFact;
+    readonly captureOffByUser: boolean;
+    readonly legWord: string | undefined;
+}
+export declare function fileHistoryLegNoticeVerdict(input: FileHistoryLegNoticeInput): FileHistoryLegNoticeVerdict;
+export declare function fileHistoryLegNoticeSentence(verdict: FileHistoryLegNoticeVerdict): string | null;
+export declare function fileHistoryDeclarationOfBody(body: object | null | undefined): FileHistoryDeclarationFact;
+export interface FileHistoryDeclarationLedger {
+    declared(requestKey: string, fact: FileHistoryDeclarationFact): boolean;
+    boundToRun(requestKey: string, runId: string, event: AgentEvent): boolean;
+    declarationOf(runId: string): FileHistoryDeclarationFact;
+}
+export declare function createFileHistoryDeclarationLedger(): FileHistoryDeclarationLedger;

package/dist/fileHistoryLegNotice.js

@@ -0,0 +1,122 @@
+import { fileHistoryCaptureMode } from './fileHistoryCaptureCapability.js';
+import { frameProvesDelivery } from './promptDelivery.js';
+import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
+export const FILE_HISTORY_LEG_VERDICTS = Object.freeze(['not_honored', 'not_offered', 'honored', 'not_declared', 'unknown']);
+function ownRead(o, key) {
+    return Object.hasOwn(o, key) ? o[key] : undefined;
+}
+function declarationOfInput(v) {
+    return v === 'sent' || v === 'not_sent' ? v : 'unknown';
+}
+export function fileHistoryLegNoticeVerdict(input) {
+    if (typeof input !== 'object' || input === null)
+        return 'unknown';
+    let capability;
+    let declaration;
+    let offByUser;
+    let legWord;
+    try {
+        capability = ownRead(input, 'capability');
+        declaration = declarationOfInput(ownRead(input, 'declaration'));
+        offByUser = ownRead(input, 'captureOffByUser') === true;
+        legWord = ownRead(input, 'legWord');
+    }
+    catch {
+        return 'unknown';
+    }
+    if (legWord !== 'on' && legWord !== FILE_HISTORY_DISABLED)
+        return 'unknown';
+    if (declaration === 'sent')
+        return legWord === 'on' ? 'not_honored' : 'honored';
+    if (!offByUser)
+        return 'not_declared';
+    const mode = fileHistoryCaptureMode(capability);
+    if (legWord === 'on' && mode === 'on-always')
+        return 'not_offered';
+    if (declaration === 'not_sent' && (legWord === FILE_HISTORY_DISABLED || mode === 'on-optional'))
+        return 'not_declared';
+    return 'unknown';
+}
+const NOT_HONORED_SENTENCE = 'The engine is still capturing file history for this session, though your settings asked it not to.';
+const NOT_OFFERED_SENTENCE = 'This engine always captures file history and cannot turn it off per session, even though file checkpoints are off in your settings.';
+export function fileHistoryLegNoticeSentence(verdict) {
+    if (verdict === 'not_honored')
+        return NOT_HONORED_SENTENCE;
+    if (verdict === 'not_offered')
+        return NOT_OFFERED_SENTENCE;
+    return null;
+}
+export function fileHistoryDeclarationOfBody(body) {
+    if (typeof body !== 'object' || body === null)
+        return 'unknown';
+    try {
+        if (Array.isArray(body))
+            return 'unknown';
+        if (typeof body.toJSON === 'function')
+            return 'unknown';
+        const d = Object.getOwnPropertyDescriptor(body, 'fileHistory');
+        const all = Object.getOwnPropertyDescriptors(body);
+        for (const k of Reflect.ownKeys(all)) {
+            const x = all[k];
+            if (x !== undefined && x.enumerable === true && !Object.hasOwn(x, 'value'))
+                return 'unknown';
+        }
+        const listed = Object.hasOwn(all, 'fileHistory') ? all.fileHistory : undefined;
+        const listedOn = listed !== undefined && listed.enumerable === true;
+        if (d === undefined || d.enumerable !== true)
+            return listedOn ? 'unknown' : 'not_sent';
+        if (!Object.hasOwn(d, 'value') || !listedOn || !Object.hasOwn(listed, 'value') || !Object.is(listed.value, d.value))
+            return 'unknown';
+        if (!Object.is(body.fileHistory, d.value))
+            return 'unknown';
+        if (typeof d.value === 'object' && d.value !== null)
+            return 'unknown';
+        return d.value === FILE_HISTORY_DISABLED ? 'sent' : 'not_sent';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+const idOk = (v) => typeof v === 'string' && v.length > 0;
+export function createFileHistoryDeclarationLedger() {
+    const factsByKey = new Map();
+    const keysByRun = new Map();
+    return Object.freeze({
+        declared(requestKey, fact) {
+            if (!idOk(requestKey) || (fact !== 'sent' && fact !== 'not_sent'))
+                return false;
+            let set = factsByKey.get(requestKey);
+            if (set === undefined)
+                factsByKey.set(requestKey, (set = new Set()));
+            set.add(fact);
+            return true;
+        },
+        boundToRun(requestKey, runId, event) {
+            if (!idOk(requestKey) || !idOk(runId) || !frameProvesDelivery(event))
+                return false;
+            let set = keysByRun.get(runId);
+            if (set === undefined)
+                keysByRun.set(runId, (set = new Set()));
+            set.add(requestKey);
+            return true;
+        },
+        declarationOf(runId) {
+            if (!idOk(runId))
+                return 'unknown';
+            const keys = keysByRun.get(runId);
+            if (keys === undefined)
+                return 'unknown';
+            let agreed;
+            for (const k of keys) {
+                const facts = factsByKey.get(k);
+                if (facts === undefined || facts.size !== 1)
+                    return 'unknown';
+                const [only] = facts;
+                if (only === undefined || (agreed !== undefined && agreed !== only))
+                    return 'unknown';
+                agreed = only;
+            }
+            return agreed ?? 'unknown';
+        },
+    });
+}

package/dist/gateOutcome.d.ts

@@ -40,7 +40,7 @@ export interface SettlementWhoView {
     approver?: string;
     window?: string;
 }
-export declare const SETTLEMENT_KIND_WORDS: readonly ["human_allowed", "human_refused", "approval_window_expired", "denial_limit_window_expired", "park_sla_expired", "no_approver", "approver_unavailable", "approver_error", "approver_contract", "presentation_failed", "blanket_allow_refused", "policy_refused", "task_aborted"];
+export declare const SETTLEMENT_KIND_WORDS: readonly ["human_allowed", "human_refused", "approval_window_expired", "denial_limit_window_expired", "park_sla_expired", "no_approver", "approver_unavailable", "approver_error", "approver_contract", "presentation_failed", "blanket_allow_refused", "policy_allowed", "policy_refused", "task_aborted"];
 export interface SettlementView {
     kind: Settlement['kind'] | (string & {});
     who: SettlementWhoView;

package/dist/gateOutcome.js

@@ -20,6 +20,7 @@ export const SETTLEMENT_KIND_WORDS = Object.freeze([
     'approver_contract',
     'presentation_failed',
     'blanket_allow_refused',
+    'policy_allowed',
     'policy_refused',
     'task_aborted',
 ]);

package/dist/generated/engineFactTables.d.ts

@@ -9,3 +9,16 @@ export declare const CORE_PERMISSION_MODE_FOLD_REASONS: readonly string[];
 export declare const CORE_ENGINE_CARD_TYPES: readonly string[];
 export declare const CORE_TOOL_DECLARATION_CODES: readonly string[];
 export declare const CORE_MODE_RELEASE_REASONS: readonly ["rule_unreadable"];
+export declare const CORE_HOOK_TOOL_ALIASES: Readonly<Record<string, string>>;
+export declare const CORE_ASK_EVIDENCE_ABSENCE_VALUES: readonly ["not_wired", "not_adjudicated", "unavailable", "no_match", "not_reported"];
+export declare const CORE_SYSTEM_INJECTION_PRIORITIES: readonly ["now", "next", "later"];
+export declare const CORE_READ_DENY_BUILTIN_TIERS: readonly ["credentials", "shell-history", "browser", "wallet", "agent-config"];
+export declare const CORE_READ_DENY_DEFAULT_TIERS: readonly ["credentials", "agent-config"];
+export interface CoreModeArbitrationRow {
+    readonly bypassImmune: boolean;
+    readonly classifierEligible: boolean;
+    readonly sandboxAdmission: boolean;
+    readonly ruleMayClear: boolean;
+    readonly hookAskFloor: boolean;
+}
+export declare const CORE_MODE_ARBITRATION: Readonly<Record<"content_question" | "hook" | "ancestor" | "unverifiable_delete" | "transcript_write" | "org_rule" | "governance_unavailable" | "rule_unreadable" | "ask_rule" | "denial_limit_fallback" | "operator_forced" | "shell_floor" | "write_protection_unresolved" | "probe" | "write_protection" | "tool_marks_mcp" | "tool_marks_a2a" | "policy_rra" | "artifact_shared_read" | "mode" | "unstated" | "ordinary", CoreModeArbitrationRow>>;