@sema-agent/client-core 0.82.0 → 0.82.1

package/dist/hitl/planReviewWire.js

@@ -4,6 +4,7 @@ import { makeEngineWireClient } from '../engineWireSdk.js';
 import { engineWireTarget } from '../engineWireTarget.js';
 import { enqueuePlanReviewOutcome } from '../notifications.js';
 import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
+import { decideFailureNote } from '../decideFailureNote.js';
 import { isPlanReviewModeAfter } from './hitlBridge.js';
 import { engineCapString } from '../engineCapsCache.js';
 import { planReviewQuestionId, REOPEN_ID_TAIL } from './gateIdentity.js';
@@ -337,7 +338,7 @@ async function decidePlanReviewInner(taskId, decision, permissionModeAfter, disp
                     const msg = e instanceof Error ? e.message : String(e);
                     hostLog('debug', `planReviewWire: ${decision} → ${status} ${msg.slice(0, 200)}`);
                     effect = status >= 400 && status < 500 ? 'not_applied' : 'unconfirmed';
-                    outcome = `The plan_review decision failed: HTTP ${status} ${msg}`.trim();
+                    outcome = `${`The plan_review decision failed: HTTP ${status} ${msg}`.trim()}${decideFailureNote(e)}`;
                 }
                 else {
                     outcome = `The plan_review decision could not reach the engine: ${String(e)}`;
@@ -382,6 +383,11 @@ export function reopenPlanReviewCard(taskId, opts) {
         if (typeof taskId !== 'string' || taskId.length === 0) {
             return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });
         }
+        if (decideInFlight.has(taskId)) {
+            hostLog('debug', `planReviewWire: reopen for task ${taskId} refused — a decision for this task is in flight (its answer is still being delivered)`);
+            const refused = { reopened: false, _sema_decisionInFlight: true };
+            return receiptMs === undefined ? refused : Promise.resolve(refused);
+        }
         const sessionKey = opts?.sessionKey ?? DEFAULT_SESSION_KEY;
         if (!hasQuestionOverlayFor(sessionKey)) {
             return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });

package/dist/hitl/toolApprovalWire.js

@@ -7,7 +7,7 @@ import { observeCancelByDeny, surfaceRememberNotApplied, surfaceEditNotForwarded
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
 import { isRuleStoreUnreadableKind } from '../gateVocabulary.js';
 import { denyAttributionRefusalFromError } from '../wireRefusalCopy.js';
-import { corruptStoredRowContent, corruptStoredRowWhere } from '../wireErrorTriage.js';
+import { decideFailureNote } from '../decideFailureNote.js';
 import { readDecideReceipt } from '../decideReceipt.js';
 import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, DENIAL_LIMIT_KINDS, } from '@sema-agent/sdk';
 export function isFsApprovalGate(gate) {
@@ -29,10 +29,6 @@ export function isToolApprovalGate(gate) {
         return true;
     return typeof gate?.toolName === 'string' && toolNameIsShellExec(gate.toolName);
 }
-function withCorruptStoredRow(reason, err) {
-    const where = corruptStoredRowWhere(err);
-    return where === undefined ? reason : `${reason} — ${corruptStoredRowContent(where)}`;
-}
 export function structurallyEqual(a, b) {
     if (a === b)
         return true;
@@ -204,7 +200,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                     kind: 'failed',
                     stage: 'decide',
                     gatedCallId,
-                    reason: withCorruptStoredRow(`decide(approve) failed: ${String(e)}`, e),
+                    reason: `decide(approve) failed: ${String(e)}${decideFailureNote(e)}`,
                     ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
                     ...(currentPending !== undefined ? { currentPending } : {}),
                     ...(wireCode !== undefined ? { errorCode: wireCode } : {}),
@@ -261,7 +257,7 @@ export async function surfaceFsApprovalAndDecide(deps, taskId, argsByCall, signa
                     kind: 'failed',
                     stage: 'decide',
                     gatedCallId,
-                    reason: withCorruptStoredRow(`decide(deny) failed: ${String(e)}`, e),
+                    reason: `decide(deny) failed: ${String(e)}${decideFailureNote(e)}`,
                     ...(e instanceof DecideTransportRetryExhaustedError ? { retryExhausted: true } : {}),
                     ...(currentPending !== undefined ? { currentPending } : {}),
                     ...(wireCode !== undefined ? { errorCode: wireCode } : {}),

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/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);