@sema-agent/client-core 0.84.0 → 0.85.0

package/dist/subagent/engineSubagentOutput.js

@@ -1,19 +1,24 @@
 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 { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
+function usableReportClient(client) {
+    return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentOutput']]);
+}
 const capByBase = new Map();
 const CAP_FALSE_RETRY_TTL_MS = 5 * 60_000;
-async function subagentOutputCapable(client, baseUrl, signal) {
-    const hit = capByBase.get(baseUrl);
+async function subagentOutputCapable(client, cacheKey, signal, deadlineMs) {
+    const hit = cacheKey !== undefined ? capByBase.get(cacheKey) : undefined;
     if (hit && (hit.ok || Date.now() - hit.at < CAP_FALSE_RETRY_TTL_MS))
         return hit.ok;
     try {
-        const caps = await client.capabilities({ ...(signal ? { signal } : {}) });
+        const caps = deadlineMs !== undefined
+            ? await settleInjected(deadlineMs, signal, (s) => client.capabilities({ signal: s }))
+            : await client.capabilities({ ...(signal ? { signal } : {}) });
         const ok = caps.subagentOutput === true;
-        capByBase.set(baseUrl, { ok, at: Date.now() });
+        if (cacheKey !== undefined)
+            capByBase.set(cacheKey, { ok, at: Date.now() });
         return ok;
     }
     catch {
@@ -25,28 +30,42 @@ export function __resetSubagentOutputCapCacheForTests() {
 }
 export async function fetchEngineSubagentReport(taskId, opts) {
     const { record: owner, runId, key } = resolveOwnerContext(taskId);
-    const cfg = engineWireTargetFor(key);
-    if (!cfg)
+    const wire = engineWireFor(opts?.wire, key, usableReportClient);
+    if (wire.kind === 'no-target')
+        return null;
+    if (wire.kind === 'injected-unusable') {
+        hostLog('debug', `[subagent-output] ${taskId}: the engine client supplied by the host is not usable (needs capabilities and runs.subagentOutput) — nothing sent`);
         return null;
+    }
     if (!runId) {
         noteBgOwnerAbsence('subagent-output', taskId);
         return null;
     }
-    const client = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        principal: cfg.principal,
-    });
-    if (!client)
-        return null;
-    if (!(await subagentOutputCapable(client, cfg.baseUrl, opts?.signal)))
+    let client;
+    let cacheKey;
+    let injected;
+    if (wire.kind === 'injected') {
+        client = wire.client;
+        cacheKey = wire.capsBaseUrl;
+        injected = true;
+    }
+    else {
+        const made = wire.make();
+        if (!made)
+            return null;
+        client = made;
+        cacheKey = wire.target.baseUrl;
+        injected = false;
+    }
+    if (!(await subagentOutputCapable(client, cacheKey, opts?.signal, injected ? INJECTED_WIRE_SETTLE_MS : undefined)))
         return null;
     try {
         const session = owner?.sessionId ?? engineSessionParamFor(key);
-        const r = await client.runs.subagentOutput(runId, taskId, {
-            ...(opts?.signal ? { signal: opts.signal } : {}),
+        const read = (signal) => client.runs.subagentOutput(runId, taskId, {
+            ...(signal ? { signal } : {}),
             ...(session ? { session } : {}),
         });
+        const r = injected ? await settleInjected(INJECTED_WIRE_SETTLE_MS, opts?.signal, read) : await read(opts?.signal);
         const content = typeof r?.content === 'string' ? r.content : '';
         if (!content.trim())
             return null;

package/dist/subagent/engineSubagentResume.d.ts

@@ -1,4 +1,5 @@
-import type { SubagentSteerReceipt } from '@sema-agent/sdk';
+import type { AgentClient, SubagentSteerReceipt } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
 import { type SubagentOwnerRecord } from '../subagentContentStore.js';
 export declare const SUBAGENT_RESUME_CAP = "subagentResume";
 export declare function subagentResumeAvailable(baseUrl?: string, sessionKey?: string): boolean;
@@ -21,12 +22,14 @@ export type SubagentResumeOutcome = {
     detail: string;
     retryAfterSec?: number;
     code?: string;
+    unconfirmed?: true;
 };
 export interface SubagentResumeFailureVerdict {
     reason: SubagentResumeFailureKind;
     detail: string;
     retryAfterSec?: number;
     code?: string;
+    unconfirmed?: true;
 }
 export declare function classifySubagentResumeFailure(e: unknown): SubagentResumeFailureVerdict;
 export declare function resolveOwnerRunId(childTaskId?: string, activeRunId?: string | undefined): string | undefined;
@@ -41,7 +44,13 @@ export interface SubagentResumeContext {
     runId: string | undefined;
     session: Record<string, string>;
 }
-export declare function resolveSubagentResumeContext(childTaskId?: string): SubagentResumeContext;
+export type SubagentResumeWireClient = {
+    runs: Pick<AgentClient['runs'], 'resumeSubagent'>;
+};
+export type SubagentResumeWire = EngineWireInjection<SubagentResumeWireClient>;
+export declare function resolveSubagentResumeContext(childTaskId?: string, opts?: {
+    wire?: SubagentResumeWire;
+}): SubagentResumeContext;
 export declare function resumeSettledSubagent(facade: SubagentResumeFacade | null, runId: string | undefined, target: string, content: string, opts?: {
     session?: string;
     signal?: AbortSignal;

package/dist/subagent/engineSubagentResume.js

@@ -2,7 +2,7 @@ import { hostLog } from '../host.js';
 import { resumeRetryLaterFromError } from '../wireErrorTriage.js';
 import { displayUntrusted } from '../displayUntrusted.js';
 import { engineCapTrue } from '../engineCapsCache.js';
-import { makeEngineWireClient } from '../engineWireSdk.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
 import { engineWireTargetFor } from '../engineWireTarget.js';
 import { activeEngineRunId, engineSessionParamFor } from '../engineSessionParam.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
@@ -33,6 +33,11 @@ function shapeOf(e) {
 }
 export function classifySubagentResumeFailure(e) {
     const { status, errorCode, message } = shapeOf(e);
+    if (status === undefined && errorCode === undefined) {
+        const noAnswer = typeof e === 'object' ? noAnswerDetailFrom(e) : null;
+        if (noAnswer !== null)
+            return { reason: 'error', detail: noAnswer, unconfirmed: true };
+    }
     const retryLater = resumeRetryLaterFromError(e);
     if (retryLater !== null) {
         return {
@@ -77,18 +82,27 @@ export function resolveOwnerContext(childTaskId) {
     const record = getBgParentRunOwner(childTaskId);
     return { record, runId: record?.runId, key: record?.sessionKey ?? DEFAULT_SESSION_KEY };
 }
-export function resolveSubagentResumeContext(childTaskId) {
+function usableResumeClient(client) {
+    return clientHasVerbs(client, [['runs', 'resumeSubagent']]);
+}
+export function resolveSubagentResumeContext(childTaskId, opts) {
     const { record: owner, key } = resolveOwnerContext(childTaskId);
-    const cfg = engineWireTargetFor(key);
-    if (!cfg)
-        return { facade: null, runId: undefined, session: {} };
-    const client = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        ...(cfg.principal !== undefined ? { principal: cfg.principal } : {}),
-    });
-    if (!client)
+    const wire = engineWireFor(opts?.wire, key, usableResumeClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return { facade: null, runId: undefined, session: {} };
+    let facade;
+    if (wire.kind === 'injected') {
+        const injected = wire.client;
+        facade = {
+            resumeSubagent: (taskId, target, message, o) => settleInjected(INJECTED_WIRE_SETTLE_MS, o?.signal, (signal) => injected.runs.resumeSubagent(taskId, target, message, { ...(o?.session !== undefined ? { session: o.session } : {}), signal })),
+        };
+    }
+    else {
+        const client = wire.make();
+        if (!client)
+            return { facade: null, runId: undefined, session: {} };
+        facade = client.runs;
+    }
     const named = childTaskId !== undefined && childTaskId !== '';
     const sessionFromRow = owner?.sessionId;
     const fallback = named ? undefined : engineSessionParamFor(key);
@@ -97,7 +111,7 @@ export function resolveSubagentResumeContext(childTaskId) {
         : fallback !== undefined
             ? { session: fallback }
             : {};
-    return { facade: client.runs, runId: resolveOwnerRunId(childTaskId), session };
+    return { facade, runId: resolveOwnerRunId(childTaskId), session };
 }
 function clean(v, max = 200) {
     return displayUntrusted(String(v ?? ''), { credentialUrls: false, credentialWords: false, foldLines: false, mark: 'dot', max });
@@ -111,7 +125,7 @@ export async function resumeSettledSubagent(facade, runId, target, content, opts
     if (text === '')
         return { ok: false, reason: 'bad-request', detail: 'empty message' };
     try {
-        const receipt = await facade.resumeSubagent(runId, target, { content: text }, opts);
+        const receipt = await sendOnce(opts?.signal, () => facade.resumeSubagent(runId, target, { content: text }, opts));
         const note = receipt?.note;
         return {
             ok: true,
@@ -122,7 +136,7 @@ export async function resumeSettledSubagent(facade, runId, target, content, opts
     }
     catch (e) {
         const f = classifySubagentResumeFailure(e);
-        hostLog('debug', `engineSubagentResume: resume(${clean(target, 64)}) → ${f.reason} (${clean(f.detail, 160)})`);
+        hostLog('debug', `engineSubagentResume: resume(${clean(target, 64)}) → ${f.reason}${f.unconfirmed === true ? ' (may have been received, no answer)' : ''} (${clean(f.detail, 160)})`);
         return { ok: false, ...f };
     }
 }

package/dist/subagent/engineSubagentSteer.d.ts

@@ -1,3 +1,9 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type SubagentSteerWireClient = {
+    runs: Pick<AgentClient['runs'], 'steerSubagent'>;
+};
+export type SubagentSteerWire = EngineWireInjection<SubagentSteerWireClient>;
 export type SubagentSteerOutcome = {
     ok: true;
     receipt: string;
@@ -5,5 +11,8 @@ export type SubagentSteerOutcome = {
     ok: false;
     reason: 'no-wire' | 'no-run' | 'not-running' | 'error';
     detail?: string;
+    unconfirmed?: true;
 };
-export declare function steerEngineSubagent(target: string, text: string, childTaskId?: string): Promise<SubagentSteerOutcome>;
+export declare function steerEngineSubagent(target: string, text: string, childTaskId?: string, opts?: {
+    wire?: SubagentSteerWire;
+}): Promise<SubagentSteerOutcome>;

package/dist/subagent/engineSubagentSteer.js

@@ -1,14 +1,16 @@
 import { hostLog } from '../host.js';
-import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireTargetFor } from '../engineWireTarget.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, settleInjected } from '../engineWireFor.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext, resolveOwnerRunId } from './engineSubagentResume.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
-export async function steerEngineSubagent(target, text, childTaskId) {
+function usableSteerClient(client) {
+    return clientHasVerbs(client, [['runs', 'steerSubagent']]);
+}
+export async function steerEngineSubagent(target, text, childTaskId, opts) {
     const named = typeof childTaskId === 'string' && childTaskId !== '' ? childTaskId : undefined;
     const { record: owner, key } = resolveOwnerContext(named);
-    const cfg = engineWireTargetFor(key);
-    if (!cfg)
+    const wire = engineWireFor(opts?.wire, key, usableSteerClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
         return { ok: false, reason: 'no-wire' };
     const runId = resolveOwnerRunId(named);
     if (!runId) {
@@ -16,11 +18,7 @@ export async function steerEngineSubagent(target, text, childTaskId) {
             noteBgOwnerAbsence('subagent-steer', named);
         return { ok: false, reason: 'no-run' };
     }
-    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 { ok: false, reason: 'no-wire' };
     const rowSession = owner?.sessionId;
@@ -31,7 +29,9 @@ export async function steerEngineSubagent(target, text, childTaskId) {
             ? { session: fallbackSession }
             : {};
     try {
-        const body = await client.runs.steerSubagent(runId, target, { content: text }, session);
+        const body = wire.kind === 'injected'
+            ? await settleInjected(INJECTED_WIRE_SETTLE_MS, undefined, (signal) => client.runs.steerSubagent(runId, target, { content: text }, { ...session, signal }))
+            : await client.runs.steerSubagent(runId, target, { content: text }, session);
         let receipt = 'Message queued for delivery at the next tool round.';
         const copy = body?.note ?? body?.message;
         if (typeof copy === 'string' && copy.length > 0)
@@ -48,6 +48,11 @@ export async function steerEngineSubagent(target, text, childTaskId) {
             }
             return { ok: false, reason: 'error', detail: `${status}` };
         }
+        const noAnswer = typeof e === 'object' ? noAnswerDetailFrom(e) : null;
+        if (noAnswer !== null) {
+            hostLog('debug', `engineSubagentSteer: may have been received, no answer — ${noAnswer}`);
+            return { ok: false, reason: 'error', detail: noAnswer, unconfirmed: true };
+        }
         hostLog('debug', `engineSubagentSteer: fetch failed ${String(e)}`);
         return { ok: false, reason: 'error', detail: String(e) };
     }

package/dist/subagent/engineSubagentTail.d.ts

@@ -1,3 +1,10 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type SubagentTailWireClient = {
+    capabilities: AgentClient['capabilities'];
+    runs: Pick<AgentClient['runs'], 'subagentStream'>;
+};
+export type SubagentTailWire = EngineWireInjection<SubagentTailWireClient>;
 export declare function __resetSubagentStreamCapCacheForTests(): void;
 export interface SubagentActivity {
     taskId: string;
@@ -14,7 +21,9 @@ export interface SubagentTailMeta {
 export type SubagentTailMetaSink = (m: SubagentTailMeta) => void;
 export declare function installSubagentTailMetaSink(sink: SubagentTailMetaSink | null): () => void;
 export declare function isEngineSubagentTailActive(taskId: string): boolean;
-export declare function tailEngineSubagent(taskId: string): void;
+export declare function tailEngineSubagent(taskId: string, opts?: {
+    wire?: SubagentTailWire;
+}): void;
 export declare function stopEngineSubagentTail(taskId: string): void;
 export declare function hasActiveSubagentTail(taskId: string): boolean;
 export declare function __activeTailCountForTests(): number;

package/dist/subagent/engineSubagentTail.js

@@ -1,20 +1,25 @@
 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 { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { coerceOutput, parentToolCallIdOf, publishSubagentContentEvent, settleSubagentContent, } from '../subagentContentStore.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
+function usableTailClient(client) {
+    return clientHasVerbs(client, [['capabilities'], ['runs', 'subagentStream']]);
+}
 const capByBase = new Map();
 const CAP_FALSE_RETRY_TTL_MS = 5 * 60_000;
-async function subagentStreamCapable(client, baseUrl, signal) {
-    const hit = capByBase.get(baseUrl);
+async function subagentStreamCapable(client, cacheKey, signal, deadlineMs) {
+    const hit = cacheKey !== undefined ? capByBase.get(cacheKey) : undefined;
     if (hit && (hit.ok || Date.now() - hit.at < CAP_FALSE_RETRY_TTL_MS))
         return hit.ok;
     try {
-        const caps = await client.capabilities({ ...(signal ? { signal } : {}) });
+        const caps = deadlineMs !== undefined
+            ? await settleInjected(deadlineMs, signal, (s) => client.capabilities({ signal: s }))
+            : await client.capabilities({ ...(signal ? { signal } : {}) });
         const ok = caps.subagentStream === true;
-        capByBase.set(baseUrl, { ok, at: Date.now() });
+        if (cacheKey !== undefined)
+            capByBase.set(cacheKey, { ok, at: Date.now() });
         return ok;
     }
     catch {
@@ -44,24 +49,37 @@ export function installSubagentTailMetaSink(sink) {
 export function isEngineSubagentTailActive(taskId) {
     return activeTails.has(taskId);
 }
-export function tailEngineSubagent(taskId) {
+export function tailEngineSubagent(taskId, opts) {
     if (activeTails.has(taskId))
         return;
     const { record: owner, runId, key } = resolveOwnerContext(taskId);
-    const cfg = engineWireTargetFor(key);
-    if (!cfg)
+    const wire = engineWireFor(opts?.wire, key, usableTailClient);
+    if (wire.kind === 'no-target')
+        return;
+    if (wire.kind === 'injected-unusable') {
+        hostLog('debug', `[subagent-tail] ${taskId}: the engine client supplied by the host is not usable (needs capabilities and runs.subagentStream) — tail not opened`);
         return;
+    }
     if (!runId) {
         noteBgOwnerAbsence('subagent-tail', taskId);
         return;
     }
-    const client = makeEngineWireClient({
-        baseUrl: cfg.baseUrl,
-        ...(cfg.token ? { token: cfg.token } : {}),
-        principal: cfg.principal,
-    });
-    if (!client)
-        return;
+    let client;
+    let cacheKey;
+    let injected;
+    if (wire.kind === 'injected') {
+        client = wire.client;
+        cacheKey = wire.capsBaseUrl;
+        injected = true;
+    }
+    else {
+        const made = wire.make();
+        if (!made)
+            return;
+        client = made;
+        cacheKey = wire.target.baseUrl;
+        injected = false;
+    }
     const ac = new AbortController();
     activeTails.set(taskId, ac);
     const openedAt = Date.now();
@@ -70,7 +88,7 @@ export function tailEngineSubagent(taskId) {
     let firstContentLogged = false;
     void (async () => {
         try {
-            if (!(await subagentStreamCapable(client, cfg.baseUrl, ac.signal)))
+            if (!(await subagentStreamCapable(client, cacheKey, ac.signal, injected ? INJECTED_WIRE_SETTLE_MS : undefined)))
                 return;
             const session = owner?.sessionId ?? engineSessionParamFor(key);
             const stream = client.runs.subagentStream(runId, taskId, {

package/dist/subagent/engineTaskHandleWire.d.ts

@@ -1,3 +1,13 @@
+import { type AgentClient } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type EngineTaskOutputWireClient = {
+    runs: Pick<AgentClient['runs'], 'taskOutput'>;
+};
+export type EngineTaskOutputWire = EngineWireInjection<EngineTaskOutputWireClient>;
+export type EngineTaskStopWireClient = {
+    runs: Pick<AgentClient['runs'], 'taskStop'>;
+};
+export type EngineTaskStopWire = EngineWireInjection<EngineTaskStopWireClient>;
 export interface EngineTaskOutputResult {
     content: string;
     status?: string;
@@ -7,6 +17,7 @@ export interface EngineTaskOutputResult {
 export declare function __resetTaskHandleWireForTests(): void;
 export declare function fetchEngineTaskOutput(handle: string, opts?: {
     signal?: AbortSignal;
+    wire?: EngineTaskOutputWire;
 }): Promise<EngineTaskOutputResult | null>;
 export interface TaskOutputMergeHint {
     readonly type?: string;
@@ -41,8 +52,10 @@ export type EngineTaskStopOutcome = {
     ok: false;
     reason: 'unavailable' | 'error';
     detail?: string;
+    unconfirmed?: true;
 };
 export declare function classifyTaskStopConflict(e: unknown): EngineTaskStopOutcome;
 export declare function stopEngineTask(handle: string, opts?: {
     signal?: AbortSignal;
+    wire?: EngineTaskStopWire;
 }): Promise<EngineTaskStopOutcome>;

package/dist/subagent/engineTaskHandleWire.js

@@ -1,11 +1,19 @@
 import { TaskStopConflictError } from '@sema-agent/sdk';
 import { hostLog } from '../host.js';
-import { makeEngineWireClient } from '../engineWireSdk.js';
-import { engineWireDebugEnabled, engineWireTargetFor } from '../engineWireTarget.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, sendOnce, settleInjected } from '../engineWireFor.js';
+import { engineWireDebugEnabled } from '../engineWireTarget.js';
+import { engineCapTrue } from '../engineCapsCache.js';
 import { engineSessionParamFor } from '../engineSessionParam.js';
 import { resolveOwnerContext } from './engineSubagentResume.js';
 import { engineTaskHandlesCapable } from './engineRowStopGate.js';
 import { noteBgOwnerAbsence } from './subagentOwnerAbsence.js';
+function usableTaskOutputClient(client) {
+    return clientHasVerbs(client, [['runs', 'taskOutput']]);
+}
+function usableTaskStopClient(client) {
+    return clientHasVerbs(client, [['runs', 'taskStop']]);
+}
+const CAPS_KEY_REQUIRED_DETAIL = 'capability evidence for taskHandles is not available under the key the host named (capsBaseUrl) — nothing sent';
 import { spoolMarkerOf } from '../toolResult.js';
 import { STOP_CONFLICT_CODES, STOP_NOT_LANDED, STOP_NOT_LOCAL, STOP_PARKED, STOP_PARK_ARBITER_UNREACHABLE, STOP_PARK_RESUME_WON, } from '../engineErrorCodes.js';
 function resolveHostRun(handle) {
@@ -26,24 +34,30 @@ export function __resetTaskHandleWireForTests() {
 }
 export async function fetchEngineTaskOutput(handle, opts) {
     const owner = resolveOwnerContext(handle);
-    const cfg = engineWireTargetFor(owner.key);
-    if (!cfg || !engineTaskHandlesCapable(owner.key))
+    const wire = engineWireFor(opts?.wire, owner.key, usableTaskOutputClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
+        return null;
+    if (wire.kind === 'injected') {
+        if (!engineCapTrue(wire.capsBaseUrl, 'taskHandles')) {
+            hostLog('debug', `[task-handle] output ${handle}: ${CAPS_KEY_REQUIRED_DETAIL}`);
+            return null;
+        }
+    }
+    else if (!engineTaskHandlesCapable(owner.key)) {
         return null;
+    }
     const runId = resolveHostRun(handle);
     if (!runId)
         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;
     try {
-        const r = await client.runs.taskOutput(runId, handle, {
-            ...(opts?.signal ? { signal: opts.signal } : {}),
+        const read = (signal) => client.runs.taskOutput(runId, handle, {
+            ...(signal ? { signal } : {}),
             ...(sessionOf(owner)),
         });
+        const r = wire.kind === 'injected' ? await settleInjected(INJECTED_WIRE_SETTLE_MS, opts?.signal, read) : await read(opts?.signal);
         const fresh = typeof r?.content === 'string' ? r.content : '';
         const prev = accumulated.get(handle) ?? '';
         const cursorSemantics = r?.cursorSemantics;
@@ -121,24 +135,28 @@ export function classifyTaskStopConflict(e) {
 }
 export async function stopEngineTask(handle, opts) {
     const owner = resolveOwnerContext(handle);
-    const cfg = engineWireTargetFor(owner.key);
-    if (!cfg || !engineTaskHandlesCapable(owner.key))
+    const wire = engineWireFor(opts?.wire, owner.key, usableTaskStopClient);
+    if (wire.kind === 'no-target' || wire.kind === 'injected-unusable')
+        return { ok: false, reason: 'unavailable' };
+    if (wire.kind === 'injected') {
+        if (!engineCapTrue(wire.capsBaseUrl, 'taskHandles'))
+            return { ok: false, reason: 'unavailable', detail: CAPS_KEY_REQUIRED_DETAIL };
+    }
+    else if (!engineTaskHandlesCapable(owner.key)) {
         return { ok: false, reason: 'unavailable' };
+    }
     const runId = resolveHostRun(handle);
     if (!runId)
         return { ok: false, reason: 'unavailable', detail: 'no host run mapping' };
-    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 { ok: false, reason: 'unavailable' };
     try {
-        const r = await client.runs.taskStop(runId, handle, {
-            ...(opts?.signal ? { signal: opts.signal } : {}),
+        const stop = (signal) => client.runs.taskStop(runId, handle, {
+            ...(signal ? { signal } : {}),
             ...(sessionOf(owner)),
         });
+        const r = wire.kind === 'injected' ? await settleInjected(INJECTED_WIRE_SETTLE_MS, opts?.signal, stop) : await sendOnce(opts?.signal, () => stop(opts?.signal));
         const out = r?.output ?? {};
         if (engineWireDebugEnabled()) {
             hostLog('debug', `[task-handle] stop ${handle} via run ${runId}: ok status=${typeof out.status === 'string' ? out.status : '-'} stoppedBy=${typeof out.stoppedBy === 'string' ? out.stoppedBy : '-'}`);
@@ -156,6 +174,9 @@ export async function stopEngineTask(handle, opts) {
         if (e instanceof TaskStopConflictError || status === 409) {
             return classifyTaskStopConflict(e);
         }
+        const noAnswer = typeof e === 'object' ? noAnswerDetailFrom(e) : null;
+        if (noAnswer !== null)
+            return { ok: false, reason: 'error', detail: noAnswer, unconfirmed: true };
         return { ok: false, reason: 'error', detail };
     }
 }

package/dist/systemReminderTag.d.ts

@@ -1,2 +1,7 @@
+export interface SystemReminderOpenTagSpan {
+    readonly start: number;
+    readonly end: number;
+}
+export declare function findSystemReminderOpenTag(text: string, from?: number): SystemReminderOpenTagSpan | null;
 export declare function unwrapSystemReminder(text: string): string;
 export declare function stripSystemReminderBlocks(text: string): string;

package/dist/systemReminderTag.js

@@ -1,29 +1,40 @@
 const OPEN_TAG_SOURCE = '<system-reminder(?: mark="[A-Za-z0-9_-]{22}")?>';
 const CLOSE_TAG = '</system-reminder>';
-const OPEN_TAG_AT_START_RE = new RegExp(`^${OPEN_TAG_SOURCE}`);
+function matchOpenTag(text, from, anchored) {
+    const re = new RegExp(OPEN_TAG_SOURCE, anchored ? 'y' : 'g');
+    re.lastIndex = from;
+    const m = re.exec(text);
+    return m === null ? null : { start: m.index, end: m.index + m[0].length };
+}
+export function findSystemReminderOpenTag(text, from) {
+    if (typeof text !== 'string')
+        return null;
+    const at = from === undefined ? 0 : from;
+    if (!Number.isInteger(at) || at < 0 || at > text.length)
+        return null;
+    return matchOpenTag(text, at, false);
+}
 export function unwrapSystemReminder(text) {
     const head = text.trimStart();
-    const open = OPEN_TAG_AT_START_RE.exec(head);
+    const open = matchOpenTag(head, 0, true);
     if (open === null)
         return text;
     const whole = head.trimEnd();
-    if (!whole.endsWith(CLOSE_TAG) || whole.length - CLOSE_TAG.length < open[0].length)
+    if (!whole.endsWith(CLOSE_TAG) || whole.length - CLOSE_TAG.length < open.end)
         return text;
-    return whole.slice(open[0].length, whole.length - CLOSE_TAG.length).trim();
+    return whole.slice(open.end, whole.length - CLOSE_TAG.length).trim();
 }
 export function stripSystemReminderBlocks(text) {
-    const openRe = new RegExp(OPEN_TAG_SOURCE, 'g');
     let out = '';
     let pos = 0;
     for (;;) {
-        openRe.lastIndex = pos;
-        const open = openRe.exec(text);
+        const open = matchOpenTag(text, pos, false);
         if (open === null)
             break;
-        const close = text.indexOf(CLOSE_TAG, open.index + open[0].length);
+        const close = text.indexOf(CLOSE_TAG, open.end);
         if (close === -1)
             break;
-        out += text.slice(pos, open.index);
+        out += text.slice(pos, open.start);
         pos = close + CLOSE_TAG.length;
     }
     return pos === 0 ? text : out + text.slice(pos);

package/dist/taskRequestWords.d.ts

@@ -0,0 +1,5 @@
+import type { TaskRequest } from '@sema-agent/sdk';
+export type TaskRequestReasoningEffort = NonNullable<TaskRequest['reasoningEffort']>;
+export declare const REASONING_EFFORT_WORDS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+export type TaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
+export declare const PERMISSION_MODE_WORDS: readonly ["default", "plan", "acceptEdits", "bypassPermissions", "auto"];

package/dist/taskRequestWords.js

@@ -0,0 +1,4 @@
+export const REASONING_EFFORT_WORDS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+export const PERMISSION_MODE_WORDS = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto'];
+const _taskRequestWordPins = [true, true, true, true];
+void _taskRequestWordPins;

package/dist/wireErrorTriage.d.ts

@@ -5,6 +5,7 @@ export type TurnWireErrorVerdict = {
     errorCode?: string;
     message: string;
     storedRowWhere?: string;
+    sessionUnreadable?: true;
 } | {
     kind: 'stream-ended-without-terminal';
 } | {

package/dist/wireErrorTriage.js

@@ -1,6 +1,6 @@
 import { readErrorNumber, readErrorString, readErrorStringList } from './wireFailureShape.js';
 import { capForDisplay } from './fleetTaskDesc.js';
-import { DRAINING_ERROR_CODE, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
+import { DRAINING_ERROR_CODE, isCorruptSessionCode, RESUME_AT_ERROR_CODE_PREFIX, RESUME_POLICY_FOLD_CODE, RESUME_RETRY_LATER_CODES, RESUME_USAGE_WINDOW_EXHAUSTED, SCENARIO_NOT_ALLOWED_ERROR_CODE, } from './engineErrorCodes.js';
 export const WIRE_NETWORK_ERROR_PATTERN = /fetch failed|ECONNREFUSED|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EHOSTUNREACH|ENETUNREACH|EPIPE|socket hang up|UND_ERR|terminated|other side closed/i;
 function wireErrorDetail(err) {
     const e = err;
@@ -15,12 +15,14 @@ export function classifyTurnWireError(err) {
         const errorCode = typeof e.errorCode === 'string' && e.errorCode.length > 0 ? e.errorCode : undefined;
         const message = typeof e.message === 'string' && e.message.length > 0 ? e.message : String(err);
         const storedRowWhere = corruptStoredRowWhere(err);
+        const sessionUnreadable = isCorruptSessionCode(effectiveWireErrorCode(err));
         return {
             kind: 'http',
             status: e.status,
             ...(errorCode !== undefined ? { errorCode } : {}),
             message,
             ...(storedRowWhere !== undefined ? { storedRowWhere } : {}),
+            ...(sessionUnreadable ? { sessionUnreadable: true } : {}),
         };
     }
     const errName = typeof err === 'object' && err !== null && typeof err.name === 'string'