@sema-agent/client-core 0.90.0 → 0.92.0

package/dist/wireRefusalCopy.js

@@ -1,5 +1,6 @@
-import { readErrorNumber, readErrorStrictStringList, readErrorString, readErrorStringList } from './wireFailureShape.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, RESUME_POLICY_FOLD_CODE, USAGE_WINDOW_EXHAUSTED } from './engineErrorCodes.js';
+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 { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
@@ -145,7 +146,6 @@ export function fleetLeaseUnavailableContent(detail) {
     return `${head}${cause}${wait}`;
 }
 const SETTLED_BY_NOT_IN_PROOF = 'settled_by_not_in_proof';
-const REQUEST_FIELD_CONFLICT = 'request.field_conflict';
 const RESUME_OUTCOME_INVALID = 'resume_outcome_invalid';
 const APPROVAL_NON_BINDING_FIELDS = new Set(['hostDecision', 'approver']);
 function readRefusalField(o) {
@@ -559,3 +559,26 @@ export function hostPostureRefusalContent(detail) {
         return HOST_POSTURE_UNATTRIBUTED;
     }
 }
+const HOOK_MATCHER_REFUSAL_FIELD = 'settings.hooks';
+export function hookMatcherRefusalFromError(err) {
+    try {
+        if (typeof err !== 'object' || err === null)
+            return undefined;
+        if (err.errorCode !== FIELD_INVALID)
+            return undefined;
+        if (readErrorString(err, 'field') !== HOOK_MATCHER_REFUSAL_FIELD)
+            return undefined;
+        const detail = readErrorRecord(err, 'detail');
+        if (detail === undefined)
+            return undefined;
+        const event = readOwnNonEmptyString(detail, 'event');
+        const alias = readOwnNonEmptyString(detail, 'alias');
+        const canonical = readOwnNonEmptyString(detail, 'canonical');
+        if (event === undefined || alias === undefined || canonical === undefined)
+            return undefined;
+        return Object.freeze({ event, alias, canonical });
+    }
+    catch {
+        return undefined;
+    }
+}

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, or the last one was unreadable)';
+        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';