@sema-agent/client-core 0.91.0 → 0.93.0

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,4 @@
-import { FLEET_LEASE_UNAVAILABLE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { FLEET_LEASE_UNAVAILABLE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
 import type { TaskRequestLike } from './request/taskRequest.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
 export declare const CONFLICT_RUN_NOT_RUNNING = "conflict.run_not_running";
@@ -22,14 +22,20 @@ export interface FleetLeaseUnavailableDetail {
 }
 export declare function fleetLeaseUnavailableFromError(err: unknown): FleetLeaseUnavailableDetail | null;
 export declare function fleetLeaseUnavailableContent(detail: FleetLeaseUnavailableDetail): string;
-export type DenyAttributionRefusalKind = 'not_in_proof' | 'decision_conflict' | 'attribution_rejected';
+export interface ScenarioAssignmentUnknownDetail {
+    code: typeof SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE;
+    scenario?: string;
+    source?: 'ruling' | 'deployment';
+}
+export declare function scenarioAssignmentUnknownFromError(err: unknown): ScenarioAssignmentUnknownDetail | null;
+export type DenyAttributionRefusalKind = 'not_in_proof' | 'decision_conflict' | 'attribution_rejected' | 'retired_key';
 export interface DenyAttributionRefusalDetail {
     kind: DenyAttributionRefusalKind;
     code: string;
     status: number;
     field?: string;
 }
-export declare function denyAttributionRefusalFromError(err: unknown, sentSettledBy: boolean): DenyAttributionRefusalDetail | null;
+export declare function denyAttributionRefusalFromError(err: unknown, sentAttributionKey: boolean): DenyAttributionRefusalDetail | null;
 export declare function denyAttributionRefusalContent(detail: Pick<DenyAttributionRefusalDetail, 'kind' | 'field'>): string;
 export declare const CONFLICT_SESSION_CHILDREN_ALIVE = "conflict.session_children_alive";
 export type SessionDeleteConflictKind = 'children_alive' | 'active_run' | 'unrecognized';

package/dist/wireRefusalCopy.js

@@ -1,6 +1,6 @@
 import { readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList } from './wireFailureShape.js';
 import { readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_FIELD_CONFLICT, RESUME_POLICY_FOLD_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_FIELD_CONFLICT, RESUME_POLICY_FOLD_CODE, SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
@@ -145,7 +145,38 @@ export function fleetLeaseUnavailableContent(detail) {
         : ' · The engine did not say how long to wait — send it again a little later';
     return `${head}${cause}${wait}`;
 }
+export function scenarioAssignmentUnknownFromError(err) {
+    try {
+        if (err === null || typeof err !== 'object')
+            return null;
+        if (effectiveWireErrorCode(err) !== SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE)
+            return null;
+        const detail = readErrorRecord(err, 'detail');
+        const bit = (key) => {
+            if (detail === undefined)
+                return undefined;
+            try {
+                return Object.hasOwn(detail, key) ? detail[key] : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        };
+        const scenario = bit('scenario');
+        const source = bit('source');
+        return {
+            code: SCENARIO_ASSIGNMENT_UNKNOWN_ERROR_CODE,
+            ...(typeof scenario === 'string' && scenario.length > 0 ? { scenario } : {}),
+            ...(source === 'ruling' || source === 'deployment' ? { source } : {}),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 const SETTLED_BY_NOT_IN_PROOF = 'settled_by_not_in_proof';
+const DECIDED_BY_NOT_IN_PROOF = 'decided_by_not_in_proof';
+const RETIRED_DECISION_KEY = 'settledBy';
 const RESUME_OUTCOME_INVALID = 'resume_outcome_invalid';
 const APPROVAL_NON_BINDING_FIELDS = new Set(['hostDecision', 'approver']);
 function readRefusalField(o) {
@@ -163,7 +194,7 @@ function readRefusalField(o) {
     }
     return readStringField(o, 'field');
 }
-export function denyAttributionRefusalFromError(err, sentSettledBy) {
+export function denyAttributionRefusalFromError(err, sentAttributionKey) {
     try {
         if (err === null || typeof err !== 'object')
             return null;
@@ -175,9 +206,12 @@ export function denyAttributionRefusalFromError(err, sentSettledBy) {
         const code = readStringField(o, 'errorCode');
         if (code === undefined)
             return null;
-        if (status === 400 && code === SETTLED_BY_NOT_IN_PROOF)
+        if (status === 400 && (code === SETTLED_BY_NOT_IN_PROOF || code === DECIDED_BY_NOT_IN_PROOF))
             return { kind: 'not_in_proof', code, status };
-        if (status === 400 && code === REQUEST_FIELD_CONFLICT && sentSettledBy) {
+        if (status === 400 && code === BODY_SHAPE && readRefusalField(o) === RETIRED_DECISION_KEY) {
+            return { kind: 'retired_key', code, status, field: RETIRED_DECISION_KEY };
+        }
+        if (status === 400 && code === REQUEST_FIELD_CONFLICT && sentAttributionKey) {
             return { kind: 'decision_conflict', code, status };
         }
         if (status === 409 && code === RESUME_OUTCOME_INVALID) {
@@ -202,6 +236,9 @@ export function denyAttributionRefusalContent(detail) {
             return ('The engine refused this decision before judging it: the body says a policy settled it and also asks to allow the call, ' +
                 'and only a person can allow one · Nothing was decided and the approval is still waiting — ' +
                 'send it again with the decision and the note in agreement');
+        case 'retired_key':
+            return ('The engine refused this decision before judging it: the note saying who settled it was sent under a name this engine no longer accepts · ' +
+                'Nothing was decided and the approval is still waiting — send the decision again with who made it given under the name the engine now takes in its place');
         case 'attribution_rejected': {
             const named = typeof detail.field === 'string' && APPROVAL_NON_BINDING_FIELDS.has(detail.field)
                 ? ` It named ${detail.field} as the part it would not take.`

package/dist/workflowsJournalCapability.d.ts

@@ -0,0 +1,18 @@
+export type WorkflowsJournalReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    kind: 'present';
+};
+export declare function projectWorkflowsJournalCapability(caps: unknown): WorkflowsJournalReading | undefined;
+export declare function noteEngineCapsForWorkflowsJournal(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+export declare function observedWorkflowsJournal(baseUrl?: string | undefined): WorkflowsJournalReading;
+export declare function workflowsJournalAvailable(reading: WorkflowsJournalReading): 'yes' | 'no' | 'unknown';
+export declare function workflowsJournalDoctorDetail(reading: WorkflowsJournalReading): string;
+export declare function forgetWorkflowsJournalReading(baseUrl: string | undefined): void;
+export declare function __resetWorkflowsJournalReadingsForTests(): void;

package/dist/workflowsJournalCapability.js

@@ -0,0 +1,50 @@
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+export function projectWorkflowsJournalCapability(caps) {
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    if (!Object.hasOwn(caps, 'workflowsJournal'))
+        return { kind: 'not_reported' };
+    const v = caps.workflowsJournal;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'boolean')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+const reader = createEngineCapReader({
+    name: 'workflowsJournal',
+    project: projectWorkflowsJournalCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+export function noteEngineCapsForWorkflowsJournal(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+export function observedWorkflowsJournal(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+export function workflowsJournalAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent')
+        return 'no';
+    return 'unknown';
+}
+export function workflowsJournalDoctorDetail(reading) {
+    switch (reading.kind) {
+        case 'unobserved':
+            return 'workflow journal not observed — the engine reports it on /v1/capabilities (workflowsJournal); this process has no usable capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)';
+        case 'not_reported':
+            return 'workflow journal not reported by this engine — the engine predates the separate flag, so the workflow listing flag still covers the journal';
+        case 'absent':
+            return 'no workflow journal on this deployment — workflows can be listed and followed, but their execution journal cannot be read';
+        case 'present':
+            return 'workflow journal on — a workflow’s execution journal can be read';
+    }
+}
+export function forgetWorkflowsJournalReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+export function __resetWorkflowsJournalReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/writeProtectionCapability.d.ts

@@ -1,7 +1,5 @@
-export interface WriteProtectionCapabilityView {
-    armed: boolean;
-    rows: number;
-    replaced: boolean;
+import type { WriteProtectionCapability } from '@sema-agent/sdk';
+export interface WriteProtectionCapabilityView extends Pick<WriteProtectionCapability, 'armed' | 'rows' | 'replaced'> {
 }
 export type WriteProtectionReading = {
     kind: 'unobserved';

package/dist/writeProtectionCapability.js

@@ -75,7 +75,7 @@ export function writeProtectionDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
             return ('not observed — the engine reports it on /v1/capabilities; this process has no usable ' +
-                'capabilities reading cached for it (none received, or the last one was unreadable)');
+                'capabilities reading cached for it (none received, the last one was unreadable, or the last one was discarded when the engine connection was reset; this process cannot tell which)');
         case 'not_reported':
             return ('not reported by this engine — the capability position needs a newer engine; this says ' +
                 'nothing about whether a protected-name table is in effect (an absent seat is the engine ' +