@sema-agent/client-core 0.84.0 → 0.85.0

package/dist/request/taskRequest.js

@@ -23,6 +23,7 @@ export const REQUEST_FIELD_MATRIX = [
     { field: 'memoryCapture', lanes: ['interactive', 'print', 'utility'], live: true, why: '本会话永远不进长期记忆的**声明形**(server §12.4 body 键,单成员闭集 "off");每条车道都是提交面 ⇒ 都能声明。与 memoryWrite:false 不是一个轴(那是「本 run 只读平面」)。⚠️ parked 续跑腿结构性拿不到声明(决策/续跑端点从持久 body 重建 spec),那是引擎侧事实,不是本层的漏', whyUtilityLane: '有座:side-channel 提交是壳自己的一次性问答,**绝不该**进用户的长期记忆 —— 这一位正是那句声明,且它是收紧方向,带上去只会更严' },
     { field: 'memory', lanes: ['interactive', 'print', 'utility'], live: true, why: '这一次运行不挂记忆面的**请求级**开关(server §12.7 body 键,单成员闭集 "off");每条车道都是提交面 ⇒ 都能声明。与 memoryCapture(采集面)不是一个轴、可并存;与 memoryWrite:false(只读平面)也不是一个轴', whyUtilityLane: '有座:side-channel 提交不需要挂记忆面(不挂记忆段 / 索引 / 三只记忆工具),省 token 且零记忆写入;与 memoryCapture 不是一个轴,两条都带' },
     { field: 'approverPosture', lanes: ['interactive', 'print'], live: true, why: '宿主对这个 run 的**审批姿态声明**(「这个 run 的审批卡由我自己自动答」;单成员闭集 `"bypass"`)。🔴 它不授权任何东西、也不是一只门:引擎只把这句声明**渲**给模型(它自己的标记块,首个回合),没有任何裁决腿读它 —— 与 `permissionMode` 的 `bypassPermissions`(选门的形状)**不是一回事**,两键在请求体上各自原样过境、**互不派生**:宿主完全可以一边留着缺省权限模式、一边自己自动答这个 run 的审批卡。🔴 **声明它的唯一条件是「宿主确实自己自动答这个 run 的审批卡」,不许据此推导或改动 `permissionMode`** —— 拿这一位当理由去把门放宽,是把一句只渲给模型看的话读成了授权。宿主并不自动答卡却声明了它 ⇒ 那是对模型说了一句与实际不符的话,修法是**别声明**,不是去动门。加座的理由是**一个事实一处铸点**:同样一句话,要么由引擎在它自己的标记块里说,要么由壳把提醒形文本拼进本 turn 的输入 —— 后者在模型眼里是一段**没有引擎标记**的提醒形副本,按标记声明它该当**数据**处理并报出来。所以壳从此停拼,交这一位。两条用户车道都是提交面 ⇒ 都能声明。坏词由引擎响亮拒(单成员闭集,打错字不许被折成缺席),本层同律在构造期就拒(见 `refuseBadApproverPosture`)。⚠️ 上游的**提交体**与**引擎规格**两层都真读这一键,而装着的 sdk 型面尚未镜像它 ⇒ 本层的字面按提交体的形声明,不从 sdk 取型', whyUtilityLane: '无座:审批姿态是**用户**对他自己那条会话的声明,而 side-channel 是壳自己的提交 —— 把用户的 bypass 姿态带进一条他没参与的提交,等于替他重申一句他没说过的话;况且零工具面根本产不出审批卡' },
+    { field: 'fileHistory', lanes: ['interactive', 'print'], live: true, why: '「这一次运行别捕获文件历史」的**请求级声明**(server 7.104.0 提交体键,单成员闭集 "disabled";`POST /v1/tasks` · `/v1/tasks/stream` · `/v1/runs` 同收,子代继承)。两条用户车道都是提交面、都跑在用户的文件上 ⇒ 都能声明;「本会话不捕获」= 每个提交都带(续跑腿重放同一个体)。🔴 只在能力读数 `on-optional` 时发(老 server 对表外键 400),值由片段口 `fileHistoryDeclarationField` 唯一铸出。与 rewind 还原键同交 ⇒ 上游 400 `request.field_conflict`', whyUtilityLane: '无座:side-channel 强制零工具面(`excludeAllTools`),不会改任何文件 ⇒ 没有可捕获的东西;带上它只会在不认识这一键的老 server 上给这条提交多一种 400' },
     { field: 'finalVerification', lanes: ['print'], live: true, why: 'P1-1 终验:无人值守车道才需要引擎自证;交互 REPL 由人当场看结果。#106 裁 B(让位+告知)后交互面默认关', whyUtilityLane: '无座:终验让引擎再跑一轮自证,而 side-channel 要的是一次小提交的即时答案;「无人值守才需要引擎自证」这条理由在本车道上让位给「小预算优先」' },
     { field: 'limits', lanes: ['print', 'utility'], live: true, why: 'P2-3-b:`-p` 的预算护栏(--max-* flag 族),交互 REPL 由人随时 Esc', whyUtilityLane: '有座:side-channel 必须带预算护栏(墙钟 / 输出 token / 轮数)—— 它同样没有人看着,而且没有后续回合可以中断' },
     { field: 'interactiveTools', lanes: ['print', 'utility'], live: true, why: '[909]B 件3:无人值守 stamp false,从 roster 源头灭掉 AskUserQuestion/plan 门。交互车道 stamp false 等于自废武功', whyUtilityLane: '有座:side-channel 绝不该弹交互问答 / plan 门(没有人在看这条提交)。它与 excludeAllTools 是**两条独立**的收紧声明、在这条车道上**并存**(本车道强制带卸载声明,见 `refuseUtilityWithoutToolUnload`;这一位是它旁边那条「连问都别问」的声明,不是它的降级替身)' },
@@ -125,6 +126,7 @@ const INPUT_KEY_ROUTES = {
     memoryCapture: row('memoryCapture'),
     memory: row('memory'),
     approverPosture: row('approverPosture'),
+    fileHistory: row('fileHistory'),
     rewind: row('resumeAt/resumeAtMode/restoreFiles/rewindFilesTo'),
     repo: row('repo'),
     council: row('council'),
@@ -197,6 +199,7 @@ const VALUE_LEVEL_IN_PLAY = Object.freeze({
     memoryCapture: (v) => v === 'off',
     memory: (v) => v === 'off',
     approverPosture: (v) => v === APPROVER_POSTURE_BYPASS,
+    fileHistory: (v) => v === FILE_HISTORY_DISABLED,
     rewind: (v) => typeof v === 'object' && v !== null && rewindSubKeys().some((k) => hasOwn(v, k) && present(v[k])),
 });
 const inPlay = (key, v) => present(v) && (VALUE_LEVEL_IN_PLAY[key]?.(v) ?? true);
@@ -377,6 +380,7 @@ void true;
 export function approverPostureDeclarationField(declared) {
     return declared ? { approverPosture: APPROVER_POSTURE_BYPASS } : {};
 }
+export const FILE_HISTORY_DISABLED = 'disabled';
 export function memoryOffDeclared(input) {
     if (typeof input !== 'object' || input === null)
         return false;
@@ -426,6 +430,15 @@ const refuseBadApproverPosture = (v) => {
         '**响亮拒**,刻意不把打错的词折回缺席。本层若静默删键,这一次提交的模型不会被告知姿态,而声明人不会知道。' +
         '错误文本只报形状,不回显值。');
 };
+const refuseBadFileHistory = (v) => {
+    if (v === undefined || v === null)
+        return;
+    if (v === FILE_HISTORY_DISABLED)
+        return;
+    throw new TypeError('buildTaskRequest: fileHistory 只接受字面量 `\'disabled\'` 或缺席(undefined/null)—— ' +
+        `收到 ${coarseShape(v)}。这一位是「这一次运行别捕获文件历史」的收紧声明,上游是**单成员闭集**(没有第二个词)且对坏值` +
+        '**响亮拒**。本层若静默删键,这一次运行照常捕获而声明人不会知道。错误文本只报形状,不回显值。');
+};
 const refuseBadMaxTokens = (v) => {
     if (v === undefined || v === null)
         return;
@@ -495,7 +508,7 @@ export function parseMaxCostUsd(text) {
         return { ok: false, why: 'not_positive' };
     return { ok: true, value };
 }
-const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'memory', 'settings', 'maxCostUsd', 'excludeAllTools', 'approverPosture', 'maxTokens', 'outputRetries'];
+const ACCESSOR_READ_ORDER = ['live', 'memoryCapture', 'memory', 'settings', 'maxCostUsd', 'excludeAllTools', 'approverPosture', 'maxTokens', 'outputRetries', 'fileHistory'];
 function dataFirstSnapshot(input, afterData) {
     let descs;
     try {
@@ -563,6 +576,7 @@ export function assembleTaskRequest(input, lane) {
     const approverPostureIn = src.approverPosture;
     const maxTokensIn = src.maxTokens;
     const outputRetriesIn = src.outputRetries;
+    const fileHistoryIn = src.fileHistory;
     const INPUT_KEYS = Object.keys(INPUT_KEY_ROUTES);
     const i = snapshotByName(src, INPUT_KEYS, {
         live,
@@ -573,6 +587,7 @@ export function assembleTaskRequest(input, lane) {
         excludeAllTools: excludeAllToolsIn,
         approverPosture: approverPostureIn,
         outputRetries: outputRetriesIn,
+        fileHistory: fileHistoryIn,
         settings: settingsIn,
     });
     const SETTINGS_KEYS = Object.keys(SETTINGS_KEY_ROUTES);
@@ -584,6 +599,7 @@ export function assembleTaskRequest(input, lane) {
     refuseBadApproverPosture(approverPostureIn);
     refuseBadMaxTokens(maxTokensIn);
     refuseBadOutputRetries(outputRetriesIn);
+    refuseBadFileHistory(fileHistoryIn);
     const rewindRoute = INPUT_KEY_ROUTES.rewind;
     const RETIRED_REWIND_FILES_KEY = 'rewindFiles';
     const REWIND_KEYS = rewindRoute.via === 'matrix' ? rewindRoute.field.split('/') : [];
@@ -733,6 +749,7 @@ export function assembleTaskRequest(input, lane) {
         ...(on('memoryCapture') ? { memoryCapture: 'off' } : {}),
         ...(on('memory') ? { memory: 'off' } : {}),
         ...(on('approverPosture') ? { approverPosture: APPROVER_POSTURE_BYPASS } : {}),
+        ...(on('fileHistory') ? { fileHistory: FILE_HISTORY_DISABLED } : {}),
         ...(Object.keys(settingsOut).length > 0 ? { settings: settingsOut } : {}),
     };
     return Object.freeze({ request: out, omitted: Object.freeze([...omitted, ...lateOmitted]) });

package/dist/resumeRefusalCopy.d.ts

@@ -33,3 +33,14 @@ export interface ResumeContextUnavailableDetail {
 }
 export declare function resumeContextUnavailableFromError(err: unknown): ResumeContextUnavailableDetail | null;
 export declare function resumeContextUnavailableContent(d: ResumeContextUnavailableDetail): string;
+export type ParkedResumeStartupDecision = 'approve' | 'deny';
+export type ParkedResumeStartupCause = 'resume_rejected' | 'undetermined';
+export interface ParkedResumeStartupDetail {
+    code: string;
+    cause: ParkedResumeStartupCause;
+    taskId?: string;
+    resendable: false;
+    denyStaysOpen: true;
+}
+export declare function parkedResumeStartupFromError(err: unknown, decision?: ParkedResumeStartupDecision): ParkedResumeStartupDetail | null;
+export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDetail): string;

package/dist/resumeRefusalCopy.js

@@ -1,5 +1,5 @@
 import { readErrorNumber, readErrorString } from './wireFailureShape.js';
-import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE, RESUME_POLICY_FOLD_CODE, } from './engineErrorCodes.js';
+import { RESUME_CONTEXT_UNAVAILABLE, RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, RESUME_REOPEN_CODES, RESUME_ENV_FAILED, RESUME_TOOL_UNAVAILABLE, RESUME_POLICY_FOLD_CODE, PARKED_RESUME_STARTUP_FAILED, isStatusDerivedCoarseCode, } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
 export const RESUME_REFUSAL_CODES = Object.freeze([
@@ -73,7 +73,9 @@ export function resumePolicyBlockFromError(err) {
 export function resumePolicyBlockContent(detail) {
     const b = detail.blockedBy;
     const reason = b.kind === 'named'
-        ? `The check that refused it: ${capForDisplay(b.code, 80)}`
+        ? isStatusDerivedCoarseCode(b.code)
+            ? `The refusal did not name a more specific check (it carried only the generic code for its HTTP status: ${b.code})`
+            : `The check that refused it: ${capForDisplay(b.code, 80)}`
         : b.kind === 'absent'
             ? 'The refusal did not name a more specific check'
             : 'The refusal carried a more specific reason that could not be read';
@@ -134,3 +136,41 @@ export function resumeContextUnavailableContent(d) {
         third,
     ].join(' · ');
 }
+export function parkedResumeStartupFromError(err, decision) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    let code;
+    try {
+        code = err.errorCode;
+    }
+    catch {
+        return null;
+    }
+    if (code !== PARKED_RESUME_STARTUP_FAILED)
+        return null;
+    const rawTaskId = readErrorString(err, 'taskId');
+    const taskId = rawTaskId !== undefined && rawTaskId.length > 0 ? rawTaskId : undefined;
+    return {
+        code: PARKED_RESUME_STARTUP_FAILED,
+        cause: decision === 'deny' ? 'resume_rejected' : 'undetermined',
+        ...(taskId !== undefined ? { taskId } : {}),
+        resendable: false,
+        denyStaysOpen: true,
+    };
+}
+const PARKED_RESUME_STARTUP_STATE = 'This refusal does not say whether the card is still waiting — re-fetch the pending approvals';
+const PARKED_RESUME_STARTUP_SENTENCES = Object.freeze({
+    resume_rejected: [
+        'The engine could not start the parked work to apply this decision (its session may be gone, or the engine rejected the decision itself)',
+        PARKED_RESUME_STARTUP_STATE,
+        'If the card is still there, decide it again from the fresh list',
+    ].join(' · '),
+    undetermined: [
+        'The engine could not start the parked work to apply this decision',
+        PARKED_RESUME_STARTUP_STATE,
+        'If the card is still there: when the engine rejected the decision itself (for example an answer given to the wrong question), correct it and decide again; when the approved tool is one the agent inherits from the task that started it, approving it again will not work on this server — deny the card, or wait for a server upgrade',
+    ].join(' · '),
+});
+export function parkedResumeStartupContent(detail) {
+    return detail.cause === 'resume_rejected' ? PARKED_RESUME_STARTUP_SENTENCES.resume_rejected : PARKED_RESUME_STARTUP_SENTENCES.undetermined;
+}

package/dist/runTerminal.js

@@ -32,6 +32,10 @@ export function readRunTerminal(result) {
         const kind = str(c.kind);
         if (kind === undefined)
             return { kind: 'unknown', plane: 'cause' };
+        const parkWord = str(r.status);
+        if (parkWord !== undefined && FLAT_PAUSED_STATUSES.includes(parkWord)) {
+            return { kind: 'paused', plane: 'cause', flatStatus: parkWord, ...(kind === 'paused' ? (pauseOf(c) ?? {}) : {}) };
+        }
         switch (kind) {
             case 'completed':
                 return { kind: 'completed', plane: 'cause' };

package/dist/sandboxWire.js

@@ -55,7 +55,7 @@ export function sandboxDegradeHint(err) {
             'Re-run without --sandbox (worker default image), or point the shell at a k8s-lane worker (sema cloud engine connect <url>).');
     }
     if (e.status === 400 && msg.includes(SANDBOX_NO_IMAGE_INDEX_400_ANCHOR)) {
-        return ('This worker has no sandbox image index configured (sema-registry backend absent), so per-task profiles cannot resolve.\n' +
+        return ('This worker has no sandbox image index configured (the sema-web-admin config center is not attached), so per-task profiles cannot resolve.\n' +
             'Re-run without --sandbox, or use a worker with the image index enabled.');
     }
     if (e.status === 404 && msg.includes(SANDBOX_NO_PUBLISHED_IMAGE_404_ANCHOR)) {

package/dist/sealedKeyCapability.d.ts

@@ -0,0 +1,17 @@
+export type SealedKeyReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'present';
+    alg: string;
+    publicKeyId: string;
+    publicKey: string;
+};
+export declare function projectSealedKeyCapability(caps: unknown): SealedKeyReading | undefined;
+export declare function noteEngineCapsForSealedKey(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedSealedKey(baseUrl?: string | undefined): SealedKeyReading;
+export declare function forgetSealedKeyReading(baseUrl: string | undefined): void;
+export declare function __resetSealedKeyReadingsForTests(): void;

package/dist/sealedKeyCapability.js

@@ -0,0 +1,42 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+function ownNonEmpty(seg, key) {
+    if (!Object.hasOwn(seg, key))
+        return undefined;
+    const v = seg[key];
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+export function projectSealedKeyCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'sealedKey'))
+        return { kind: 'not_reported' };
+    const seg = caps.sealedKey;
+    if (seg === undefined)
+        return { kind: 'not_reported' };
+    if (seg === null || typeof seg !== 'object' || Array.isArray(seg))
+        return undefined;
+    const alg = ownNonEmpty(seg, 'alg');
+    const publicKeyId = ownNonEmpty(seg, 'publicKeyId');
+    const publicKey = ownNonEmpty(seg, 'publicKey');
+    if (alg === undefined || publicKeyId === undefined || publicKey === undefined)
+        return undefined;
+    return { kind: 'present', alg, publicKeyId, publicKey };
+}
+const reader = createEngineCapReader({
+    name: 'sealedKey',
+    project: projectSealedKeyCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForSealedKey(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedSealedKey(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function forgetSealedKeyReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetSealedKeyReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/seatContract.d.ts

@@ -1,4 +1,5 @@
 import type { ReasoningEffort } from "./effortWire.js";
+import type { PermissionMode } from "./permissionWireCaps.js";
 import type { LaneProof } from "./seam.js";
 import type { QuestionAnswer } from "./liveQuestionStore.js";
 import type { ToolApprovalDelegation } from "./hitl/toolApprovalWire.js";
@@ -101,7 +102,7 @@ export interface StartSessionOptions {
     cwd?: string;
     excludeTools?: string[];
 }
-export type PermissionModeIntent = "default" | "plan" | "acceptEdits" | "bypassPermissions" | "auto";
+export type PermissionModeIntent = PermissionMode;
 export declare const PERMISSION_MODE_INTENTS: readonly PermissionModeIntent[];
 export declare const ATTACHMENT_IDS_PER_TASK_CAP = 16;
 export declare const SEAT_REASONING_EFFORTS: readonly ReasoningEffort[];

package/dist/seatContract.js

@@ -1,3 +1,4 @@
+import { PERMISSION_MODE_WORDS, REASONING_EFFORT_WORDS } from "./taskRequestWords.js";
 const bad = (reason, field) => field === undefined ? { reason } : { reason, field };
 const nested = (prefix, verdict) => {
     const path = verdict.field === undefined
@@ -71,25 +72,9 @@ export const HITL_RESOLUTION_OUTCOMES = [
     "decline",
     "cancel",
 ];
-const PERMISSION_MODE_INTENT_TUPLE = [
-    "default",
-    "plan",
-    "acceptEdits",
-    "bypassPermissions",
-    "auto",
-];
-export const PERMISSION_MODE_INTENTS = PERMISSION_MODE_INTENT_TUPLE;
+export const PERMISSION_MODE_INTENTS = [...PERMISSION_MODE_WORDS];
 export const ATTACHMENT_IDS_PER_TASK_CAP = 16;
-const SEAT_REASONING_EFFORT_TUPLE = [
-    "off",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max",
-];
-export const SEAT_REASONING_EFFORTS = SEAT_REASONING_EFFORT_TUPLE;
+export const SEAT_REASONING_EFFORTS = [...REASONING_EFFORT_WORDS];
 export const SEAT_TURN_SETTINGS_KEYS = ["ultracode"];
 export const ATTACHMENT_UPLOAD_REQUEST_KEYS = ["name", "mimeType", "bytes"];
 export const SESSION_SEARCH_RESULT_KEYS = ["sessionId", "title", "matches"];
@@ -224,8 +209,8 @@ const checkLocalSessionEvent = (v) => {
     }
     if (!isAbsent(v.permissionMode)) {
         const mode = v.permissionMode;
-        if (typeof mode !== "string" || !inTuple(PERMISSION_MODE_INTENT_TUPLE, mode)) {
-            return bad(`permissionMode must be one of ${PERMISSION_MODE_INTENT_TUPLE.join("|")}`, "permissionMode");
+        if (typeof mode !== "string" || !inTuple(PERMISSION_MODE_INTENTS, mode)) {
+            return bad(`permissionMode must be one of ${PERMISSION_MODE_INTENTS.join("|")}`, "permissionMode");
         }
     }
     if (!isAbsent(v.session)) {
@@ -718,7 +703,6 @@ const _seatContractPins = [
     true, true,
     true, true,
     true, true, true, true,
-    true, true, true, true,
     true, true,
     true, true,
     true, true,

package/dist/subagent/engineCompactWire.d.ts

@@ -1,5 +1,16 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type EngineCompactWireClient = {
+    capabilities: AgentClient['capabilities'];
+    runs: Pick<AgentClient['runs'], 'compact'>;
+};
+export type EngineCompactWire = EngineWireInjection<EngineCompactWireClient>;
 export declare function isEngineCompactPending(sessionKey?: string): boolean;
 export declare function resetManualCompactCapability(): void;
 export declare function __resetEngineCompactArmForTests(): void;
-export declare function requestEngineCompact(sessionKey?: string): 'fired' | 'armed' | 'offline' | 'unsupported';
-export declare function onEngineTaskBound(taskId: string, sessionKey?: string): void;
+export declare function requestEngineCompact(sessionKey?: string, opts?: {
+    wire?: EngineCompactWire;
+}): 'fired' | 'armed' | 'offline' | 'unsupported';
+export declare function onEngineTaskBound(taskId: string, sessionKey?: string, opts?: {
+    wire?: EngineCompactWire;
+}): void;

package/dist/subagent/engineCompactWire.js

@@ -1,34 +1,38 @@
 import { hostLog, hostTimersFor } from '../host.js';
-import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTargetFor } from '../engineWireTarget.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected, } from '../engineWireFor.js';
 import { activeEngineRunIdFor, engineSessionParamFor } from '../engineSessionParam.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
+function usableCompactClient(client) {
+    return clientHasVerbs(client, [['capabilities'], ['runs', 'compact']]);
+}
+const COMPACT_PROBE_SETTLE_MS = 5000;
 const pendingCompactKeys = new Set();
 export function isEngineCompactPending(sessionKey = DEFAULT_SESSION_KEY) {
     return pendingCompactKeys.has(sessionKey);
 }
 const manualCompactCapableByBase = new Map();
 const capabilitiesProbeByBase = new Map();
-function probeManualCompactCapability(sessionKey = DEFAULT_SESSION_KEY) {
-    const cfg = engineWireTargetFor(sessionKey);
-    if (!cfg)
+function probeManualCompactCapability(wire) {
+    const base = wire.kind === 'injected' ? wire.capsBaseUrl : wire.target.baseUrl;
+    if (base === undefined)
         return;
-    const base = cfg.baseUrl;
     if (capabilitiesProbeByBase.has(base))
         return;
     capabilitiesProbeByBase.set(base, (async () => {
         try {
-            const client = makeEngineWireClient({
-                baseUrl: base,
-                ...(cfg.token ? { token: cfg.token } : {}),
-                principal: cfg.principal,
-                timeoutMs: 5000,
-            });
-            if (!client) {
-                capabilitiesProbeByBase.delete(base);
-                return;
+            let caps;
+            if (wire.kind === 'injected') {
+                const injected = wire.client;
+                caps = await settleInjected(COMPACT_PROBE_SETTLE_MS, undefined, (signal) => injected.capabilities({ signal }));
+            }
+            else {
+                const client = wire.make({ timeoutMs: 5000 });
+                if (!client) {
+                    capabilitiesProbeByBase.delete(base);
+                    return;
+                }
+                caps = await client.capabilities();
             }
-            const caps = await client.capabilities();
             if (typeof caps.manualCompact === 'boolean')
                 manualCompactCapableByBase.set(base, caps.manualCompact);
             else
@@ -55,31 +59,35 @@ function deferFire(ms, fn, why, sessionKey) {
     timers.setTimer(ms, fn);
     return true;
 }
-function freezeCompactShot(taskId, sessionKey) {
-    const cfg = engineWireTargetFor(sessionKey);
-    if (!cfg)
+function freezeCompactShot(taskId, sessionKey, wire) {
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return null;
     const sid = engineSessionParamFor(sessionKey);
+    let client;
+    if (wire.kind === 'injected') {
+        const injected = wire.client;
+        client = () => injected;
+    }
+    else {
+        const make = wire.make;
+        client = () => make();
+    }
     return {
         taskId,
         sessionKey,
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token !== undefined ? { token: cfg.token } : {}),
-        ...(cfg.principal !== undefined ? { principal: cfg.principal } : {}),
+        client,
+        injected: wire.kind === 'injected',
         ...(sid !== undefined ? { session: sid } : {}),
     };
 }
 async function postCompact(shot, retriesLeft = 1) {
-    const client = makeEngineWireClient({
-        baseUrl: shot.baseUrl,
-        ...(shot.token ? { token: shot.token } : {}),
-        principal: shot.principal,
-    });
+    const client = shot.client();
     if (!client)
         return;
     const taskId = shot.taskId;
     try {
-        const ack = await client.runs.compact(taskId, shot.session !== undefined ? { session: shot.session } : {});
+        const fire = (signal) => client.runs.compact(taskId, { ...(shot.session !== undefined ? { session: shot.session } : {}), ...(signal ? { signal } : {}) });
+        const ack = shot.injected ? await settleInjected(INJECTED_WIRE_SETTLE_MS, undefined, fire) : await fire(undefined);
         hostLog('debug', `engineCompactWire: POST compact ${taskId} → ok${ack?.status ? ` (${ack.status})` : ''}`);
     }
     catch (e) {
@@ -94,18 +102,19 @@ async function postCompact(shot, retriesLeft = 1) {
         hostLog('debug', `engineCompactWire: compact fire failed (best-effort): ${String(e)}`);
     }
 }
-export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY) {
-    const cfg = engineWireTargetFor(sessionKey);
-    if (!cfg)
+export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY, opts) {
+    const wire = engineWireFor(opts?.wire, sessionKey, usableCompactClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return 'offline';
-    probeManualCompactCapability(sessionKey);
-    if (manualCompactCapableByBase.get(cfg.baseUrl) === false) {
+    probeManualCompactCapability(wire);
+    const capsKey = wire.kind === 'injected' ? wire.capsBaseUrl : wire.target.baseUrl;
+    if (capsKey !== undefined && manualCompactCapableByBase.get(capsKey) === false) {
         hostLog('debug', 'engineCompactWire: engine capabilities report manualCompact:false — verb suppressed (TOC-local runStore-less engine, [488])');
         return 'unsupported';
     }
     const taskId = activeEngineRunIdFor(sessionKey);
     if (taskId) {
-        const shot = freezeCompactShot(taskId, sessionKey);
+        const shot = freezeCompactShot(taskId, sessionKey, wire);
         if (shot !== null)
             void postCompact(shot);
         return 'fired';
@@ -114,11 +123,13 @@ export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY) {
     return 'armed';
 }
 const BOUND_FIRE_DELAY_MS = 1500;
-export function onEngineTaskBound(taskId, sessionKey = DEFAULT_SESSION_KEY) {
-    probeManualCompactCapability(sessionKey);
+export function onEngineTaskBound(taskId, sessionKey = DEFAULT_SESSION_KEY, opts) {
+    const wire = engineWireFor(opts?.wire, sessionKey, usableCompactClient);
+    if (wire.kind !== 'no-target' && wire.kind !== 'injected-unusable')
+        probeManualCompactCapability(wire);
     if (!pendingCompactKeys.has(sessionKey))
         return;
-    const shot = freezeCompactShot(taskId, sessionKey);
+    const shot = freezeCompactShot(taskId, sessionKey, wire);
     if (shot === null)
         return;
     if (deferFire(BOUND_FIRE_DELAY_MS, () => void postCompact(shot), 'bind 后发射', sessionKey)) {

package/dist/subagent/engineDelegatedPrompt.d.ts

@@ -1,3 +1,9 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type DelegatedPromptWireClient = {
+    sessions: Pick<AgentClient['sessions'], 'get'>;
+};
+export type DelegatedPromptWire = EngineWireInjection<DelegatedPromptWireClient>;
 export declare function recordEngineTranscriptId(taskId: string, transcriptId: string): void;
 export declare function getEngineTranscriptId(taskId: string): string | undefined;
 export declare function __resetEngineDelegatedPromptForTests(): void;
@@ -9,5 +15,7 @@ export interface DelegatedPromptFetch {
     prompt?: string;
     outcome: 'hit' | 'skipped' | 'unreadable' | 'absent';
 }
-export declare function fetchDelegatedPrompt(taskId: string): Promise<DelegatedPromptFetch>;
+export declare function fetchDelegatedPrompt(taskId: string, opts?: {
+    wire?: DelegatedPromptWire;
+}): Promise<DelegatedPromptFetch>;
 export {};

package/dist/subagent/engineDelegatedPrompt.js

@@ -1,8 +1,10 @@
 import { stripSystemReminderBlocks } from '../systemReminderTag.js';
 import { hostLog } from '../host.js';
-import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTargetFor } from '../engineWireTarget.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected } from '../engineWireFor.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
+function usableDelegatedPromptClient(client) {
+    return clientHasVerbs(client, [['sessions', 'get']]);
+}
 const TAIL_WINDOW = 200;
 const BLOB_CAP = 8 * 1024;
 const transcriptIdByTask = new Map();
@@ -89,27 +91,25 @@ let transcriptWindowReader = null;
 export function __setTranscriptWindowReaderForTests(r) {
     transcriptWindowReader = r;
 }
-async function readTranscriptWindow(transcriptId, sessionKey) {
+async function readTranscriptWindow(transcriptId, sessionKey, injectedWire) {
     if (transcriptWindowReader)
         return transcriptWindowReader(transcriptId);
-    const cfg = engineWireTargetFor(sessionKey);
-    if (!cfg)
+    const wire = engineWireFor(injectedWire, sessionKey, usableDelegatedPromptClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return null;
-    const client = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        principal: cfg.principal,
-    });
+    const client = wire.kind === 'injected' ? wire.client : wire.make();
     if (!client)
         return null;
-    const rec = await client.sessions.get(transcriptId, {
-        tail: TAIL_WINDOW,
-        blobCap: BLOB_CAP,
-    });
+    const rec = wire.kind === 'injected'
+        ? await settleInjected(INJECTED_WIRE_SETTLE_MS, undefined, (signal) => client.sessions.get(transcriptId, { tail: TAIL_WINDOW, blobCap: BLOB_CAP, signal }))
+        : await client.sessions.get(transcriptId, {
+            tail: TAIL_WINDOW,
+            blobCap: BLOB_CAP,
+        });
     const msgs = rec.messages;
     return Array.isArray(msgs) ? msgs : null;
 }
-export async function fetchDelegatedPrompt(taskId) {
+export async function fetchDelegatedPrompt(taskId, opts) {
     if (promptHydrateInFlight.has(taskId))
         return { outcome: 'skipped' };
     const transcriptId = transcriptIdByTask.get(taskId);
@@ -118,7 +118,7 @@ export async function fetchDelegatedPrompt(taskId) {
     promptHydrateInFlight.add(taskId);
     let msgs = null;
     try {
-        msgs = await readTranscriptWindow(transcriptId, resolveOwnerContext(taskId).key);
+        msgs = await readTranscriptWindow(transcriptId, resolveOwnerContext(taskId).key, opts?.wire);
     }
     catch (e) {
         promptHydrateInFlight.delete(taskId);

package/dist/subagent/engineRowStopGate.d.ts

@@ -1,5 +1,5 @@
 export declare const engineOwnedRowIds: Set<string>;
 export declare const fleetViewStubRowIds: Set<string>;
 export declare function isEngineViewRow(taskId: string): boolean;
-export declare function engineTaskHandlesCapable(sessionKey?: string): boolean;
-export declare function engineRowNeedsStopConfirm(taskId: string, sessionKey?: string): boolean;
+export declare function engineTaskHandlesCapable(sessionKey?: string, capsBaseUrl?: string): boolean;
+export declare function engineRowNeedsStopConfirm(taskId: string, sessionKey?: string, capsBaseUrl?: string): boolean;

package/dist/subagent/engineRowStopGate.js

@@ -6,9 +6,9 @@ export const fleetViewStubRowIds = new Set();
 export function isEngineViewRow(taskId) {
     return engineOwnedRowIds.has(taskId) || fleetViewStubRowIds.has(taskId);
 }
-export function engineTaskHandlesCapable(sessionKey = DEFAULT_SESSION_KEY) {
-    return engineCapTrue(engineWireTargetFor(sessionKey)?.baseUrl, 'taskHandles');
+export function engineTaskHandlesCapable(sessionKey = DEFAULT_SESSION_KEY, capsBaseUrl) {
+    return engineCapTrue(capsBaseUrl ?? engineWireTargetFor(sessionKey)?.baseUrl, 'taskHandles');
 }
-export function engineRowNeedsStopConfirm(taskId, sessionKey) {
-    return isEngineViewRow(taskId) && engineTaskHandlesCapable(sessionKey ?? DEFAULT_SESSION_KEY);
+export function engineRowNeedsStopConfirm(taskId, sessionKey, capsBaseUrl) {
+    return isEngineViewRow(taskId) && engineTaskHandlesCapable(sessionKey ?? DEFAULT_SESSION_KEY, capsBaseUrl);
 }

package/dist/subagent/engineSubagentOutput.d.ts

@@ -1,3 +1,10 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type SubagentReportWireClient = {
+    capabilities: AgentClient['capabilities'];
+    runs: Pick<AgentClient['runs'], 'subagentOutput'>;
+};
+export type SubagentReportWire = EngineWireInjection<SubagentReportWireClient>;
 export declare function __resetSubagentOutputCapCacheForTests(): void;
 export interface EngineSubagentReport {
     content: string;
@@ -5,4 +12,5 @@ export interface EngineSubagentReport {
 }
 export declare function fetchEngineSubagentReport(taskId: string, opts?: {
     signal?: AbortSignal;
+    wire?: SubagentReportWire;
 }): Promise<EngineSubagentReport | null>;