@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/skillsWireCaps.d.ts

@@ -1,8 +1,5 @@
 import type { SkillSpec } from '@sema-agent/sdk';
 import { type SkillToolListsReading } from './skillToolListsCapability.js';
-export declare const SKILL_CAPS: {
-    readonly content: 1048576;
-};
 export interface SkillCmdLike {
     type?: string;
     name?: string;
@@ -24,4 +21,18 @@ export interface SkillSpecsOptions {
     skillToolLists?: SkillToolListsReading;
 }
 export declare function skillBaseDirOf(skillRoot: string | undefined, platform?: 'posix' | 'win32'): string | undefined;
+export type SkillToolListKey = 'allowedTools' | 'disallowedTools';
+export type SkillToolListsVerdict = {
+    readonly kind: 'ok';
+    readonly lists: {
+        allowedTools?: string[];
+        disallowedTools?: string[];
+    };
+} | {
+    readonly kind: 'bad';
+    readonly key: SkillToolListKey;
+    readonly index?: number;
+    readonly detail: string;
+};
+export declare function skillToolListsVerdict(source: object, reading: SkillToolListsReading | undefined): SkillToolListsVerdict;
 export declare function skillCommandsToSpecs(cmds: SkillCmdLike[], resolveBody: (cmd: SkillCmdLike) => string | null, opts?: SkillSpecsOptions): SkillSpecOnWire[];

package/dist/skillsWireCaps.js

@@ -1,8 +1,9 @@
 import { skillToolListsAvailable } from './skillToolListsCapability.js';
-export const SKILL_CAPS = { content: 1_048_576 };
+import { msg, renderMessage } from './i18n/translate.js';
+import { appendOwnElement } from './ownKey.js';
 export function toCappedSpec(name, description, whenToUse, body) {
     const n = name.trim();
-    const c = body.trim().slice(0, SKILL_CAPS.content);
+    const c = body.trim();
     if (!n || !c)
         return null;
     const desc = [description.trim(), whenToUse.trim()]
@@ -28,14 +29,14 @@ export function skillBaseDirOf(skillRoot, platform = 'posix') {
         return undefined;
     return skillRoot;
 }
-function readSkillToolList(skillName, key, cmd) {
-    const who = `skillCommandsToSpecs: skill ${JSON.stringify(skillName.slice(0, 80))} ${key}`;
+const SKILL_TOOL_LIST_READ_BUDGET = 100_000;
+function readSkillToolList(key, source) {
     const hint = 'The list is the skill’s own tool rule list and is sent exactly as given (entries are never dropped, repaired, reordered or truncated here), ' +
         'so a value that is not a list of strings is refused instead of being silently reduced.';
-    const unreadable = () => new TypeError(`${who} could not be read — reading it (the property, the array length or an entry) threw. ${hint}`);
+    const unreadable = () => new TypeError(`could not be read — reading it (the property, the array length or an entry) threw. ${hint}`);
     let v;
     try {
-        v = cmd[key];
+        v = source[key];
     }
     catch {
         throw unreadable();
@@ -50,7 +51,7 @@ function readSkillToolList(skillName, key, cmd) {
         throw unreadable();
     }
     if (!isArray) {
-        throw new TypeError(`${who} must be an array of strings or absent — got ${v === null ? 'null' : typeof v === 'object' ? 'a non-array object' : `typeof ${typeof v}`}. ${hint}`);
+        throw new TypeError(`must be an array of strings or absent — got ${v === null ? 'null' : typeof v === 'object' ? 'a non-array object' : `typeof ${typeof v}`}. ${hint}`);
     }
     const list = v;
     let lengthRead;
@@ -61,7 +62,10 @@ function readSkillToolList(skillName, key, cmd) {
         throw unreadable();
     }
     if (typeof lengthRead !== 'number' || !Number.isSafeInteger(lengthRead) || lengthRead < 0 || lengthRead > 4_294_967_295) {
-        throw new TypeError(`${who} must be an array of strings or absent — its length is not a valid array length. ${hint}`);
+        throw new TypeError(`must be an array of strings or absent — its length is not a valid array length. ${hint}`);
+    }
+    if (lengthRead > SKILL_TOOL_LIST_READ_BUDGET) {
+        throw new TypeError(renderMessage(msg('config.skills.toolListTooMany', { got: String(SKILL_TOOL_LIST_READ_BUDGET) })));
     }
     const n = lengthRead;
     const out = [];
@@ -74,18 +78,45 @@ function readSkillToolList(skillName, key, cmd) {
             throw unreadable();
         }
         if (typeof e !== 'string') {
-            throw new TypeError(`${who} must be an array of strings or absent — the entry at index ${i} is ${e === null ? 'null' : `typeof ${typeof e}`}. ${hint}`);
+            throw Object.assign(new TypeError(`must be an array of strings or absent — the entry at index ${i} is ${e === null ? 'null' : `typeof ${typeof e}`}. ${hint}`), { index: i });
         }
-        out.push(e);
+        appendOwnElement(out, e);
     }
     return out;
 }
+function refusalOf(e, key) {
+    const index = e.index;
+    return { kind: 'bad', key, ...(typeof index === 'number' ? { index } : {}), detail: e.message };
+}
+export function skillToolListsVerdict(source, reading) {
+    if (reading === undefined)
+        return { kind: 'ok', lists: {} };
+    let allowedTools;
+    let disallowedTools;
+    try {
+        allowedTools = readSkillToolList('allowedTools', source);
+    }
+    catch (e) {
+        return refusalOf(e, 'allowedTools');
+    }
+    try {
+        disallowedTools = readSkillToolList('disallowedTools', source);
+    }
+    catch (e) {
+        return refusalOf(e, 'disallowedTools');
+    }
+    const toolListsOn = skillToolListsAvailable(reading ?? { kind: 'unobserved' }) === 'yes';
+    const lists = {};
+    if (toolListsOn && allowedTools !== undefined)
+        lists.allowedTools = allowedTools;
+    if (toolListsOn && disallowedTools !== undefined)
+        lists.disallowedTools = disallowedTools;
+    return { kind: 'ok', lists };
+}
 export function skillCommandsToSpecs(cmds, resolveBody, opts) {
     const specs = [];
     const seen = new Set();
     const reading = opts?.skillToolLists;
-    const wired = reading !== undefined;
-    const toolListsOn = wired && skillToolListsAvailable(reading ?? { kind: 'unobserved' }) === 'yes';
     for (const cmd of cmds) {
         if (cmd.type !== 'prompt' || cmd.disableModelInvocation)
             continue;
@@ -97,15 +128,14 @@ export function skillCommandsToSpecs(cmds, resolveBody, opts) {
             continue;
         seen.add(spec.name);
         const baseDir = opts?.toolsRunHere === true ? skillBaseDirOf(cmd.skillRoot, opts.platform ?? 'posix') : undefined;
-        const allowedTools = wired ? readSkillToolList(spec.name, 'allowedTools', cmd) : undefined;
-        const disallowedTools = wired ? readSkillToolList(spec.name, 'disallowedTools', cmd) : undefined;
+        const verdict = skillToolListsVerdict(cmd, reading);
+        if (verdict.kind === 'bad') {
+            throw new TypeError(`skillCommandsToSpecs: skill ${JSON.stringify(spec.name.slice(0, 80))} ${verdict.key} ${verdict.detail}`);
+        }
         let wire = spec;
         if (baseDir !== undefined)
             wire = { ...wire, baseDir };
-        if (toolListsOn && allowedTools !== undefined)
-            wire = { ...wire, allowedTools };
-        if (toolListsOn && disallowedTools !== undefined)
-            wire = { ...wire, disallowedTools };
+        wire = { ...wire, ...verdict.lists };
         specs.push(wire);
     }
     return specs;

package/dist/slashCommandGate.d.ts

@@ -0,0 +1,24 @@
+import type { Capabilities } from '@sema-agent/sdk';
+import { SLASH_COMMAND_ROSTER_PIN, type SlashCommandBucket, type SlashCommandOverride, type SlashCommandPosture } from './slashCommandTable.js';
+export { SLASH_COMMAND_ROSTER_PIN };
+export type { SlashCommandBucket, SlashCommandOverride, SlashCommandPosture };
+export declare const SLASH_COMMAND_BUCKETS: Readonly<Record<SlashCommandBucket, readonly string[]>>;
+export type SlashCommandGateReason = 'cc-availability' | 'cc-isEnabled' | 'config-deny' | 'capability-absent' | 'capability-degraded' | 'hidden-from-help' | 'allowed';
+export type SlashCommandGateState = 'allowed' | 'degraded' | 'denied';
+export interface SlashCommandGateInput {
+    readonly name: string;
+    readonly source?: string;
+    readonly ccAvailable?: boolean;
+    readonly ccEnabled?: boolean;
+}
+export interface SlashCommandVerdict {
+    readonly state: SlashCommandGateState;
+    readonly visible: boolean;
+    readonly degraded: boolean;
+    readonly hidden: boolean;
+    readonly reason: SlashCommandGateReason;
+    readonly requiredCapability?: string;
+}
+export declare function slashCommandBucketOf(name: string): SlashCommandBucket | undefined;
+export declare function slashCommandOverrideOf(name: string): SlashCommandOverride | undefined;
+export declare function judgeSlashCommand(command: SlashCommandGateInput, capabilities: Capabilities | undefined): SlashCommandVerdict;

package/dist/slashCommandGate.js

@@ -0,0 +1,74 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+import { SLASH_COMMAND_BUCKET_FLEET_NA, SLASH_COMMAND_BUCKET_MAPPABLE_TO_SDK, SLASH_COMMAND_BUCKET_POSTURE_TABLE, SLASH_COMMAND_BUCKET_PURE_UI, SLASH_COMMAND_OVERRIDE_ROWS, SLASH_COMMAND_ROSTER_PIN, } from './slashCommandTable.js';
+export { SLASH_COMMAND_ROSTER_PIN };
+export const SLASH_COMMAND_BUCKETS = Object.freeze({
+    pureUI: SLASH_COMMAND_BUCKET_PURE_UI,
+    mappableToSdk: SLASH_COMMAND_BUCKET_MAPPABLE_TO_SDK,
+    fleetNA: SLASH_COMMAND_BUCKET_FLEET_NA,
+});
+const BUCKET_INDEX = new Map([
+    ...SLASH_COMMAND_BUCKET_PURE_UI.map((n) => [n, 'pureUI']),
+    ...SLASH_COMMAND_BUCKET_MAPPABLE_TO_SDK.map((n) => [n, 'mappableToSdk']),
+    ...SLASH_COMMAND_BUCKET_FLEET_NA.map((n) => [n, 'fleetNA']),
+]);
+const OVERRIDE_INDEX = new Map(SLASH_COMMAND_OVERRIDE_ROWS);
+export function slashCommandBucketOf(name) {
+    return typeof name === 'string' ? BUCKET_INDEX.get(name) : undefined;
+}
+export function slashCommandOverrideOf(name) {
+    return typeof name === 'string' ? OVERRIDE_INDEX.get(name) : undefined;
+}
+function capabilityPresent(capabilities, key) {
+    try {
+        const v = guardedRead(() => readOwnDataValue(capabilities, key));
+        if (typeof v === 'boolean')
+            return v;
+        if (typeof v === 'string')
+            return v.length > 0;
+        if (Array.isArray(v))
+            return v.length > 0;
+        return Boolean(v);
+    }
+    catch {
+        return false;
+    }
+}
+function slot(input, key) {
+    return guardedRead(() => readOwnDataValue(input, key));
+}
+function verdict(state, hidden, reason, requiredCapability) {
+    return Object.freeze({
+        state,
+        visible: state !== 'denied',
+        degraded: state === 'degraded',
+        hidden,
+        reason,
+        ...(requiredCapability !== undefined ? { requiredCapability } : {}),
+    });
+}
+export function judgeSlashCommand(command, capabilities) {
+    const rawName = slot(command, 'name');
+    const name = typeof rawName === 'string' ? rawName : '';
+    if (slot(command, 'ccAvailable') === false)
+        return verdict('denied', false, 'cc-availability');
+    if (slot(command, 'ccEnabled') === false)
+        return verdict('denied', false, 'cc-isEnabled');
+    const override = OVERRIDE_INDEX.get(name);
+    const bucket = BUCKET_INDEX.get(name);
+    const bucketPosture = (bucket !== undefined ? SLASH_COMMAND_BUCKET_POSTURE_TABLE[bucket] : undefined) ?? 'allow';
+    const explicit = override?.mode;
+    const mode = explicit === 'allow' || explicit === 'deny' ? explicit : bucketPosture;
+    if (mode === 'deny')
+        return verdict('denied', false, 'config-deny');
+    const source = slot(command, 'source');
+    const builtin = source === undefined || source === 'builtin';
+    const unbucketedFallthrough = builtin && bucket === undefined && explicit !== 'allow' && explicit !== 'deny';
+    const hidden = override?.hidden === true || unbucketedFallthrough;
+    const required = override?.requiredCapability;
+    if (required !== undefined && required !== '' && !capabilityPresent(capabilities, required)) {
+        if (override?.degradeWhenAbsent === true)
+            return verdict('degraded', hidden, 'capability-degraded', required);
+        return verdict('denied', false, 'capability-absent', required);
+    }
+    return verdict('allowed', hidden, hidden ? 'hidden-from-help' : 'allowed', required !== undefined && required !== '' ? required : undefined);
+}

package/dist/slashCommandTable.d.ts

@@ -0,0 +1,14 @@
+export declare const SLASH_COMMAND_ROSTER_PIN = "CC 2.1.187";
+export type SlashCommandBucket = 'pureUI' | 'mappableToSdk' | 'fleetNA';
+export type SlashCommandPosture = 'allow' | 'deny';
+export interface SlashCommandOverride {
+    readonly mode: 'allow' | 'deny' | 'auto';
+    readonly requiredCapability?: string;
+    readonly degradeWhenAbsent?: boolean;
+    readonly hidden?: boolean;
+}
+export declare const SLASH_COMMAND_BUCKET_POSTURE_TABLE: Readonly<Record<SlashCommandBucket, SlashCommandPosture>>;
+export declare const SLASH_COMMAND_BUCKET_PURE_UI: readonly string[];
+export declare const SLASH_COMMAND_BUCKET_MAPPABLE_TO_SDK: readonly string[];
+export declare const SLASH_COMMAND_BUCKET_FLEET_NA: readonly string[];
+export declare const SLASH_COMMAND_OVERRIDE_ROWS: readonly (readonly [string, SlashCommandOverride])[];

package/dist/slashCommandTable.js

@@ -0,0 +1,99 @@
+export const SLASH_COMMAND_ROSTER_PIN = 'CC 2.1.187';
+export const SLASH_COMMAND_BUCKET_POSTURE_TABLE = Object.freeze({
+    pureUI: 'allow',
+    mappableToSdk: 'allow',
+    fleetNA: 'deny',
+});
+export const SLASH_COMMAND_BUCKET_PURE_UI = Object.freeze([
+    'color', 'theme', 'tui', 'brief', 'scroll-speed', 'terminal-setup',
+    'help', 'exit', 'copy', 'export', 'diff', 'config',
+    'ide', 'add-dir', 'cd', 'powerup', 'feedback', 'btw',
+    'advisor', 'fast', 'effort', 'heapdump', 'version', 'stickers',
+    'keybindings', 'statusline', 'vim', 'install', 'passes', 'clear',
+    'recap',
+]);
+export const SLASH_COMMAND_BUCKET_MAPPABLE_TO_SDK = Object.freeze([
+    'init', 'init-verifiers', 'review', 'insights', 'team-onboarding', 'compact',
+    'context', 'resume', 'model', 'usage', 'cost', 'permissions',
+    'hooks', 'plan', 'memory', 'tasks', 'stop', 'workflows',
+    'skills', 'mcp', 'agents', 'plugin', 'reload-plugins', 'rename',
+    'branch', 'goal', 'commit-push-pr', 'import', 'explain-usage',
+]);
+export const SLASH_COMMAND_BUCKET_FLEET_NA = Object.freeze([
+    'files', 'think-back', 'thinkback-play', 'commit', 'login', 'logout',
+    'setup-bedrock', 'setup-vertex', 'upgrade', 'usage-credits', 'extra-usage', 'rate-limit-options',
+    'pro-trial-expired', 'desktop', 'session', 'teleport', 'remote-control', 'remote-env',
+    'web-setup', 'ultraplan', 'ultrareview', 'install-github-app', 'install-slack-app', 'design-login',
+    'autofix-pr', 'mobile', 'tag', 'privacy-settings',
+]);
+export const SLASH_COMMAND_OVERRIDE_ROWS = Object.freeze([
+    ['status', { mode: 'allow' }],
+    ['doctor', { mode: 'allow' }],
+    ['rewind', { mode: 'allow' }],
+    ['skill-doctor', { mode: 'allow' }],
+    ['memory-capture', { mode: 'allow' }],
+    ['init', { mode: 'auto' }],
+    ['init-verifiers', { mode: 'auto' }],
+    ['review', { mode: 'auto' }],
+    ['insights', { mode: 'auto' }],
+    ['team-onboarding', { mode: 'auto' }],
+    ['compact', { mode: 'auto', degradeWhenAbsent: true }],
+    ['context', { mode: 'auto', degradeWhenAbsent: true }],
+    ['resume', { mode: 'auto', requiredCapability: 'asyncRuns', degradeWhenAbsent: true }],
+    ['tasks', { mode: 'auto', requiredCapability: 'asyncRuns' }],
+    ['stop', { mode: 'auto', requiredCapability: 'asyncRuns' }],
+    ['workflows', { mode: 'auto', requiredCapability: 'asyncRuns' }],
+    ['usage', { mode: 'auto', requiredCapability: 'pricingConfigured', degradeWhenAbsent: true }],
+    ['cost', { mode: 'auto', requiredCapability: 'pricingConfigured', degradeWhenAbsent: true }],
+    ['stats', { mode: 'allow' }],
+    ['vim', { mode: 'auto', hidden: true }],
+    ['statusline', { mode: 'auto', hidden: true }],
+    ['permissions', { mode: 'auto', requiredCapability: 'approvals', degradeWhenAbsent: true }],
+    ['plan', { mode: 'auto', requiredCapability: 'approvals', degradeWhenAbsent: true }],
+    ['goal', { mode: 'auto', requiredCapability: 'approvals', degradeWhenAbsent: true }],
+    ['hooks', { mode: 'auto', degradeWhenAbsent: true }],
+    ['memory', { mode: 'auto', requiredCapability: 'memory' }],
+    ['model', { mode: 'auto' }],
+    ['skills', { mode: 'auto', degradeWhenAbsent: true }],
+    ['mcp', { mode: 'auto', degradeWhenAbsent: true }],
+    ['agents', { mode: 'auto', degradeWhenAbsent: true }],
+    ['plugin', { mode: 'auto', degradeWhenAbsent: true }],
+    ['reload-plugins', { mode: 'auto', degradeWhenAbsent: true }],
+    ['rename', { mode: 'auto', degradeWhenAbsent: true }],
+    ['branch', { mode: 'auto', degradeWhenAbsent: true }],
+    ['loops', { mode: 'deny' }],
+    ['update', { mode: 'deny' }],
+    ['collab', { mode: 'allow' }],
+    ['websearch', { mode: 'allow' }],
+    ['import', { mode: 'auto' }],
+    ['explain-usage', { mode: 'auto' }],
+    ['mobile', { mode: 'deny' }],
+    ['tag', { mode: 'deny' }],
+    ['files', { mode: 'deny' }],
+    ['privacy-settings', { mode: 'deny' }],
+    ['think-back', { mode: 'deny' }],
+    ['thinkback-play', { mode: 'deny' }],
+    ['commit', { mode: 'deny' }],
+    ['login', { mode: 'deny' }],
+    ['logout', { mode: 'deny' }],
+    ['setup-bedrock', { mode: 'deny' }],
+    ['setup-vertex', { mode: 'deny' }],
+    ['upgrade', { mode: 'deny' }],
+    ['usage-credits', { mode: 'deny' }],
+    ['extra-usage', { mode: 'deny' }],
+    ['rate-limit-options', { mode: 'allow' }],
+    ['pro-trial-expired', { mode: 'deny' }],
+    ['desktop', { mode: 'deny' }],
+    ['session', { mode: 'deny' }],
+    ['teleport', { mode: 'deny' }],
+    ['remote-control', { mode: 'deny' }],
+    ['remote-env', { mode: 'deny' }],
+    ['web-setup', { mode: 'deny' }],
+    ['ultraplan', { mode: 'deny' }],
+    ['ultrareview', { mode: 'deny' }],
+    ['install-github-app', { mode: 'deny' }],
+    ['install-slack-app', { mode: 'deny' }],
+    ['design-login', { mode: 'deny' }],
+    ['autofix-pr', { mode: 'deny' }],
+    ['daemon', { mode: 'allow', requiredCapability: 'asyncRuns', degradeWhenAbsent: true }],
+]);

package/dist/sqlEngineCapability.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { storeSeatOf, createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSqlEngineCapability(caps) {
@@ -40,7 +40,7 @@ const reader = createEngineCapReader({
     name: 'sql',
     project: projectSqlEngineCapability,
 });
-export function observedSqlEngine(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSqlEngine(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 const SQL_DETAIL_MAX = 40;

package/dist/steerPriorityCapability.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { ownDataField } from './ownKey.js';
 export function projectSteerPriorityCapability(caps) {
@@ -26,7 +26,7 @@ const reader = createEngineCapReader({
     name: 'fleet.steerPriority',
     project: projectSteerPriorityCapability,
 });
-export function observedSteerPriority(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedSteerPriority(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 export function steerPriorityMode(reading) {

package/dist/storePostureCapability.js

@@ -1,5 +1,5 @@
 import { capForDisplay } from './fleetTaskDesc.js';
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { storeSeatOf, createEngineCapReader, unreadableReadingDetail } from './engineCapReader.js';
 import { projectSqlEngineCapability } from './sqlEngineCapability.js';
 import { ownDataField } from './ownKey.js';
@@ -45,7 +45,7 @@ const reader = createEngineCapReader({
     name: 'store',
     project: projectStorePostureCapability,
 });
-export function observedStorePosture(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedStorePosture(baseUrl = engineWireTargetBaseUrl()) {
     return reader.observed(baseUrl);
 }
 function presentView(reading) {

package/dist/subagent/agentStateDetail.js

@@ -4,7 +4,7 @@ function own(v, key) {
         return undefined;
     try {
         const d = Object.getOwnPropertyDescriptor(v, key);
-        return d !== undefined && 'value' in d ? d.value : undefined;
+        return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
     }
     catch {
         return undefined;

package/dist/subagent/engineDelegatedPrompt.d.ts

@@ -1,4 +1,5 @@
 import type { AgentClient } from '@sema-agent/sdk';
+import type { UiLanguage } from '../env/uiLanguage.js';
 import type { EngineWireInjection } from '../engineWireSdk.js';
 export type DelegatedPromptWireClient = {
     sessions: Pick<AgentClient['sessions'], 'get'>;
@@ -11,9 +12,17 @@ export declare function delegatedPromptText(content: unknown): string | undefine
 export declare function pickDelegatedPrompt(messages: readonly unknown[]): string | undefined;
 type TranscriptWindowReader = (transcriptId: string) => Promise<readonly unknown[] | null>;
 export declare function __setTranscriptWindowReaderForTests(r: TranscriptWindowReader | null): void;
+export declare const DELEGATED_PROMPT_ABSENCE_CAUSES: readonly ["not_owned_after_restart", "not_in_store", "forbidden", "prompt_absent", "unknown"];
+export type DelegatedPromptAbsenceCause = (typeof DELEGATED_PROMPT_ABSENCE_CAUSES)[number];
+export interface DelegatedPromptAbsence {
+    readonly cause: DelegatedPromptAbsenceCause;
+    readonly text: string;
+}
+export declare function delegatedPromptAbsenceSentence(cause: DelegatedPromptAbsenceCause | string, lang?: UiLanguage): string;
 export interface DelegatedPromptFetch {
     prompt?: string;
     outcome: 'hit' | 'skipped' | 'unreadable' | 'absent';
+    absence?: DelegatedPromptAbsence;
 }
 export declare function fetchDelegatedPrompt(taskId: string, opts?: {
     wire?: DelegatedPromptWire;

package/dist/subagent/engineDelegatedPrompt.js

@@ -1,6 +1,8 @@
 import { stripSystemReminderBlocks } from '../systemReminderTag.js';
 import { hostLog } from '../host.js';
 import { isSessionIdPathSegment } from '../sessionIdSegment.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+import { readThrownSlot } from '../wireFailureShape.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected } from '../engineWireFor.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { panelAnchorOf } from '../panelReduce.js';
@@ -22,7 +24,7 @@ export function __resetEngineDelegatedPromptForTests() {
     clearEnginePanelAnchors();
     promptHydrateInFlight.clear();
 }
-const promptHydrateInFlight = new Set();
+const promptHydrateInFlight = new Map();
 function roleOf(entry) {
     if (typeof entry !== 'object' || entry === null)
         return undefined;
@@ -113,13 +115,38 @@ async function readTranscriptWindow(transcriptId, sessionKey, injectedWire) {
     const msgs = rec.messages;
     return Array.isArray(msgs) ? msgs : null;
 }
+export const DELEGATED_PROMPT_ABSENCE_CAUSES = Object.freeze(['not_owned_after_restart', 'not_in_store', 'forbidden', 'prompt_absent', 'unknown']);
+const ABSENCE_KEY = {
+    not_owned_after_restart: 'session.subagent.delegatedPrompt.absence.notOwnedAfterRestart',
+    not_in_store: 'session.subagent.delegatedPrompt.absence.notInStore',
+    forbidden: 'session.subagent.delegatedPrompt.absence.forbidden',
+    prompt_absent: 'session.subagent.delegatedPrompt.absence.promptAbsent',
+    unknown: 'session.subagent.delegatedPrompt.absence.unknown',
+};
+export function delegatedPromptAbsenceSentence(cause, lang) {
+    const known = typeof cause === 'string' && Object.hasOwn(ABSENCE_KEY, cause);
+    return renderMessage(msg(known ? ABSENCE_KEY[cause] : ABSENCE_KEY.unknown), lang);
+}
+function absenceOf(cause) {
+    return Object.freeze({ cause, text: delegatedPromptAbsenceSentence(cause) });
+}
+function absenceOfThrown(e) {
+    const status = readThrownSlot(e, 'status');
+    if (status === 404)
+        return absenceOf('not_in_store');
+    if (status === 401 || status === 403)
+        return absenceOf('forbidden');
+    return absenceOf('unknown');
+}
 export async function fetchDelegatedPrompt(taskId, opts) {
-    if (promptHydrateInFlight.has(taskId))
-        return { outcome: 'skipped' };
+    if (promptHydrateInFlight.has(taskId)) {
+        const settled = promptHydrateInFlight.get(taskId);
+        return settled ? { outcome: 'skipped', absence: settled } : { outcome: 'skipped' };
+    }
     const transcriptId = getEngineTranscriptId(taskId);
     if (!isSessionIdPathSegment(transcriptId))
-        return { outcome: 'skipped' };
-    promptHydrateInFlight.add(taskId);
+        return { outcome: 'skipped', absence: absenceOf(transcriptId === undefined ? 'not_owned_after_restart' : 'unknown') };
+    promptHydrateInFlight.set(taskId, null);
     let msgs = null;
     try {
         msgs = await readTranscriptWindow(transcriptId, resolveOwnerContext(taskId).key, opts?.wire);
@@ -127,14 +154,18 @@ export async function fetchDelegatedPrompt(taskId, opts) {
     catch (e) {
         promptHydrateInFlight.delete(taskId);
         hostLog('debug', `[delegated-prompt] ${taskId} transcript ${transcriptId} read failed: ${String(e).slice(0, 160)}`);
-        return { outcome: 'unreadable' };
+        return { outcome: 'unreadable', absence: absenceOfThrown(e) };
     }
     const prompt = msgs ? pickDelegatedPrompt(msgs) : undefined;
     if (!prompt) {
         if (msgs === null)
             promptHydrateInFlight.delete(taskId);
         hostLog('debug', `[delegated-prompt] ${taskId} transcript ${transcriptId}: ${msgs === null ? 'transcript unreadable (retryable)' : 'no delegated user message (final)'}`);
-        return { outcome: msgs === null ? 'unreadable' : 'absent' };
+        if (msgs === null)
+            return { outcome: 'unreadable', absence: absenceOf('unknown') };
+        const settled = absenceOf('prompt_absent');
+        promptHydrateInFlight.set(taskId, settled);
+        return { outcome: 'absent', absence: settled };
     }
     hostLog('debug', `[delegated-prompt] ${taskId} <- transcript ${transcriptId} (${prompt.length} chars) head=${JSON.stringify(prompt.slice(0, 60))}`);
     return { prompt, outcome: 'hit' };

package/dist/subagent/engineRowStopGate.js

@@ -1,5 +1,5 @@
 import { engineCapTrue } from '../engineCapsCache.js';
-import { engineWireTargetFor } from '../engineWireTarget.js';
+import { engineWireTargetBaseUrl } from '../engineWireTarget.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 export const engineOwnedRowIds = new Set();
 export const fleetViewStubRowIds = new Set();
@@ -7,7 +7,7 @@ export function isEngineViewRow(taskId) {
     return engineOwnedRowIds.has(taskId) || fleetViewStubRowIds.has(taskId);
 }
 export function engineTaskHandlesCapable(sessionKey = DEFAULT_SESSION_KEY, capsBaseUrl) {
-    return engineCapTrue(capsBaseUrl ?? engineWireTargetFor(sessionKey)?.baseUrl, 'taskHandles');
+    return engineCapTrue(capsBaseUrl ?? engineWireTargetBaseUrl(sessionKey), 'taskHandles');
 }
 export function engineRowNeedsStopConfirm(taskId, sessionKey, capsBaseUrl) {
     return isEngineViewRow(taskId) && engineTaskHandlesCapable(sessionKey ?? DEFAULT_SESSION_KEY, capsBaseUrl);

package/dist/subagent/engineSubagentResume.js

@@ -5,13 +5,13 @@ import { RESUME_SESSION_NOT_FOUND } from '../engineErrorCodes.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
 import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
-import { engineWireTargetFor } from '../engineWireTarget.js';
+import { engineWireTargetBaseUrl } from '../engineWireTarget.js';
 import { activeEngineRunId, engineSessionParamFor } from '../engineSessionParam.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { getBgParentRunOwner, parentToolCallIdOf, } from '../subagentContentStore.js';
 export const SUBAGENT_RESUME_CAP = 'subagentResume';
 export function subagentResumeAvailable(baseUrl, sessionKey = DEFAULT_SESSION_KEY) {
-    return engineCapTrue(baseUrl ?? engineWireTargetFor(sessionKey)?.baseUrl, SUBAGENT_RESUME_CAP);
+    return engineCapTrue(baseUrl ?? engineWireTargetBaseUrl(sessionKey), SUBAGENT_RESUME_CAP);
 }
 export function resolveSubagentContinueTarget(rowId, displayName) {
     const precise = parentToolCallIdOf(rowId);
@@ -149,7 +149,7 @@ export async function resumeSettledSubagent(facade, runId, target, content, opts
 }
 const warnedRetainWithoutWake = new Set();
 export function auditRetainWithoutWake(input) {
-    const baseUrl = input.baseUrl ?? engineWireTargetFor(input.sessionKey ?? DEFAULT_SESSION_KEY)?.baseUrl;
+    const baseUrl = input.baseUrl ?? engineWireTargetBaseUrl(input.sessionKey ?? DEFAULT_SESSION_KEY);
     if (!engineCapTrue(baseUrl, SUBAGENT_RESUME_CAP))
         return undefined;
     if (input.retainRequested === false)

package/dist/subagent/engineTaskHandleWire.d.ts

@@ -13,6 +13,7 @@ export interface EngineTaskOutputResult {
     status?: string;
     stoppedBy?: string;
     partialResult?: boolean;
+    exitCode?: number;
 }
 export declare function __resetTaskHandleWireForTests(): void;
 export declare function fetchEngineTaskOutput(handle: string, opts?: {

package/dist/subagent/engineTaskHandleWire.js

@@ -6,6 +6,7 @@ import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { engineTaskHandlesCapable } from './engineRowStopGate.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
+import { guardedRead, readOwnDataValue } from '../ownKey.js';
 function usableTaskOutputClient(client) {
     return clientHasVerbs(client, [['runs', 'taskOutput']]);
 }
@@ -27,6 +28,13 @@ function sessionOf(ctx) {
     const s = ctx.record?.sessionId ?? engineSessionParamFor(ctx.key);
     return s !== undefined ? { session: s } : {};
 }
+function exitCodeOfTaskOutput(output) {
+    const details = guardedRead(() => readOwnDataValue(output, 'details'));
+    if (typeof details !== 'object' || details === null)
+        return undefined;
+    const code = guardedRead(() => readOwnDataValue(details, 'exitCode'));
+    return typeof code === 'number' && Number.isInteger(code) ? code : undefined;
+}
 const accumulated = new Map();
 export function __resetTaskHandleWireForTests() {
     accumulated.clear();
@@ -67,11 +75,13 @@ export async function fetchEngineTaskOutput(handle, opts) {
         if (engineWireDebugEnabled()) {
             hostLog('debug', `[task-handle] output ${handle} via run ${runId}: ok fresh=${fresh.length}b merged=${merged.length}b status=${typeof out.status === 'string' ? out.status : '-'}`);
         }
+        const exitCode = exitCodeOfTaskOutput(out);
         return {
             content: merged,
             ...(typeof out.status === 'string' ? { status: out.status } : {}),
             ...(typeof out.stoppedBy === 'string' ? { stoppedBy: out.stoppedBy } : {}),
             ...(out.partial_result === true ? { partialResult: true } : {}),
+            ...(exitCode !== undefined ? { exitCode } : {}),
         };
     }
     catch (e) {

package/dist/subagentContentStore.d.ts

@@ -44,6 +44,7 @@ export declare const SUBAGENT_CONTENT_STORE_DEFAULTS: Readonly<SubagentContentSt
 export declare function configureSubagentContentStore(next: Partial<SubagentContentStoreConfig>): void;
 export declare function subagentContentStoreConfig(): SubagentContentStoreConfig;
 export declare function __resetSubagentContentStoreConfigForTests(): void;
+export declare function bindSubagentIdentityReader(fn: (id: string) => readonly string[] | undefined): void;
 export declare function registerSubagentContentAlias(parentToolCallId: string, taskId: string): void;
 export declare function registerSubagentAlias(parentToolCallId: string, taskId: string): void;
 export declare function publishSubagentContentEvent(ev: SubagentContentEvent): void;