@sema-agent/client-core 0.104.1 → 0.106.0

package/dist/reattachWindow.js

@@ -1,5 +1,6 @@
 import { usableClockMs } from './clockReading.js';
 import { readThrownSlot, THROWN_SLOT_UNREADABLE } from './wireFailureShape.js';
+import { isReattachBreak, mintRunNotFollowed } from './runFollow.js';
 export const REATTACH_WINDOW_MS = 300_000;
 export const REATTACH_BACKOFF_START_MS = 1_000;
 export const REATTACH_BACKOFF_CAP_MS = 30_000;
@@ -25,15 +26,37 @@ export function reattachBackoffMs(attempt, tuning) {
     const raw = startMs * 2 ** (attempt - 1);
     return Number.isFinite(raw) ? Math.min(raw, capMs) : capMs;
 }
-export function reattachWindowOpen(nowMs, tuning) {
+const isRunHandle = (v) => typeof v === 'string' && v !== '';
+export function reattachWindowOpen(nowMs, tuning, runId) {
     const t = tuned(tuning);
     const start = usableClockMs(nowMs) ?? Number.NaN;
-    return Object.freeze({ enteredAtMs: start, deadlineMs: start + t.windowMs, attempt: 0, consecutiveNotFound: 0, notFoundConfirmed: false, tuning: Object.freeze(t) });
+    return Object.freeze({
+        enteredAtMs: start,
+        deadlineMs: start + t.windowMs,
+        attempt: 0,
+        consecutiveNotFound: 0,
+        notFoundConfirmed: false,
+        tuning: Object.freeze(t),
+        ...(isRunHandle(runId) ? { runId } : {}),
+    });
 }
 const step = (state, decision) => Object.freeze({ state, decision });
-const exhausted = (state) => step(state, Object.freeze({ action: 'window-exhausted' }));
+const runOf = (state) => {
+    const v = readThrownSlot(state, 'runId', 'data');
+    return isRunHandle(v) ? v : undefined;
+};
+const exhausted = (state) => {
+    const brk = readThrownSlot(state, 'lastBreak', 'data');
+    return step(state, Object.freeze({ action: 'window-exhausted', notFollowed: mintRunNotFollowed('reattach_exhausted', runOf(state), isReattachBreak(brk) ? brk : undefined) }));
+};
+const badInput = (state, runId) => step(state, Object.freeze({ action: 'window-exhausted', notFollowed: mintRunNotFollowed('bad_input', runId) }));
 const cont = (state, notFoundConfirmed = false) => step(state, Object.freeze({ action: 'continue', notFoundConfirmed }));
-const next = (state, patch) => Object.freeze({ ...state, ...patch });
+const next = (state, patch, lastBreak) => {
+    if (lastBreak === undefined)
+        return Object.freeze({ ...state, ...patch });
+    const { lastBreak: _previous, ...rest } = state;
+    return Object.freeze(lastBreak.to === undefined ? { ...rest, ...patch } : { ...rest, ...patch, lastBreak: lastBreak.to });
+};
 const isCount = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
 function validState(s) {
     if (typeof s !== 'object' || s === null)
@@ -42,18 +65,20 @@ function validState(s) {
     return typeof o.enteredAtMs === 'number' && typeof o.deadlineMs === 'number' && isCount(o.attempt) && isCount(o.consecutiveNotFound) && typeof o.notFoundConfirmed === 'boolean' && typeof o.tuning === 'object' && o.tuning !== null;
 }
 export function reattachWindowStep(state, event, nowMs) {
+    let windowRun;
     try {
+        windowRun = runOf(state);
         if (!validState(state))
-            return exhausted(reattachWindowOpen(Number.NaN));
+            return badInput(reattachWindowOpen(Number.NaN, undefined, windowRun), windowRun);
         if (typeof event !== 'object' || event === null)
             return cont(state);
         const type = event.type;
         const result = event.result;
         const serverRetryAfterMs = event.serverRetryAfterMs;
         if (type === 'new-segment')
-            return cont(reattachWindowOpen(nowMs, state.tuning));
-        if (usableClockMs(nowMs) === null || !Number.isFinite(state.deadlineMs))
-            return exhausted(state);
+            return cont(reattachWindowOpen(nowMs, state.tuning, windowRun));
+        if (usableClockMs(nowMs) === null || usableClockMs(state.enteredAtMs) === null || !Number.isFinite(state.deadlineMs))
+            return badInput(state, windowRun);
         switch (type) {
             case 'attempt':
                 return nowMs < state.deadlineMs ? cont(next(state, { attempt: state.attempt + 1 })) : exhausted(state);
@@ -70,18 +95,25 @@ export function reattachWindowStep(state, event, nowMs) {
             case 'tail-frame':
                 return cont(next(state, { consecutiveNotFound: 0, notFoundConfirmed: false }));
             case 'tail-refused-404':
-                return state.notFoundConfirmed ? step(state, Object.freeze({ action: 'run-unknown', confirmations: state.consecutiveNotFound })) : cont(state);
+                return state.notFoundConfirmed
+                    ? step(state, Object.freeze({ action: 'run-unknown', confirmations: state.consecutiveNotFound, notFollowed: mintRunNotFollowed('run_unknown', windowRun) }))
+                    : cont(state);
             case 'backoff': {
-                const own = reattachBackoffMs(state.attempt, state.tuning);
+                const brkRead = readThrownSlot(event, 'break');
+                const brk = isReattachBreak(brkRead) ? brkRead : undefined;
+                const handoffRead = readThrownSlot(event, 'runId');
+                const handoff = isRunHandle(handoffRead) && handoffRead !== windowRun ? handoffRead : undefined;
+                const moved = next(state, handoff !== undefined ? { runId: handoff, consecutiveNotFound: 0, notFoundConfirmed: false } : {}, { to: brk });
+                const own = reattachBackoffMs(moved.attempt, moved.tuning);
                 const delay = typeof serverRetryAfterMs === 'number' && Number.isFinite(serverRetryAfterMs) && serverRetryAfterMs > 0 ? Math.max(own, serverRetryAfterMs) : own;
-                return nowMs + delay >= state.deadlineMs ? exhausted(state) : step(state, Object.freeze({ action: 'wait', afterMs: delay }));
+                return nowMs + delay >= moved.deadlineMs ? exhausted(moved) : step(moved, Object.freeze({ action: 'wait', afterMs: delay }));
             }
             default:
                 return cont(state);
         }
     }
     catch {
-        return exhausted(reattachWindowOpen(Number.NaN));
+        return badInput(reattachWindowOpen(Number.NaN, undefined, windowRun), windowRun);
     }
 }
 export function poisonFrameInitial() {

package/dist/replayBody.d.ts

@@ -1,14 +1,15 @@
-export interface ReplayRowView {
-    readonly status?: string;
-    readonly errorCode?: string;
-    readonly error?: string;
+export interface RunReceiptView {
+    readonly taskId?: string;
     readonly sessionId?: string;
+    readonly status?: string;
 }
 export interface DoneResultView {
     readonly replay: boolean;
-    readonly engine: unknown;
-    readonly row?: ReplayRowView;
+    readonly receipt: boolean;
+    readonly body: unknown;
 }
+export declare function terminalLayerOf<T>(carrier: T): T | object;
+export declare function runRowSentenceOf<T>(carrier: T): string | undefined;
 export declare function doneResultView(result: unknown): DoneResultView;
 export declare function isReplayedTerminal(frame: object | null | undefined): boolean;
 export declare function isReplayMarked(message: object | null | undefined): boolean;

package/dist/replayBody.js

@@ -11,18 +11,73 @@ function guardedString(o, k) {
     const v = guarded(o, k);
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+function guardedIn(o, k) {
+    try {
+        return k in o;
+    }
+    catch {
+        return undefined;
+    }
+}
+function carriesEngineResult(o) {
+    const stats = guardedIn(o, 'stats');
+    const terminal = guardedIn(o, 'terminal');
+    if (stats === true || terminal === true)
+        return true;
+    return stats === false && terminal === false ? false : undefined;
+}
+function engineResultLayerOf(carrier) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null || Array.isArray(carrier))
+            return undefined;
+        const own = carriesEngineResult(carrier);
+        if (own !== false)
+            return own === true ? carrier : undefined;
+        const nested = guarded(carrier, 'result');
+        if (typeof nested !== 'object' || nested === null || Array.isArray(nested))
+            return undefined;
+        return carriesEngineResult(nested) === true ? nested : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRunReceiptShape(o) {
+    return guardedIn(o, 'activeTaskId') === false && guardedIn(o, 'taskId') === true;
+}
+export function terminalLayerOf(carrier) {
+    return engineResultLayerOf(carrier) ?? carrier;
+}
+export function runRowSentenceOf(carrier) {
+    try {
+        if (typeof carrier !== 'object' || carrier === null || Array.isArray(carrier))
+            return undefined;
+        if (engineResultLayerOf(carrier) !== undefined)
+            return undefined;
+        if (!isRunReceiptShape(carrier))
+            return undefined;
+        return guardedString(carrier, 'error');
+    }
+    catch {
+        return undefined;
+    }
+}
 export function doneResultView(result) {
     if (typeof result !== 'object' || result === null || Array.isArray(result))
-        return { replay: false, engine: result };
-    if (guarded(result, 'replay') !== true)
-        return { replay: false, engine: result };
-    const row = {};
-    for (const k of ['status', 'errorCode', 'error', 'sessionId']) {
+        return { replay: false, receipt: false, body: result };
+    const replay = guarded(result, 'replay') === true;
+    const engine = engineResultLayerOf(result);
+    if (engine !== undefined)
+        return { replay, receipt: false, body: engine };
+    if (!isRunReceiptShape(result))
+        return { replay, receipt: false, body: result };
+    const view = {};
+    for (const k of ['taskId', 'sessionId', 'status']) {
         const v = guardedString(result, k);
         if (v !== undefined)
-            row[k] = v;
+            view[k] = v;
     }
-    return { replay: true, engine: guarded(result, 'result'), row };
+    return { replay, receipt: true, body: Object.freeze(view) };
 }
 export function isReplayedTerminal(frame) {
     if (frame === null || typeof frame !== 'object' || Array.isArray(frame))

package/dist/request/taskRequest.js

@@ -450,7 +450,7 @@ const resolvedSnapshotForWire = (resolved) => {
 export function hostTurnSettings(input) {
     return buildHostTurnSettings(input, { materialize: (snapshot) => resolvedSnapshotForWire(snapshot), memoryOffDeclared });
 }
-const fileRestoreRequested = (restoreFiles, rewindFilesTo, rewindFiles) => restoreFiles === true || (typeof rewindFilesTo === 'string' && rewindFilesTo.length > 0) || rewindFiles === true;
+const fileRestoreRequested = (restoreFiles, rewindFilesTo) => restoreFiles === true || (typeof rewindFilesTo === 'string' && rewindFilesTo.length > 0);
 function tightenedRequestOf(request, intake, lane) {
     const readData = (key) => {
         try {
@@ -489,10 +489,9 @@ function tightenedRequestOf(request, intake, lane) {
         if (sent.value !== FILE_HISTORY_DISABLED) {
             const restoreFiles = readData('restoreFiles');
             const rewindFilesTo = readData('rewindFilesTo');
-            const rewindFiles = readData('rewindFiles');
-            if (!restoreFiles.ok || !rewindFilesTo.ok || !rewindFiles.ok)
+            if (!restoreFiles.ok || !rewindFilesTo.ok)
                 return unjudged;
-            if (fileRestoreRequested(restoreFiles.value, rewindFilesTo.value, rewindFiles.value))
+            if (fileRestoreRequested(restoreFiles.value, rewindFilesTo.value))
                 return { kind: 'refuse', notice: hostFileHistoryRestoreNotice() };
             add.fileHistory = FILE_HISTORY_DISABLED;
             appendOwnElement(tightened, 'fileHistory');

package/dist/ruleCompileVerdict.d.ts

@@ -25,5 +25,3 @@ export type DenyEntryReading = {
     readonly kind: 'unknown';
 };
 export declare function denyEntryReading(rule: string): DenyEntryReading;
-export declare const DOMAIN_TIGHTEN_HONORED_FROM = "7.135.0";
-export declare function tightenEntryNeverMatches(rule: string, serverVersion: string | undefined): boolean;

package/dist/ruleCompileVerdict.js

@@ -1,6 +1,5 @@
 import { readRuleEntry, validatePermissionRules } from './coreValuePorts.js';
 import { guardedRead, readOwnDataValue } from './ownKey.js';
-import { engineVersionTier } from './supportFloor.js';
 const RULE_COMPILE_ROOT = '/';
 function issueText(issue, key) {
     try {
@@ -73,33 +72,3 @@ export function denyEntryReading(rule) {
         return { kind: 'unknown' };
     }
 }
-function readsAsDomainSpelling(rule) {
-    try {
-        const reading = readRuleEntry(rule, 'allow');
-        if (typeof reading !== 'object' || reading === null)
-            return false;
-        if (readOwnDataValue(reading, 'kind') !== 'row')
-            return false;
-        const compiled = readOwnDataValue(reading, 'compiled');
-        if (typeof compiled !== 'object' || compiled === null)
-            return false;
-        return readOwnDataValue(compiled, 'kind') === 'domain';
-    }
-    catch {
-        return false;
-    }
-}
-export const DOMAIN_TIGHTEN_HONORED_FROM = '7.135.0';
-function targetLeavesDomainTightenInert(serverVersion) {
-    return engineVersionTier(serverVersion) === 'engine' && engineVersionTier(serverVersion, DOMAIN_TIGHTEN_HONORED_FROM) === 'legacy';
-}
-export function tightenEntryNeverMatches(rule, serverVersion) {
-    if (!targetLeavesDomainTightenInert(serverVersion))
-        return false;
-    const r = denyEntryReading(rule);
-    if (r.kind !== 'inert' || r.reason !== 'content_unsupported')
-        return false;
-    if (!readsAsDomainSpelling(rule))
-        return false;
-    return ruleCompileVerdict(rule, 'deny').kind === 'compiles';
-}

package/dist/ruleRefusalSentence.js

@@ -10,7 +10,6 @@ const CLASS_OF_REASON = Object.freeze({
     home_relative_path: 'homePath',
     compile_refused: 'compile',
     paren_in_tool_name: 'compile',
-    content_form_never_matches: 'neverMatches',
 });
 function reasonOf(row, lang) {
     const cls = typeof row.reason === 'string' && Object.hasOwn(CLASS_OF_REASON, row.reason) ? CLASS_OF_REASON[row.reason] : undefined;
@@ -18,8 +17,6 @@ function reasonOf(row, lang) {
         return renderMessage(msg('rules.refusal.reason.toolName'), lang);
     if (cls === 'homePath')
         return renderMessage(msg('rules.refusal.reason.homePath'), lang);
-    if (cls === 'neverMatches')
-        return renderMessage(msg('rules.refusal.reason.neverMatches'), lang);
     if (cls === 'compile')
         return permissionRuleIssueDetail(row.code, row.message, row.rule, lang);
     return undefined;

package/dist/runFollow.d.ts

@@ -0,0 +1,30 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+import { type MessageRef } from './i18n/translate.js';
+import type { ReattachEvent } from './runReattachPolicy.js';
+export type RunNotFollowedCause = 'reattach_exhausted' | 'no_run_id' | 'bad_input' | 'run_unknown' | 'target_unconfirmed' | 'cursor_unknown';
+export type ReattachBreak = ReattachEvent['cause'];
+export type RunNotFollowed<C extends RunNotFollowedCause = RunNotFollowedCause> = C extends 'reattach_exhausted' ? RunNotFollowedExhausted : RunNotFollowedFact<C>;
+interface RunNotFollowedFact<C extends RunNotFollowedCause> {
+    readonly kind: 'not_followable';
+    readonly cause: C;
+    readonly taskId?: string;
+}
+interface RunNotFollowedExhausted extends RunNotFollowedFact<'reattach_exhausted'> {
+    readonly lastBreak?: ReattachBreak;
+}
+export declare const isReattachBreak: (v: {} | null | undefined) => v is ReattachBreak;
+export declare function mintRunNotFollowed<C extends RunNotFollowedCause>(cause: C, taskId?: string, lastBreak?: ReattachBreak): RunNotFollowed<C>;
+export declare function registerRunNotFollowed(thrown: object, fact: RunNotFollowed): void;
+export declare function runNotFollowedOf(err: {} | null | undefined): RunNotFollowed | undefined;
+interface NoticeParts {
+    readonly reason: MessageRef;
+    readonly ending: MessageRef | '';
+    readonly exit: MessageRef | '';
+}
+export declare function runNotFollowedHeadRef(taskId: string | undefined, parts: NoticeParts): MessageRef;
+export declare function runNotFollowedReasonRef(cause: RunNotFollowedCause, lastBreak?: ReattachBreak): MessageRef;
+export declare function runNotFollowedEndingUnknownRef(): MessageRef;
+export declare function runNotFollowedExitRef(cause: RunNotFollowedCause): MessageRef | '';
+export declare function runNotFollowedNoticeRef(fact: RunNotFollowed): MessageRef;
+export declare function runNotFollowedNotice(fact: RunNotFollowed, lang?: UiLanguage): string;
+export {};

package/dist/runFollow.js

@@ -0,0 +1,117 @@
+import { msg, renderMessage } from './i18n/translate.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+const RUN_NOT_FOLLOWED_CAUSES = Object.freeze(['reattach_exhausted', 'no_run_id', 'bad_input', 'run_unknown', 'target_unconfirmed', 'cursor_unknown']);
+const _causesPin = true;
+void _causesPin;
+const REATTACH_BREAKS = Object.freeze(['connection_lost', 'stream_cap', 'stream_draining']);
+const _breaksPin = true;
+void _breaksPin;
+const isCause = (v) => RUN_NOT_FOLLOWED_CAUSES.includes(v);
+export const isReattachBreak = (v) => REATTACH_BREAKS.includes(v);
+export function mintRunNotFollowed(cause, taskId, lastBreak) {
+    const c = isCause(cause) ? cause : 'bad_input';
+    const run = typeof taskId === 'string' && taskId !== '' ? { taskId } : {};
+    const fact = c === 'reattach_exhausted' ? { kind: 'not_followable', cause: c, ...run, ...(isReattachBreak(lastBreak) ? { lastBreak } : {}) } : { kind: 'not_followable', cause: c, ...run };
+    return Object.freeze(fact);
+}
+const notFollowedByThrown = new WeakMap();
+export function registerRunNotFollowed(thrown, fact) {
+    try {
+        if ((typeof thrown === 'object' && thrown !== null) || typeof thrown === 'function')
+            notFollowedByThrown.set(thrown, fact);
+    }
+    catch {
+    }
+}
+export function runNotFollowedOf(err) {
+    try {
+        if (typeof err === 'object' && err !== null)
+            return notFollowedByThrown.get(err);
+        if (typeof err === 'function')
+            return notFollowedByThrown.get(err);
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const TASK_ID_MAX = 64;
+function readFact(fact) {
+    if (typeof fact !== 'object' || fact === null)
+        return undefined;
+    if (guardedRead(() => readOwnDataValue(fact, 'kind')) !== 'not_followable')
+        return undefined;
+    const cause = guardedRead(() => readOwnDataValue(fact, 'cause'));
+    if (!isCause(cause))
+        return undefined;
+    const rawTask = guardedRead(() => readOwnDataValue(fact, 'taskId'));
+    const shown = typeof rawTask === 'string' && rawTask !== '' ? guardedRead(() => displayUntrusted(rawTask, { max: TASK_ID_MAX, blanks: true })) : undefined;
+    const brk = cause === 'reattach_exhausted' ? guardedRead(() => readOwnDataValue(fact, 'lastBreak')) : undefined;
+    return { cause, ...(shown !== undefined && shown !== '' ? { taskId: shown } : {}), ...(isReattachBreak(brk) ? { lastBreak: brk } : {}) };
+}
+export function runNotFollowedHeadRef(taskId, parts) {
+    const tail = { reason: parts.reason, ending: parts.ending, exit: parts.exit };
+    return taskId !== undefined && taskId !== '' ? msg('follow.notFollowed.headRun', { taskId, ...tail }) : msg('follow.notFollowed.headTurn', tail);
+}
+const LAST_BREAK_REASON_KEYS = Object.freeze({
+    stream_draining: 'follow.notFollowed.reason.exhaustedDraining',
+    connection_lost: 'follow.notFollowed.reason.exhaustedConnectionLost',
+    stream_cap: 'follow.notFollowed.reason.exhaustedStreamCap',
+});
+export function runNotFollowedReasonRef(cause, lastBreak) {
+    switch (cause) {
+        case 'reattach_exhausted':
+            return msg(lastBreak !== undefined && isReattachBreak(lastBreak) ? LAST_BREAK_REASON_KEYS[lastBreak] : 'follow.notFollowed.reason.exhausted');
+        case 'bad_input':
+            return msg('follow.notFollowed.reason.badInput');
+        case 'no_run_id':
+            return msg('follow.notFollowed.reason.noRunId');
+        case 'run_unknown':
+            return msg('follow.notFollowed.reason.runUnknown');
+        default:
+            return msg('follow.notFollowed.reason.unspecified');
+    }
+}
+export function runNotFollowedEndingUnknownRef() {
+    return msg('follow.notFollowed.endingUnknown');
+}
+export function runNotFollowedExitRef(cause) {
+    switch (cause) {
+        case 'reattach_exhausted':
+        case 'bad_input':
+            return msg('follow.notFollowed.exit.reattach');
+        case 'no_run_id':
+            return msg('follow.notFollowed.exit.checkRuns');
+        case 'run_unknown':
+            return msg('follow.notFollowed.exit.runUnknown');
+        default:
+            return '';
+    }
+}
+function neutralNoticeRef() {
+    return runNotFollowedHeadRef(undefined, { reason: msg('follow.notFollowed.reason.unspecified'), ending: runNotFollowedEndingUnknownRef(), exit: '' });
+}
+export function runNotFollowedNoticeRef(fact) {
+    try {
+        const r = readFact(fact);
+        if (r === undefined)
+            return neutralNoticeRef();
+        return runNotFollowedHeadRef(r.taskId, {
+            reason: runNotFollowedReasonRef(r.cause, r.lastBreak),
+            ending: r.cause === 'run_unknown' ? '' : runNotFollowedEndingUnknownRef(),
+            exit: runNotFollowedExitRef(r.cause),
+        });
+    }
+    catch {
+        return neutralNoticeRef();
+    }
+}
+export function runNotFollowedNotice(fact, lang) {
+    try {
+        return renderMessage(runNotFollowedNoticeRef(fact), lang);
+    }
+    catch {
+        return renderMessage(neutralNoticeRef(), lang);
+    }
+}

package/dist/runLedgerSnapshot.d.ts

@@ -0,0 +1,20 @@
+export interface RunLedgerSnapshot<F = never> {
+    readonly highWater: string;
+    readonly openToolStart?: object;
+    readonly folded?: F;
+}
+export interface RunLedgerFold<F> {
+    readonly init: () => F;
+    readonly step: (acc: F, ev: object) => F;
+    readonly strictOrder?: boolean;
+    readonly agree?: (a: F, b: F) => boolean;
+    readonly substantive?: (ev: object) => boolean;
+}
+export interface RunLedgerSnapshotDeps<F = never> {
+    readonly isParked: (taskId: string, signal: AbortSignal) => Promise<boolean>;
+    readonly frames: (taskId: string, signal: AbortSignal) => AsyncIterable<object>;
+    readonly budgetMs?: number;
+    readonly log?: (msg: string) => void;
+    readonly fold?: RunLedgerFold<F>;
+}
+export declare function readRunLedgerSnapshot<F = never>(taskId: string, callId: string | undefined, deps: RunLedgerSnapshotDeps<F>, signal?: AbortSignal): Promise<RunLedgerSnapshot<F> | null>;