@sema-agent/client-core 0.82.0 → 0.82.2

package/dist/index.d.ts

@@ -78,6 +78,7 @@ export * from './retainBackgroundWireCaps.js';
 export * from './oneShotWireCaps.js';
 export * from './rewindWireCaps.js';
 export * from './rewindArchiveCapability.js';
+export * from './fileHistoryCaptureCapability.js';
 export * from './registryQuotaUsage.js';
 export * from './selfOrchestrationWireCaps.js';
 export * from './skillsWireCaps.js';
@@ -86,6 +87,7 @@ export * from './selfOrchestrationDenial.js';
 export * from './webSearchWireCaps.js';
 export * from './liveModelCatalog.js';
 export * from './modelBudgetRule.js';
+export * from './modelIdentityResolvability.js';
 export * from './sessionModelLatch.js';
 export * from './effortWire.js';
 export * from './adapter/types.js';

package/dist/index.js

@@ -77,6 +77,7 @@ export * from './retainBackgroundWireCaps.js';
 export * from './oneShotWireCaps.js';
 export * from './rewindWireCaps.js';
 export * from './rewindArchiveCapability.js';
+export * from './fileHistoryCaptureCapability.js';
 export * from './registryQuotaUsage.js';
 export * from './selfOrchestrationWireCaps.js';
 export * from './skillsWireCaps.js';
@@ -85,6 +86,7 @@ export * from './selfOrchestrationDenial.js';
 export * from './webSearchWireCaps.js';
 export * from './liveModelCatalog.js';
 export * from './modelBudgetRule.js';
+export * from './modelIdentityResolvability.js';
 export * from './sessionModelLatch.js';
 export * from './effortWire.js';
 export * from './adapter/types.js';

package/dist/modelIdentityResolvability.d.ts

@@ -0,0 +1,31 @@
+type ModelIdentityLaneTuple = readonly [
+    'processEnv',
+    'settingsEnv',
+    'modelCatalogFile',
+    'followedSettingsFile',
+    'followedProviderEnv'
+];
+export type ModelIdentityLane = ModelIdentityLaneTuple[number];
+export type ModelIdentityLaneReading = 'complete' | 'partial' | 'absent' | 'unreadable';
+export type ModelIdentityLanes = {
+    [L in ModelIdentityLane]: L extends 'modelCatalogFile' ? Exclude<ModelIdentityLaneReading, 'complete'> : ModelIdentityLaneReading;
+};
+export type EngineAnswerObservation = 'answered' | 'not_observed' | 'unreachable';
+export interface LocalEngineModelIdentityReading {
+    engine: 'local';
+    lanes: ModelIdentityLanes;
+    engineAnswer?: EngineAnswerObservation;
+}
+export interface RemoteEngineModelIdentityReading {
+    engine: 'remote';
+    engineAnswer: EngineAnswerObservation;
+}
+export type ModelIdentityReading = LocalEngineModelIdentityReading | RemoteEngineModelIdentityReading;
+export type ModelIdentityResolvability = 'resolvable' | 'not_resolvable' | 'unknown';
+export type ModelSetupDecision = 'offer_setup' | 'explain_unconfigured' | 'proceed';
+export declare function modelIdentityResolvability(reading: ModelIdentityReading): ModelIdentityResolvability;
+export declare function modelIdentityDetail(reading: ModelIdentityReading): string;
+export declare function modelSetupDecision(identity: ModelIdentityResolvability, hostCanConfigureModel: boolean): ModelSetupDecision;
+export declare function modelSetupNotice(decision: ModelSetupDecision): string | null;
+export declare function observedEngineAnswer(baseUrl?: string | undefined): EngineAnswerObservation;
+export {};

package/dist/modelIdentityResolvability.js

@@ -0,0 +1,145 @@
+import { engineCapValue } from './engineCapsCache.js';
+import { engineWireTarget } from './engineWireTarget.js';
+function laneOrder() {
+    return ['processEnv', 'settingsEnv', 'modelCatalogFile', 'followedSettingsFile', 'followedProviderEnv'];
+}
+function malformed() {
+    return { verdict: 'unknown', why: 'malformed' };
+}
+function own(o, key) {
+    if (!Object.hasOwn(o, key))
+        return undefined;
+    return { v: o[key] };
+}
+function isPlainObject(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+function laneState(lanes, lane) {
+    const hit = own(lanes, lane);
+    if (hit === undefined)
+        return 'not_reported';
+    const v = hit.v;
+    const _catalogPin = true;
+    void _catalogPin;
+    if (v === 'complete')
+        return lane === 'modelCatalogFile' ? 'unusable' : v;
+    return v === 'partial' || v === 'absent' || v === 'unreadable' ? v : 'unusable';
+}
+function analyse(reading) {
+    try {
+        if (!isPlainObject(reading))
+            return malformed();
+        const answer = own(reading, 'engineAnswer')?.v;
+        if (answer === 'answered')
+            return { verdict: 'resolvable', why: 'engine_answered' };
+        const engine = own(reading, 'engine')?.v;
+        if (engine === 'remote') {
+            return { verdict: 'unknown', why: 'remote', answer: answer === 'unreachable' ? 'unreachable' : 'not_observed' };
+        }
+        if (engine !== 'local')
+            return malformed();
+        const lanesHit = own(reading, 'lanes')?.v;
+        const order = laneOrder();
+        if (!isPlainObject(lanesHit))
+            return { verdict: 'unknown', why: 'lanes', unreadable: [], unreported: [...order], unusable: [] };
+        const partial = [];
+        const unreadable = [];
+        const unreported = [];
+        const unusable = [];
+        for (const lane of order) {
+            const s = laneState(lanesHit, lane);
+            if (s === 'complete')
+                return { verdict: 'resolvable', why: 'lane', lane };
+            if (s === 'partial')
+                partial.push(lane);
+            else if (s === 'unreadable')
+                unreadable.push(lane);
+            else if (s === 'not_reported')
+                unreported.push(lane);
+            else if (s === 'unusable')
+                unusable.push(lane);
+        }
+        if (unreadable.length > 0 || unreported.length > 0 || unusable.length > 0) {
+            return { verdict: 'unknown', why: 'lanes', unreadable, unreported, unusable };
+        }
+        return { verdict: 'not_resolvable', partial };
+    }
+    catch {
+        return malformed();
+    }
+}
+export function modelIdentityResolvability(reading) {
+    return analyse(reading).verdict;
+}
+function laneLabel(lane) {
+    switch (lane) {
+        case 'processEnv':
+            return 'the environment this client was started with';
+        case 'settingsEnv':
+            return "this client's settings file";
+        case 'modelCatalogFile':
+            return 'the local model catalog file';
+        case 'followedSettingsFile':
+            return "another tool's settings file that this client follows";
+        case 'followedProviderEnv':
+            return 'the provider environment variables this client follows';
+    }
+}
+function joinPhrases(xs) {
+    if (xs.length <= 1)
+        return xs.join('');
+    return `${xs.slice(0, -1).join(', ')} and ${xs[xs.length - 1]}`;
+}
+export function modelIdentityDetail(reading) {
+    const a = analyse(reading);
+    switch (a.verdict) {
+        case 'resolvable':
+            if (a.why === 'engine_answered') {
+                return 'the engine is up and answering, and it does not start without a model name, so it has one — whether its gateway accepts that name is a separate check';
+            }
+            return `${laneLabel(a.lane)} supplies a model name, so the local engine can start with it — whether its gateway accepts that name is a separate check`;
+        case 'not_resolvable':
+            if (a.partial.length > 0) {
+                const labels = joinPhrases(a.partial.map(laneLabel));
+                return `no model name is configured for the local engine — ${labels} ${a.partial.length > 1 ? 'carry' : 'carries'} part of a model configuration (such as a gateway address or a credential) but no model name, and the engine does not start without one`;
+            }
+            return 'no model name is configured for the local engine — none of the places this client reads supplies one, and the engine does not start without it';
+        case 'unknown':
+            if (a.why === 'remote') {
+                return a.answer === 'unreachable'
+                    ? 'the engine runs elsewhere and did not answer — it may be unreachable or may have failed to start; its model configuration lives with that deployment, so whether it has a model name is unknown'
+                    : 'the engine runs elsewhere and has not been seen answering yet — its model configuration lives with that deployment, so whether it has a model name is unknown';
+            }
+            if (a.why === 'lanes') {
+                const parts = [
+                    ...a.unreadable.map((l) => `${laneLabel(l)} could not be read`),
+                    ...a.unreported.map((l) => `${laneLabel(l)} was not reported`),
+                    ...a.unusable.map((l) => `${laneLabel(l)} gave no usable reading`),
+                ];
+                return `whether the local engine has a model name is unknown — ${joinPhrases(parts)}, and no other place this client reads provides one`;
+            }
+            return "this reading of the engine's model configuration could not be interpreted, so whether the engine has a model name is unknown";
+    }
+}
+export function modelSetupDecision(identity, hostCanConfigureModel) {
+    if (identity !== 'not_resolvable')
+        return 'proceed';
+    if (hostCanConfigureModel === true)
+        return 'offer_setup';
+    if (hostCanConfigureModel === false)
+        return 'explain_unconfigured';
+    return 'proceed';
+}
+export function modelSetupNotice(decision) {
+    switch (decision) {
+        case 'offer_setup':
+            return 'no model name is configured for the engine, and it does not start without one — opening model setup';
+        case 'explain_unconfigured':
+            return 'this engine has no model configured, and it cannot be configured from this client — ask whoever runs the engine to set one up';
+        default:
+            return null;
+    }
+}
+export function observedEngineAnswer(baseUrl = engineWireTarget()?.baseUrl) {
+    return engineCapValue(baseUrl, 'version').kind === 'unobserved' ? 'not_observed' : 'answered';
+}

package/dist/notifications.d.ts

@@ -1,3 +1,4 @@
+import type { PlanReviewOutcomeMeta } from './hitl/planReviewWire.js';
 export interface TaskNotificationFields {
     taskId: string;
     status: string;
@@ -48,12 +49,13 @@ export interface NotificationQueuePort {
         priority: 'later';
         isMeta: true;
         workload: string;
+        _sema_planReviewOutcome?: PlanReviewOutcomeMeta;
     }): void;
 }
 export declare function installNotificationQueuePort(port: NotificationQueuePort | null): void;
 export declare function notificationQueuePortMisses(): number;
 export declare function _resetNotificationQueuePortForTest(): void;
-export declare function enqueuePlanReviewOutcome(value: string): boolean;
+export declare function enqueuePlanReviewOutcome(value: string, meta?: PlanReviewOutcomeMeta): boolean;
 export declare function dropQueuedNotificationsForRun(taskId: string): number;
 export declare function markEngineWorkflowNotified(runId: string): void;
 export declare function isEngineWorkflowNotified(runId: string): boolean;

package/dist/notifications.js

@@ -188,7 +188,7 @@ function notifiedBgCycleAtLeast(taskId, cycle) {
     const high = notifiedBgCycleHigh.get(taskId);
     return high !== undefined && high.cycle >= cycle ? high : undefined;
 }
-export function enqueuePlanReviewOutcome(value) {
+export function enqueuePlanReviewOutcome(value, meta) {
     const p = port();
     if (!p)
         return false;
@@ -196,7 +196,23 @@ export function enqueuePlanReviewOutcome(value) {
         queuePortMisses++;
         return false;
     }
-    p.enqueueMetaPrompt({ value, mode: 'prompt', priority: 'later', isMeta: true, workload: 'plan-review' });
+    p.enqueueMetaPrompt({
+        value,
+        mode: 'prompt',
+        priority: 'later',
+        isMeta: true,
+        workload: 'plan-review',
+        ...(meta !== undefined
+            ? {
+                _sema_planReviewOutcome: Object.freeze({
+                    taskId: meta.taskId,
+                    dispatchNo: meta.dispatchNo,
+                    decision: meta.decision,
+                    effect: meta.effect,
+                }),
+            }
+            : {}),
+    });
     return true;
 }
 export function dropQueuedNotificationsForRun(taskId) {

package/dist/printToolResultFrame.js

@@ -1,6 +1,8 @@
 import { isCcToolDenialKind } from './gateVocabulary.js';
 export { flattenWireOutput as flattenToolOutput } from './adapt/wireShapes.js';
 import { flattenWireOutput } from './adapt/wireShapes.js';
+import { parseModelFacingBash } from './toolResult.js';
+import { toolResultEnvelopeParts, toolResultOutcomeOf } from './adapt/toolCards.js';
 function bashExitCodeFailed(toolName, text, structured) {
     if (typeof toolName !== 'string' || toolName.toLowerCase() !== 'bash')
         return false;
@@ -10,6 +12,8 @@ function bashExitCodeFailed(toolName, text, structured) {
     const ec = st?.exitCode;
     if (typeof ec === 'number')
         return ec !== 0;
+    if (parseModelFacingBash(text)?.note !== undefined)
+        return false;
     const m = /^exit code: (\d+)\b/.exec(text);
     return m !== null && m[1] !== '0';
 }
@@ -17,6 +21,14 @@ export function toolEndResultToUserFrame(arm) {
     if (typeof arm.toolCallId !== 'string' || arm.toolCallId.length === 0)
         return null;
     const text = flattenWireOutput(arm.output);
+    const parent = typeof arm.parentToolCallId === 'string' ? arm.parentToolCallId : null;
+    const outcome = toolResultOutcomeOf(typeof arm.toolName === 'string' ? arm.toolName : '', {
+        output: arm.output,
+        structured: arm.structured,
+        truncated: arm.truncated === true,
+        isError: arm.isError === true,
+    }, undefined, parent === null ? 'leader' : 'subagent');
+    const envelope = toolResultEnvelopeParts(outcome);
     return {
         type: 'user',
         message: {
@@ -30,8 +42,10 @@ export function toolEndResultToUserFrame(arm) {
                 },
             ],
         },
-        parent_tool_use_id: typeof arm.parentToolCallId === 'string' ? arm.parentToolCallId : null,
+        parent_tool_use_id: parent,
         ...(isCcToolDenialKind(arm._sema_denial_kind) ? { _sema_denial_kind: arm._sema_denial_kind } : {}),
+        ...(Object.hasOwn(envelope, 'tool_use_result') ? { tool_use_result: envelope.tool_use_result } : {}),
+        ...(Object.hasOwn(envelope, '_sema_degraded') ? { _sema_degraded: envelope._sema_degraded } : {}),
         uuid: arm.uuid,
         session_id: arm.session_id,
     };

package/dist/resumeRefusalCopy.d.ts

@@ -7,6 +7,18 @@ export interface ResumeRefusalDetail {
 }
 export declare function resumeRefusalFromError(err: unknown): ResumeRefusalDetail | null;
 export declare function resumeRefusalContent(detail: ResumeRefusalDetail): string;
+export interface ResumePolicyBlockDetail {
+    blockedBy: {
+        kind: 'named';
+        code: string;
+    } | {
+        kind: 'absent';
+    } | {
+        kind: 'unreadable';
+    };
+}
+export declare function resumePolicyBlockFromError(err: unknown): ResumePolicyBlockDetail | null;
+export declare function resumePolicyBlockContent(detail: ResumePolicyBlockDetail): string;
 export interface ResumeReopenDetail {
     code: string;
     reason: 'env_failed' | 'tool_unavailable' | 'tool_contract_mismatch';

package/dist/resumeRefusalCopy.js

@@ -1,5 +1,6 @@
 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, } 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, } from './engineErrorCodes.js';
+import { capForDisplay } from './fleetTaskDesc.js';
 import { resumeRetryLaterFromError } from './wireErrorTriage.js';
 export const RESUME_REFUSAL_CODES = Object.freeze([
     RESUME_PLACEMENT_MISMATCH,
@@ -39,6 +40,49 @@ export function resumeRefusalContent(detail) {
             'The engine supplied no wait, so this refusal does not say whether the token stays redeemable');
     return parts.join(' · ');
 }
+export function resumePolicyBlockFromError(err) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    const o = err;
+    let outer;
+    try {
+        outer = o['errorCode'];
+    }
+    catch {
+        return null;
+    }
+    if (outer !== RESUME_POLICY_FOLD_CODE)
+        return null;
+    const judge = (v) => ({
+        blockedBy: typeof v === 'string' && v.length > 0 ? { kind: 'named', code: v } : { kind: 'unreadable' },
+    });
+    try {
+        const top = o['blockedBy'];
+        if (top !== undefined)
+            return judge(top);
+        const extra = o['extra'];
+        if (typeof extra === 'object' && extra !== null && !Array.isArray(extra) && Object.hasOwn(extra, 'blockedBy')) {
+            return judge(extra['blockedBy']);
+        }
+        return { blockedBy: { kind: 'absent' } };
+    }
+    catch {
+        return { blockedBy: { kind: 'unreadable' } };
+    }
+}
+export function resumePolicyBlockContent(detail) {
+    const b = detail.blockedBy;
+    const reason = b.kind === 'named'
+        ? `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';
+    return [
+        'The engine refused to resume this parked work at its admission check (the engine reports that its admission policy changed since the work was first accepted)',
+        reason,
+        "This refusal does not say whether anything was consumed before it or whether a retry would pass — check the task's current state before deciding again, and ask whoever operates this deployment if it keeps happening",
+    ].join(' · ');
+}
 export function resumeReopenFromError(err) {
     if (typeof err !== 'object' || err === null)
         return null;

package/dist/seam.d.ts

@@ -130,6 +130,7 @@ export type ChromeEvent = {
     engineUsage?: EngineTurnUsage;
     usageMissing?: true;
     stopReason?: string;
+    responseModel?: string;
 } | {
     kind: 'subagent_turn_usage';
     laneProof: LaneProof;
@@ -140,6 +141,7 @@ export type ChromeEvent = {
     engineUsage?: EngineTurnUsage;
     usageMissing?: true;
     stopReason?: string;
+    responseModel?: string;
 } | {
     kind: 'plan_review_park';
     laneProof: LaneProof;

package/dist/toolResult.d.ts

@@ -79,8 +79,8 @@ export interface ToolResultBody {
     degraded?: typeof TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT;
 }
 export declare function degradedToolResultBody(isError: boolean): ToolResultBody;
-export declare function wireOutputToBody(toolName: string, output: unknown, isError: boolean, truncated: boolean, flatten: FlattenWireOutput, structured?: unknown): ToolResultBody;
-export declare function structuredToToolUseResult(structured: unknown, modelText?: string): {
+export declare function wireOutputToBody(toolName: string, output: unknown, isError: boolean, truncated: boolean, flatten: FlattenWireOutput, structured?: unknown, leaderLedger?: boolean): ToolResultBody;
+export declare function structuredToToolUseResult(structured: unknown, modelText?: string, leaderLedger?: boolean): {
     toolUseResult: unknown;
     isError?: boolean;
 } | null;

package/dist/toolResult.js

@@ -229,7 +229,7 @@ export const TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT = 'wire_carried_no_output';
 export function degradedToolResultBody(isError) {
     return { content: '', isError, degraded: TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT };
 }
-export function wireOutputToBody(toolName, output, isError, truncated, flatten, structured) {
+export function wireOutputToBody(toolName, output, isError, truncated, flatten, structured, leaderLedger = true) {
     const text = flatten(output);
     const name = (toolName || '').toLowerCase();
     const sType = structuredDetailType(structured);
@@ -320,7 +320,7 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
         }
         const wfEnvelope = parseWorkflowPollEnvelope(text);
         if (wfEnvelope) {
-            if (WF_TERMINAL_STATUSES.has(wfEnvelope.status))
+            if (leaderLedger && WF_TERMINAL_STATUSES.has(wfEnvelope.status))
                 markEngineWorkflowNotified(wfEnvelope.taskId);
             return wrap({
                 task_id: wfEnvelope.taskId,
@@ -340,7 +340,7 @@ export function wireOutputToBody(toolName, output, isError, truncated, flatten,
     }
     return { content: truncated ? `${text}\n…(truncated)` : text, isError };
 }
-export function structuredToToolUseResult(structured, modelText) {
+export function structuredToToolUseResult(structured, modelText, leaderLedger = true) {
     if (typeof structured !== 'object' || structured === null)
         return null;
     const s = structured;
@@ -348,7 +348,7 @@ export function structuredToToolUseResult(structured, modelText) {
         if (typeof s[k] === 'string' && s[k].length > MAX_STRUCTURED_FIELD_CHARS)
             return null;
     }
-    if (s.type === 'workflow-run' && typeof s.workflowRunId === 'string') {
+    if (leaderLedger && s.type === 'workflow-run' && typeof s.workflowRunId === 'string') {
         registerOutstandingWorkflowRun(s.workflowRunId);
     }
     switch (s.type) {
@@ -586,7 +586,8 @@ export function structuredToToolUseResult(structured, modelText) {
             if (typeof s.description !== 'string' || typeof s.prompt !== 'string') {
                 return null;
             }
-            registerOutstandingBgTask(agentId, s.description, s.prompt, receipt.seq);
+            if (leaderLedger)
+                registerOutstandingBgTask(agentId, s.description, s.prompt, receipt.seq);
             return {
                 toolUseResult: {
                     isAsync: true,
@@ -653,7 +654,7 @@ export function structuredToToolUseResult(structured, modelText) {
             const runErrorCode = typeof s.errorCode === 'string' && s.errorCode.length > 0 ? s.errorCode : undefined;
             let output = bodyText ?? '';
             if (taskType === 'workflow') {
-                if (WF_TERMINAL_STATUSES.has(status))
+                if (leaderLedger && WF_TERMINAL_STATUSES.has(status))
                     markEngineWorkflowNotified(taskId);
                 const jsonSrc = output.length > 0 ? output : (modelText ?? '');
                 output = projectWorkflowTaskOutput(jsonSrc);