@sema-agent/client-core 0.105.0 → 0.107.0

package/dist/sessionRowTag.d.ts

@@ -20,5 +20,9 @@ export type SessionRowPatchRefusal = {
 } | {
     readonly kind: 'tag-unsupported';
 };
+export interface SessionRowUnreadable {
+    readonly errorCode?: string;
+}
+export declare function sessionRowUnreadableOf(row: object | null | undefined): SessionRowUnreadable | undefined;
 export declare function sessionRowTagOf(row: object | null | undefined): string | undefined;
 export declare function sessionRowPatchRefusalOf(error: {} | null | undefined, sent: Readonly<SessionRowPatchFields> | null | undefined): SessionRowPatchRefusal | null;

package/dist/sessionRowTag.js

@@ -8,6 +8,24 @@ function ownData(v, key) {
         return undefined;
     return guardedRead(() => readOwnDataValue(v, key));
 }
+export function sessionRowUnreadableOf(row) {
+    try {
+        const marker = ownData(row, 'unreadable');
+        if (!isPlainMarker(marker))
+            return undefined;
+        const code = ownData(marker, 'errorCode');
+        return Object.freeze(typeof code === 'string' && code.length > 0 ? { errorCode: code } : {});
+    }
+    catch {
+        return undefined;
+    }
+}
+function isPlainMarker(v) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return false;
+    const proto = Object.getPrototypeOf(v);
+    return proto === null || (typeof proto === 'object' && Object.getPrototypeOf(proto) === null);
+}
 export function sessionRowTagOf(row) {
     const v = ownData(row, 'rowTag');
     return typeof v === 'string' && v.length > 0 ? v : undefined;

package/dist/settingsLayerAdmission.d.ts

@@ -1,4 +1,5 @@
 import type { HostSettingsLayer, WorkspaceTrustState } from './hostSettingsSource.js';
+export declare function layerAdmissionReading(trust: WorkspaceTrustState | 'unreadable'): WorkspaceTrustState;
 export declare function layerAdmissionWord(layer: HostSettingsLayer, trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): string;
 export declare function layerAdmitted(layer: HostSettingsLayer, trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): boolean;
 export declare function admittedLayers<L extends HostSettingsLayer>(layers: readonly L[], trust: WorkspaceTrustState | 'unreadable', category: string, member?: string): readonly L[];

package/dist/settingsLayerAdmission.js

@@ -1,8 +1,11 @@
 import { SETTINGS_LAYER_ADMISSION } from './generated/settingsSchemaFns.js';
 const TRUST_UNREADABLE_READING = 'declined';
 const ADMITTED = 'admitted';
+export function layerAdmissionReading(trust) {
+    return trust === 'unreadable' ? TRUST_UNREADABLE_READING : trust;
+}
 function layerAdmissionOf(layer, trust, category, member) {
-    const reading = trust === 'unreadable' ? TRUST_UNREADABLE_READING : trust;
+    const reading = layerAdmissionReading(trust);
     return member === undefined ? SETTINGS_LAYER_ADMISSION(layer, reading, category) : SETTINGS_LAYER_ADMISSION(layer, reading, category, member);
 }
 export function layerAdmissionWord(layer, trust, category, member) {

package/dist/toolResult.js

@@ -28,7 +28,7 @@ export const PROTOCOL_MARKERS = {
     delegationTrailer: 'Verify this result before concluding. If it leaves more to do, continue or delegate again.',
     delegationTrailerFork: 'Verify this result before concluding. If it leaves more to do, continue the work yourself or fork again.',
     delegationFieldLine: /^(status|error|error_kind|observer|stats|worktree):(?: ([^\r\u2028\u2029\u0085]*))?/,
-    taskOutputLabel: /^TaskOutput\s+(\S+)$/,
+    taskOutputLabel: /^(?:TaskOutput|task)\s+(\S+)$/,
     taskOutputStatus: /^status:\s*(.+)$/m,
     taskOutputHeadSlots: /^(\r?\n)(?:(state: ([^\r\n\u2028\u2029\u0085]*)(?:\r?\n|$)))?(?:(error: ([^\r\n\u2028\u2029\u0085]*)(?:\r?\n|$)))?/,
     taskOutputResultNote: /^--- result \(([^)\n]*)\) ---/,

package/dist/wireRefusalCopy.d.ts

@@ -1,4 +1,4 @@
-import { FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { CONFLICT_SESSION_ARCHIVE_STAMPED, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import type { TaskRequestLike } from './request/taskRequest.js';
 import type { UiLanguage } from './env/uiLanguage.js';
 export declare const CONFLICT_APPROVAL_SETTLED = "conflict.approval_settled";
@@ -139,6 +139,11 @@ export interface AutonomyLaneRefusalDetail {
 }
 export declare function autonomyLaneRefusalFromError(err: unknown): AutonomyLaneRefusalDetail | null;
 export declare function autonomyLaneRefusalContent(lang?: UiLanguage): string;
+export interface SessionArchiveStampedDetail {
+    readonly code: typeof CONFLICT_SESSION_ARCHIVE_STAMPED;
+}
+export declare function sessionArchiveStampedFromError(err: {} | null | undefined): SessionArchiveStampedDetail | null;
+export declare function sessionArchiveStampedContent(lang?: UiLanguage): string;
 export interface UnsupportedRuleRefusalProblem {
     readonly code: string;
     readonly field?: string;

package/dist/wireRefusalCopy.js

@@ -1,9 +1,10 @@
 import { PROTOCOL_ERROR_NAME, REFUSAL_PROBLEMS_READ_MAX, THROWN_SLOT_UNREADABLE, effectiveWireCodeReading, isSlotCarrier, protocolErrorNameOf, readErrorNumber, readErrorRecord, readErrorStrictStringList, readErrorString, readErrorStringList, readRefusalField, readThrownSlot, readThrownStatusSlot } from './wireFailureShape.js';
 import { appendOwnElement, guardedRead, readOwnDataValue, readOwnNonEmptyString } from './ownKey.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, CONFLICT_SESSION_ARCHIVE_STAMPED, FLEET_LEASE_UNAVAILABLE, REQUEST_AUTONOMY_LANE_REFUSED, REQUEST_FIELD_CONFLICT, RESUME_OUTCOME_INVALID, USAGE_WINDOW_EXHAUSTED, USER_ATTACHMENT_INVALID_ERROR_CODE, USER_INVOKED_SKILL_UNKNOWN_ERROR_CODE } from './engineErrorCodes.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { CORE_TOOL_DECLARATION_CODES } from './generated/engineFactTables.js';
+import { SETTINGS_ECHO_CALLER_TEXT } from './generated/settingsSchemaFns.js';
 import { PERMISSION_RULE_ISSUE_CODES, permissionRuleIssueDetail } from './permissionRuleIssue.js';
 import { ruleRefusalListText } from './ruleRefusalSentence.js';
 import { msg, renderMessage } from './i18n/translate.js';
@@ -579,11 +580,6 @@ export function bodyShapeRefusalFromError(err) {
     }
 }
 const SETTINGS_PERMISSIONS_PREFIX = 'permissions.';
-const ECHO_MAX_CHARS = 64;
-function echoedKeyName(key) {
-    const clean = key.replace(/[\u0000-\u001f\u007f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, '');
-    return clean.length > ECHO_MAX_CHARS ? `${clean.slice(0, ECHO_MAX_CHARS)}…` : clean;
-}
 function hasCustomJson(v) {
     return typeof v === 'object' && v !== null && typeof v.toJSON === 'function';
 }
@@ -615,7 +611,7 @@ function echoMatch(bag, prefix, echo) {
     }
     let state = 'absent';
     for (const name of names) {
-        if (prefix + echoedKeyName(name) !== echo)
+        if (prefix + SETTINGS_ECHO_CALLER_TEXT(name) !== echo)
             continue;
         const s = sentValue(bag, name).state;
         if (s === 'sent')
@@ -813,6 +809,12 @@ export function autonomyLaneRefusalFromError(err) {
 export function autonomyLaneRefusalContent(lang) {
     return renderMessage(msg('notice.wireRefusal.autonomyLane'), lang);
 }
+export function sessionArchiveStampedFromError(err) {
+    return effectiveWireErrorCode(err) === CONFLICT_SESSION_ARCHIVE_STAMPED ? { code: CONFLICT_SESSION_ARCHIVE_STAMPED } : null;
+}
+export function sessionArchiveStampedContent(lang) {
+    return renderMessage(msg('notice.wireRefusal.sessionArchiveStamped'), lang);
+}
 const REQUEST_UNPROCESSABLE = 'request.unprocessable';
 const UNSUPPORTED_RULE_PROBLEMS_MAX = REFUSAL_PROBLEMS_READ_MAX;
 const nonEmptyString = (v) => (typeof v === 'string' && v !== '' ? v : undefined);