@sema-agent/client-core 0.99.0 → 0.100.0

package/dist/compactionStatus.js

@@ -0,0 +1,196 @@
+import { readOwnDataValue } from './ownKey.js';
+import { snapshotIsSubFlow, snapshotSegmentIdentity } from './adapter/types.js';
+const _printStatusFramePins = [true, true];
+void _printStatusFramePins;
+const CLOSED_PASS_MEMORY = 1024;
+const nonEmpty = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+const own = (o, key) => (typeof o === 'object' && o !== null ? readOwnDataValue(o, key) : undefined);
+function chromeLane(ev) {
+    const lane = own(own(ev, 'laneProof'), 'lane');
+    if (typeof lane !== 'string' || lane.length === 0)
+        return 'unreadable';
+    return lane === 'main' ? 'main' : 'other';
+}
+function armLane(m) {
+    const snap = snapshotSegmentIdentity(m);
+    if (snap === null)
+        return 'unreadable';
+    return snapshotIsSubFlow(snap) ? 'other' : 'main';
+}
+function openOf(pass, lane, startedAt, trigger) {
+    if (lane === 'unreadable')
+        return null;
+    if (nonEmpty(trigger) === undefined)
+        return null;
+    return { kind: 'open', pass, main: lane === 'main', ...(typeof startedAt === 'number' && Number.isFinite(startedAt) ? { startedAt } : {}) };
+}
+function parse(input) {
+    const plane = own(input, 'plane');
+    if (plane === 'chrome') {
+        const ev = own(input, 'event');
+        return typeof ev === 'object' && ev !== null ? parseChrome(ev) : null;
+    }
+    if (plane === 'transcript') {
+        const msg = own(input, 'message');
+        return typeof msg === 'object' && msg !== null ? parseMessage(msg) : null;
+    }
+    if (own(input, 'kind') !== undefined)
+        return parseChrome(input);
+    return parseMessage(input);
+}
+function parseChrome(ev) {
+    const kind = own(ev, 'kind');
+    const pass = nonEmpty(own(ev, 'pass'));
+    if (pass === undefined)
+        return null;
+    if (kind === 'compaction_started')
+        return openOf(pass, chromeLane(ev), own(ev, 'startedAt'), own(ev, 'trigger'));
+    if (kind === 'compaction_outcome') {
+        const outcome = nonEmpty(own(ev, 'outcome'));
+        const reason = nonEmpty(own(ev, 'reason'));
+        return { kind: 'close-outcome', pass, ...(outcome !== undefined ? { outcome } : {}), ...(reason !== undefined ? { reason } : {}) };
+    }
+    return null;
+}
+function parseMessage(m) {
+    const type = own(m, 'type');
+    if (type === 'system') {
+        if (own(m, 'subtype') !== 'compact_boundary')
+            return null;
+        const pass = nonEmpty(own(own(m, 'compact_metadata'), '_sema_pass'));
+        return pass === undefined ? null : { kind: 'close-landed', pass };
+    }
+    const pass = nonEmpty(own(m, 'pass'));
+    if (pass === undefined)
+        return null;
+    if (type === 'compaction_started')
+        return openOf(pass, armLane(m), own(m, 'startedAt'), own(m, 'trigger'));
+    if (type === 'compaction_outcome') {
+        const outcome = nonEmpty(own(m, 'outcome'));
+        const reason = nonEmpty(own(m, 'reason'));
+        return { kind: 'close-outcome', pass, ...(outcome !== undefined ? { outcome } : {}), ...(reason !== undefined ? { reason } : {}) };
+    }
+    return null;
+}
+export function createCompactionStatusTracker() {
+    const open = new Map();
+    const closed = new Set();
+    const remember = (pass) => {
+        closed.add(pass);
+        if (closed.size > CLOSED_PASS_MEMORY) {
+            const oldest = closed.values().next().value;
+            if (oldest !== undefined)
+                closed.delete(oldest);
+        }
+    };
+    const mainOpen = () => {
+        let n = 0;
+        for (const e of open.values())
+            if (e.main)
+                n++;
+        return n;
+    };
+    const since = () => {
+        let min;
+        for (const e of open.values())
+            if (e.main && e.startedAt !== undefined && (min === undefined || e.startedAt < min))
+                min = e.startedAt;
+        return min;
+    };
+    const reading = () => {
+        if (mainOpen() === 0)
+            return { compacting: false };
+        const s = since();
+        return { compacting: true, ...(s !== undefined ? { since: s } : {}) };
+    };
+    return {
+        take(input) {
+            try {
+                if (typeof input !== 'object' || input === null)
+                    return null;
+                const p = parse(input);
+                if (p === null)
+                    return null;
+                if (p.kind === 'open') {
+                    if (open.has(p.pass) || closed.has(p.pass))
+                        return null;
+                    const before = mainOpen();
+                    open.set(p.pass, { main: p.main === true, ...(p.startedAt !== undefined ? { startedAt: p.startedAt } : {}) });
+                    if (before === 0 && p.main === true) {
+                        const s = since();
+                        return { kind: 'opened', pass: p.pass, ...(s !== undefined ? { since: s } : {}) };
+                    }
+                    return null;
+                }
+                const entry = open.get(p.pass);
+                remember(p.pass);
+                if (entry === undefined)
+                    return null;
+                open.delete(p.pass);
+                if (!entry.main || mainOpen() > 0)
+                    return null;
+                if (p.kind === 'close-landed')
+                    return { kind: 'closed', pass: p.pass, result: 'success' };
+                if (p.outcome === 'failed')
+                    return { kind: 'closed', pass: p.pass, result: 'failed', ...(p.reason !== undefined ? { error: p.reason } : {}) };
+                return { kind: 'closed', pass: p.pass };
+            }
+            catch {
+                return null;
+            }
+        },
+        streamEnded() {
+            try {
+                let lastMain;
+                for (const [pass, e] of open) {
+                    if (e.main)
+                        lastMain = pass;
+                    remember(pass);
+                }
+                const wasCompacting = lastMain !== undefined;
+                open.clear();
+                return wasCompacting ? { kind: 'closed', pass: lastMain } : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        reading() {
+            try {
+                return reading();
+            }
+            catch {
+                return { compacting: false };
+            }
+        },
+    };
+}
+export function compactionStatusFrameOf(change, ctx) {
+    try {
+        if (typeof change !== 'object' || change === null)
+            return null;
+        const sessionId = nonEmpty(own(ctx, 'sessionId'));
+        const mintUuid = own(ctx, 'mintUuid');
+        if (sessionId === undefined || typeof mintUuid !== 'function')
+            return null;
+        const kind = own(change, 'kind');
+        if (kind === 'opened')
+            return { type: 'system', subtype: 'status', status: 'compacting', uuid: String(mintUuid()), session_id: sessionId };
+        if (kind !== 'closed')
+            return null;
+        const result = own(change, 'result');
+        const error = result === 'failed' ? nonEmpty(own(change, 'error')) : undefined;
+        return {
+            type: 'system',
+            subtype: 'status',
+            status: null,
+            ...(result === 'success' || result === 'failed' ? { compact_result: result } : {}),
+            ...(error !== undefined ? { compact_error: error } : {}),
+            uuid: String(mintUuid()),
+            session_id: sessionId,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/decideFailureNote.js

@@ -1,21 +1,21 @@
 import { corruptStoredRowContent, corruptStoredRowWhere, scenarioDenyFromError, scenarioNotAllowedContent } from './wireErrorTriage.js';
 import { checkpointUnsupportedVersionContent, checkpointUnsupportedVersionFromError, parkedResumeStartupContent, parkedResumeStartupFromError, resumePolicyBlockContent, resumePolicyBlockFromError, } from './resumeRefusalCopy.js';
 import { askGoneContent, askGoneFromError, decideParkMovedContent, decideParkMovedFromError } from './decideReceipt.js';
-import { settingsPermissionBucketRefusalContent, settingsPermissionBucketRefusalFromError } from './wireRefusalCopy.js';
+import { fieldLimitRefusalContent, fieldLimitRefusalFromError } from './wireRefusalCopy.js';
 import { DECISION_ANSWER_INVALID_CONTENT, decisionConflictOf } from './hitl/decisionConflict.js';
 export function decideFailureNote(err, decision) {
     const where = corruptStoredRowWhere(err);
     const fold = resumePolicyBlockFromError(err);
     const startup = parkedResumeStartupFromError(err, decision);
     const moved = decideParkMovedFromError(err);
-    const bucket = settingsPermissionBucketRefusalFromError(err);
+    const bucket = fieldLimitRefusalFromError(err);
     const scenario = scenarioDenyFromError(err);
     const unsupported = checkpointUnsupportedVersionFromError(err);
     const gone = askGoneFromError(err);
     const answerInvalid = decisionConflictOf(err) === 'answer_invalid';
     return ((where === undefined ? '' : ` — ${corruptStoredRowContent(where)}`) +
         (fold === null ? '' : ` — ${resumePolicyBlockContent(fold)}`) +
-        (bucket === null ? '' : ` — ${settingsPermissionBucketRefusalContent(bucket)}`) +
+        (bucket === null ? '' : ` — ${fieldLimitRefusalContent(bucket)}`) +
         (scenario === null ? '' : ` — ${scenarioNotAllowedContent(scenario, undefined, 'resumed_work')}`) +
         (startup === null ? '' : ` — ${parkedResumeStartupContent(startup)}`) +
         (moved === null ? '' : ` — ${decideParkMovedContent(moved)}`) +

package/dist/displayUntrusted.js

@@ -43,6 +43,9 @@ export function looksLikeKnownSecret(s) {
     for (let layer = 0; layer < 4; layer++) {
         if (scanForSecretLiteral(cur))
             return true;
+        const wide = percentBoundaryDecode(cur);
+        if (wide !== null && scanForSecretLiteral(wide.decoded))
+            return true;
         const next = percentDecodeForMatching(cur).decoded;
         if (next === cur)
             break;
@@ -301,7 +304,7 @@ function pathCandidates(src, base, path, opaqueSegments, edits, soft) {
         if (opaqueSegments) {
             let a = 0;
             let b = head.length;
-            while (a < b && !isKeyWordChar(head.charCodeAt(a)))
+            while (a < b && !isKeyWordChar(head.charCodeAt(a)) && !(head.charCodeAt(a) === 0x25 && hasNonAsciiPercentEscape(head.slice(a, a + 3))))
                 a++;
             while (b > a && !isKeyWordChar(head.charCodeAt(b - 1)))
                 b--;
@@ -1321,10 +1324,93 @@ function percentDecodeForMatching(text) {
     return { decoded: chars.join(''), offsets };
 }
 const PERCENT_ESCAPE_ASCII = /%[0-7][0-9A-Fa-f]/;
+function hasNonAsciiPercentEscape(text) {
+    return /%[89A-Fa-f][0-9A-Fa-f]/.test(text);
+}
+function isWellFormedUtf8(bytes) {
+    for (let i = 0; i < bytes.length;) {
+        const lead = bytes[i] ?? 0;
+        if (lead < 0x80) {
+            i += 1;
+            continue;
+        }
+        const need = utf8TailLength(lead);
+        if (need === 0)
+            return false;
+        for (let k = 1; k <= need; k++) {
+            const c = bytes[i + k];
+            const lo = k === 1 ? (lead === 0xe0 ? 0xa0 : lead === 0xf0 ? 0x90 : 0x80) : 0x80;
+            const hi = k === 1 ? (lead === 0xed ? 0x9f : lead === 0xf4 ? 0x8f : 0xbf) : 0xbf;
+            if (c === undefined || c < lo || c > hi)
+                return false;
+        }
+        i += need + 1;
+    }
+    return true;
+}
+function utf8TailLength(lead) {
+    if (lead >= 0xc2 && lead <= 0xdf)
+        return 1;
+    if (lead >= 0xe0 && lead <= 0xef)
+        return 2;
+    if (lead >= 0xf0 && lead <= 0xf4)
+        return 3;
+    return 0;
+}
+function percentBoundaryDecode(text) {
+    if (!hasNonAsciiPercentEscape(text))
+        return null;
+    const chars = [];
+    const from = [];
+    const to = [];
+    const escapeAt = (k) => text.charCodeAt(k) === 0x25 && isHexDigit(text.charAt(k + 1)) && isHexDigit(text.charAt(k + 2));
+    let i = 0;
+    while (i < text.length) {
+        if (!escapeAt(i)) {
+            chars.push(text.charAt(i));
+            from.push(i);
+            to.push(i + 1);
+            i += 1;
+            continue;
+        }
+        const bytes = [];
+        let j = i;
+        while (escapeAt(j)) {
+            bytes.push(Number.parseInt(text.slice(j + 1, j + 3), 16));
+            j += 3;
+        }
+        if (isWellFormedUtf8(bytes)) {
+            for (let k = 0; k < bytes.length;) {
+                const lead = bytes[k] ?? 0;
+                const len = lead < 0x80 ? 1 : utf8TailLength(lead) + 1;
+                let cp = len === 1 ? lead : lead & (0xff >> (len + 1));
+                for (let t = 1; t < len; t++)
+                    cp = (cp << 6) | ((bytes[k + t] ?? 0) & 0x3f);
+                const ch = String.fromCodePoint(cp);
+                for (let u = 0; u < ch.length; u++) {
+                    chars.push(ch.charAt(u));
+                    from.push(i + k * 3);
+                    to.push(i + (k + len) * 3);
+                }
+                k += len;
+            }
+        }
+        else {
+            for (let k = 0; k < bytes.length; k++) {
+                const b = bytes[k] ?? 0;
+                chars.push(b < 0x80 ? String.fromCharCode(b) : ' ');
+                from.push(i + k * 3);
+                to.push(i + k * 3 + 3);
+            }
+        }
+        i = j;
+    }
+    return { decoded: chars.join(''), from, to };
+}
 const MAX_PERCENT_VIEW_LAYERS = 3;
 function percentLayers(text) {
     const out = [];
-    if (!PERCENT_ESCAPE_ASCII.test(text))
+    if (!PERCENT_ESCAPE_ASCII.test(text) && !hasNonAsciiPercentEscape(text))
         return out;
     let cur = text;
     let ps = null;
@@ -1347,6 +1433,22 @@ function percentLayers(text) {
         ps = nps;
         pe = npe;
     }
+    const bases = [[text, null, null], ...out.map((l) => [l.text, l.ps, l.pe])];
+    for (const [base, bps, bpe] of bases) {
+        const wide = percentBoundaryDecode(base);
+        if (wide === null)
+            continue;
+        const n = wide.decoded.length;
+        const nps = new Int32Array(n);
+        const npe = new Int32Array(n);
+        for (let k = 0; k < n; k++) {
+            const a = wide.from[k] ?? 0;
+            const b = wide.to[k] ?? base.length;
+            nps[k] = bps === null ? a : (bps[a] ?? 0);
+            npe[k] = bpe === null ? b : (bpe[b - 1] ?? 0);
+        }
+        out.push({ text: wide.decoded, ps: nps, pe: npe });
+    }
     return out;
 }
 function firstLabelCutInPath(path, outer = false) {
@@ -3312,7 +3414,7 @@ function proseLiteralEdits(text) {
         let end = i;
         while (end < text.length && isKeyWordChar(text.charCodeAt(end)))
             end++;
-        const escHead = i > 0 && text.charCodeAt(i - 1) === 0x25 && PERCENT_ESCAPE_ASCII.test(text.slice(i - 1, i + 2)) && i + 2 < end ? 2 : 0;
+        const escHead = i > 0 && text.charCodeAt(i - 1) === 0x25 && (PERCENT_ESCAPE_ASCII.test(text.slice(i - 1, i + 2)) || hasNonAsciiPercentEscape(text.slice(i - 1, i + 2))) && i + 2 < end ? 2 : 0;
         const word = text.slice(i, end);
         if (word.startsWith('eyJ')) {
             let segEnd = end;
@@ -4134,11 +4236,19 @@ function collectCandidates(text, o, nested) {
     for (const S of surfaces) {
         const cands = [];
         const regions = [];
+        const unitPos = (k) => S.dropped(k) || V.rawUnit[S.rawStart(k)] === 1;
         if (o.urls) {
-            const unitPos = (k) => S.dropped(k) || V.rawUnit[S.rawStart(k)] === 1;
             urlCandidates(S.text, cands, regions, unitPos, (k) => unitPos(k) || S.painted(k), o.queryByShape ?? false, o.wholeAddress === true, o.wholeAddress === true && S.decoded !== true);
             userinfoCandidates(S, cands, o.words);
         }
+        else if (o.words && o.wholeAddress === true) {
+            const scratch = [];
+            const hostOnly = [];
+            urlCandidates(S.text, scratch, hostOnly, unitPos, (k) => unitPos(k) || S.painted(k), false, true, S.decoded !== true);
+            for (const r of hostOnly)
+                if (r[2] === 'host')
+                    regions.push(r);
+        }
         if (o.words) {
             editsToCandidates(pemEdits(S, (blk) => { if (S === regionSurface)
                 pemBlocksSeen.push(pemBlockToRaw(S, blk)); }), 'pem', cands);
@@ -4778,7 +4888,42 @@ function isHighEntropyQueryValue(value) {
 }
 function isOpaqueSecretValue(value) {
     const core = valueCoreForJudging(value);
-    return core.length > 0 && (looksLikeKnownSecret(core) || isHighEntropyQueryValue(core));
+    if (core.length === 0)
+        return false;
+    if (looksLikeKnownSecret(core) || isHighEntropyQueryValue(core))
+        return true;
+    if (hasNonAsciiPercentEscape(core)) {
+        for (const chunk of percentByteChunks(core))
+            if (chunk.length > 0 && isHighEntropyQueryValue(chunk))
+                return true;
+    }
+    return false;
+}
+function percentByteChunks(text) {
+    const escapeAt = (k) => text.charCodeAt(k) === 0x25 && isHexDigit(text.charAt(k + 1)) && isHexDigit(text.charAt(k + 2));
+    const chunks = [];
+    let start = 0;
+    let i = 0;
+    while (i < text.length) {
+        if (!escapeAt(i)) {
+            i += 1;
+            continue;
+        }
+        let j = i;
+        let wide = false;
+        while (escapeAt(j)) {
+            if (text.charCodeAt(j + 1) >= 0x38)
+                wide = true;
+            j += 3;
+        }
+        if (wide) {
+            chunks.push(text.slice(start, i));
+            start = j;
+        }
+        i = j;
+    }
+    chunks.push(text.slice(start));
+    return chunks;
 }
 const VALUE_PIECE_SEPARATORS = new Set(['/', '\\', '?', '#', '&', '=', ';', ':', '@', ',', '+']);
 function hasOpaquePiece(text) {

package/dist/engineAgentPanelStore.d.ts

@@ -2,6 +2,10 @@ import { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_T
 import type { EngineAgentPanelCycleIdentity } from './cycleOrder.js';
 export { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_TICK_BEATS };
 export type { EngineAgentPanelCycleIdentity, EnginePanelTaskIdentity };
+type PanelFinalityFlags = {
+    totalTokens?: true;
+    toolUses?: true;
+};
 export type EngineAgentPanelEvent = {
     kind: 'tick';
     taskId: string;
@@ -16,6 +20,8 @@ export type EngineAgentPanelEvent = {
     cardBound?: true;
     wireTaskId?: string;
     taskIdOrigin?: 'fleet-row' | 'wire';
+    cycleSeq?: number;
+    final?: PanelFinalityFlags;
 } | {
     kind: 'fleet-row';
     taskId: string;
@@ -33,10 +39,7 @@ export type EngineAgentPanelEvent = {
     parentToolCallId?: string;
     wireTaskId?: string;
     taskIdOrigin?: 'wire';
-    final?: {
-        totalTokens?: true;
-        toolUses?: true;
-    };
+    final?: PanelFinalityFlags;
 } | {
     kind: 'end';
     taskId: string;

package/dist/engineErrorCodes.d.ts

@@ -16,8 +16,9 @@ export declare const CONFIG_MEMORY_PROJECT_KEY_SPELLING = "config.memory_project
 export declare const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = "config.memory_write_scope_mismatch";
 export declare const CONFIG_LEGACY_TOOL_NAME = "config.legacy_tool_name";
 export declare const CONFIG_IMAGE_INVALID = "config.image_invalid";
-export declare function imageInvalidFailureNoteOf(code: string | undefined): string | undefined;
 export declare const CONFIG_AGENT_UNKNOWN_TOOL = "config.agent.unknown_tool";
+export declare const CONFIG_TOOL_FACE_CONTROL = "config.tool_face_control";
+export declare const PROMPT_ASSEMBLED_ROLE_REFUSED = "prompt.assembled_role_refused";
 export declare const CONFIG_OUTPUT_STYLE_INVALID = "config.output_style_invalid";
 export declare const RULES_INERT_ENTRY = "rules.inert_entry";
 export declare const RULES_INVALID_SHAPE = "rules.invalid_shape";
@@ -35,6 +36,9 @@ export declare const TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN = "interrupted_outcome
 export declare function isInterruptedToolEndCode(code: string | undefined): boolean;
 export declare const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = "capability.self_orchestration_required";
 export declare const CAPABILITY_IMAGE_INDEX_REQUIRED = "capability.image_index_required";
+export declare const CAPABILITY_K8S_LANE_REQUIRED = "capability.k8s_lane_required";
+export declare const NOT_FOUND_IMAGE = "not_found.image";
+export declare const REQUEST_PRECONDITION_UNMET = "request.precondition_unmet";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
 export declare const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = "conflict.idempotency_payload_mismatch";
@@ -110,6 +114,10 @@ export declare const DECIDE_ALREADY_RESOLVED_CODES: readonly string[];
 export declare function isDecideAlreadyResolvedCode(code: string | null | undefined): boolean;
 export declare const ASK_GONE = "gone.ask";
 export declare const ASK_GONE_PARKED = "gone.ask_parked";
+export declare const ASK_NOT_FOUND = "not_found.ask";
+export declare const ASK_IDEMPOTENCY_CONFLICT = "conflict.ask_idempotency";
+export declare const ASK_PARKING_RETRY = "parking.ask_retry";
+export declare const ASK_DECISION_LANE_DISABLED = "feature.approval_ask_disabled";
 export declare const ASK_GONE_DENIED_WORD: "routing_failure_fail_closed";
 export declare const RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];
 export type { RunDeathVerdictCode };

package/dist/engineErrorCodes.js

@@ -21,12 +21,9 @@ export const CONFIG_MEMORY_PROJECT_KEY_SPELLING = 'config.memory_project_key_spe
 export const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = 'config.memory_write_scope_mismatch';
 export const CONFIG_LEGACY_TOOL_NAME = 'config.legacy_tool_name';
 export const CONFIG_IMAGE_INVALID = 'config.image_invalid';
-const IMAGE_INVALID_FAILURE_NOTE = 'This run did not start: an image sent with the message was refused before the model was called — the engine’s own error text says which image and what is wrong with it. ' +
-    'Nothing was sent to the model; remove or replace that image, then send the message again.';
-export function imageInvalidFailureNoteOf(code) {
-    return code === CONFIG_IMAGE_INVALID ? IMAGE_INVALID_FAILURE_NOTE : undefined;
-}
 export const CONFIG_AGENT_UNKNOWN_TOOL = 'config.agent.unknown_tool';
+export const CONFIG_TOOL_FACE_CONTROL = 'config.tool_face_control';
+export const PROMPT_ASSEMBLED_ROLE_REFUSED = 'prompt.assembled_role_refused';
 export const CONFIG_OUTPUT_STYLE_INVALID = 'config.output_style_invalid';
 export const RULES_INERT_ENTRY = 'rules.inert_entry';
 export const RULES_INVALID_SHAPE = 'rules.invalid_shape';
@@ -65,6 +62,9 @@ export function isInterruptedToolEndCode(code) {
 }
 export const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = 'capability.self_orchestration_required';
 export const CAPABILITY_IMAGE_INDEX_REQUIRED = 'capability.image_index_required';
+export const CAPABILITY_K8S_LANE_REQUIRED = 'capability.k8s_lane_required';
+export const NOT_FOUND_IMAGE = 'not_found.image';
+export const REQUEST_PRECONDITION_UNMET = 'request.precondition_unmet';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
 export const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = 'conflict.idempotency_payload_mismatch';
@@ -208,6 +208,10 @@ export function isDecideAlreadyResolvedCode(code) {
 }
 export const ASK_GONE = 'gone.ask';
 export const ASK_GONE_PARKED = 'gone.ask_parked';
+export const ASK_NOT_FOUND = 'not_found.ask';
+export const ASK_IDEMPOTENCY_CONFLICT = 'conflict.ask_idempotency';
+export const ASK_PARKING_RETRY = 'parking.ask_retry';
+export const ASK_DECISION_LANE_DISABLED = 'feature.approval_ask_disabled';
 export const ASK_GONE_DENIED_WORD = SDK_DENY_REASON_ROUTING_FAILURE;
 export const RUN_DEATH_VERDICT_CODES = SDK_RUN_DEATH_VERDICT_CODES;
 const _runDeathVerdictCodePin = true;

package/dist/engineRowRef.js

@@ -96,6 +96,7 @@ export const TRANSCRIPT_ROW_SIDECAR_KEYS = Object.freeze([
     '_sema_api_error_status',
     '_sema_api_error_code',
     '_sema_provider_condition',
+    '_sema_terminal_owner',
 ]);
 export function parkHeldCallIdOf(carrier) {
     return readFrameStringKey(carrier, 'toolCallId');

package/dist/engineToolDirectory.d.ts

@@ -10,6 +10,9 @@ export type EngineToolDirectory = {
     readonly state: 'not_landed';
 } | {
     readonly state: 'unreadable';
+} | {
+    readonly state: 'request_only';
+    readonly requestMcpServerPrefixes: ReadonlySet<string>;
 } | {
     readonly state: 'directory';
     readonly mcpServerPrefixes: ReadonlySet<string>;

package/dist/engineToolDirectory.js

@@ -35,18 +35,20 @@ export function engineToolDirectoryOf(source) {
         const deployment = readHalf(ownDataField(source, 'deploymentMcpServers'));
         if (request === 'unreadable' || deployment === 'unreadable')
             return unreadable();
-        if (request === 'absent' || deployment === 'absent')
+        if (request === 'absent')
             return notLanded();
         const ns = namingPorts();
         if (ns === undefined)
             return unreadable();
         const prefixes = [];
-        for (const name of [...request, ...deployment]) {
+        for (const name of deployment === 'absent' ? request : [...request, ...deployment]) {
             const prefix = mintNamespacePrefix(ns, name);
             if (typeof prefix !== 'string' || prefix.length === 0)
                 return unreadable();
             prefixes.push(prefix);
         }
+        if (deployment === 'absent')
+            return Object.freeze({ state: 'request_only', requestMcpServerPrefixes: frozenSet(prefixes) });
         return Object.freeze({ state: 'directory', mcpServerPrefixes: frozenSet(prefixes) });
     }
     catch {

package/dist/eventLeg.d.ts

@@ -65,11 +65,6 @@ export interface EventLegIdleTriagePorts {
     readonly baseUrl: string;
 }
 export type EventLegTap = (frame: AgentEvent) => void;
-export type EventLegStreamDecorator = (stream: AsyncGenerator<AgentEvent>, ctx: EventLegStreamContext) => AsyncGenerator<AgentEvent>;
-export interface EventLegStreamContext {
-    readonly leg: EventLegKind;
-    readonly runId: string | undefined;
-}
 export interface ApprovalFrameContext {
     readonly leg: EventLegKind;
     readonly windowIsCurrent: boolean;
@@ -85,9 +80,8 @@ export interface EventLegPorts {
     readonly idleTriage?: EventLegIdleTriagePorts;
     readonly signal?: AbortSignal;
     readonly taps?: readonly EventLegTap[];
-    readonly perStream?: readonly EventLegStreamDecorator[];
 }
-export type EventLegPortName = 'run.headerRunId' | 'run.onBound' | 'run.onRefused' | 'run.onTerminal' | 'run.isCurrent' | 'hitl.question' | 'hitl.elicitation' | 'hitl.toolApproval' | 'askBridge.respondToolApproval' | 'taps' | 'perStream';
+export type EventLegPortName = 'run.headerRunId' | 'run.onBound' | 'run.onRefused' | 'run.onTerminal' | 'run.isCurrent' | 'hitl.question' | 'hitl.elicitation' | 'hitl.toolApproval' | 'askBridge.respondToolApproval' | 'taps';
 export interface EventLegReport {
     readonly missingPorts: readonly EventLegPortName[];
     readonly portFaults: Readonly<Partial<Record<EventLegPortName, number>>>;

package/dist/eventLeg.js

@@ -22,6 +22,12 @@ const FRAME_STAGE_DOMAINS = makeFrameStageDomains({
     stampOwner: Object.freeze(['task_progress']),
     hitlFrames: Object.freeze(['question', 'question_complete', 'elicitation', 'elicitation_complete', 'tool_approval', 'tool_approval_complete', 'approval_request', 'approval_revoke']),
 });
+const HITL_FRAMES_PROJECTED = Object.freeze(['human_input']);
+const _hitlFrameTypesPin = [true, true];
+const _hitlProjectedDisjointPin = true;
+void _hitlFrameTypesPin;
+void _hitlProjectedDisjointPin;
+void HITL_FRAMES_PROJECTED;
 const HITL_PORT_OF = Object.freeze({
     question: 'question',
     question_complete: 'question',
@@ -130,7 +136,6 @@ export function composeEventLeg(source, leg, ports) {
     };
     const sessionKey = typeof ports.owner?.sessionKey === 'string' && ports.owner.sessionKey !== '' ? ports.owner.sessionKey : undefined;
     const taps = (ports.taps ?? []).filter((t) => typeof t === 'function');
-    const decorators = (ports.perStream ?? []).filter((d) => typeof d === 'function');
     const info = Object.freeze({ leg: kind });
     const runSessions = new Map();
     let lastBound;
@@ -218,13 +223,7 @@ export function composeEventLeg(source, leg, ports) {
             ended.abort();
         }
     }
-    const streamOf = (raw, streamKind, streamRunId) => {
-        let s = generatorOf(raw);
-        const ctx = Object.freeze({ leg: streamKind, runId: streamRunId });
-        for (const d of decorators)
-            s = d(s, ctx);
-        return frameLevel(s, streamKind, streamRunId);
-    };
+    const streamOf = (raw, streamKind, streamRunId) => frameLevel(generatorOf(raw), streamKind, streamRunId);
     let inner = streamOf(source, kind, legRunId);
     if (hostBridge !== undefined) {
         let windowOpen = row.windowIsCurrent;

package/dist/fileHistoryCaptureCapability.d.ts

@@ -13,9 +13,6 @@ export type FileHistoryCaptureMode = 'off' | 'on-optional' | 'unknown';
 export declare function projectFileHistoryCaptureCapability(caps: unknown): FileHistoryCaptureReading | undefined;
 export declare function observedFileHistoryCapture(baseUrl?: string | undefined): FileHistoryCaptureReading;
 export declare function fileHistoryCaptureMode(reading: FileHistoryCaptureReading): FileHistoryCaptureMode;
-export declare function fileHistoryDeclarationField(reading: FileHistoryCaptureReading, captureOff: boolean): {
-    fileHistory: 'disabled';
-} | Record<string, never>;
 export declare const FILE_HISTORY_TIGHTEN_VERDICTS: readonly ["not_requested", "declare", "already_off", "unjudged"];
 export type FileHistoryTightenVerdict = (typeof FILE_HISTORY_TIGHTEN_VERDICTS)[number];
 export declare function fileHistoryTightenVerdict(reading: FileHistoryCaptureReading, captureOffByUser: boolean): FileHistoryTightenVerdict;

package/dist/fileHistoryCaptureCapability.js

@@ -4,7 +4,6 @@ import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { refreshEngineCapsOnce } from './engineCapsCache.js';
 import { ownDataField } from './ownKey.js';
-import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
 export function projectFileHistoryCaptureCapability(caps) {
     try {
         if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
@@ -47,9 +46,6 @@ export function fileHistoryCaptureMode(reading) {
         return 'on-optional';
     return 'unknown';
 }
-export function fileHistoryDeclarationField(reading, captureOff) {
-    return captureOff === true && fileHistoryCaptureMode(reading) === 'on-optional' ? { fileHistory: FILE_HISTORY_DISABLED } : {};
-}
 export const FILE_HISTORY_TIGHTEN_VERDICTS = Object.freeze(['not_requested', 'declare', 'already_off', 'unjudged']);
 export function fileHistoryTightenVerdict(reading, captureOffByUser) {
     if (captureOffByUser !== true)