@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/resultFrameKeys.d.ts

@@ -2,3 +2,4 @@ export declare function resultErrorCodeOf(frame: unknown): string | undefined;
 export declare function resultSelectedModelOf(frame: unknown): string | undefined;
 export declare function resultSalvagedResultOf(frame: unknown): string | undefined;
 export declare function resultParkFailedReasonOf(frame: unknown): string | undefined;
+export declare function resultErrorCodeInTextOf(frame: object | null | undefined): true | undefined;

package/dist/resultFrameKeys.js

@@ -1,4 +1,4 @@
-import { readFrameStringKey } from './ownKey.js';
+import { readFrameStringKey, readFrameTrueMark } from './ownKey.js';
 export function resultErrorCodeOf(frame) {
     return readFrameStringKey(frame, '_sema_error_code');
 }
@@ -11,3 +11,6 @@ export function resultSalvagedResultOf(frame) {
 export function resultParkFailedReasonOf(frame) {
     return readFrameStringKey(frame, '_sema_park_failed_reason');
 }
+export function resultErrorCodeInTextOf(frame) {
+    return readFrameTrueMark(frame, '_sema_error_code_in_text') ? true : undefined;
+}

package/dist/resumeRefusalCopy.d.ts

@@ -48,7 +48,7 @@ export interface ParkedResumeStartupDetail {
     denyStaysOpen: true;
 }
 declare const RESUME_CAUSE_CORE_AHEAD: readonly ["transcript_corrupt"];
-type ResumeCauseCoreAhead = (typeof RESUME_CAUSE_CORE_AHEAD)[number];
+type ResumeCauseCoreAhead = Exclude<(typeof RESUME_CAUSE_CORE_AHEAD)[number], ResumeStartupCause>;
 export declare function parkedResumeStartupFromError(err: unknown, decision?: ParkedResumeStartupDecision): ParkedResumeStartupDetail | null;
 export declare function parkedResumeStartupContent(detail: ParkedResumeStartupDetail, lang?: UiLanguage): string;
 export interface CheckpointUnsupportedVersionDetail {
@@ -69,6 +69,8 @@ export interface RefusedParkFacts {
     readonly code: RefusedParkCode;
     readonly field?: string;
     readonly stillPending?: boolean;
+    readonly blockedBy?: string;
+    readonly reason?: string;
 }
 export declare function refusedParkFromError(failure: unknown): RefusedParkFacts | null;
 export interface RefusedParkContentInput {

package/dist/resumeRefusalCopy.js

@@ -238,6 +238,7 @@ export function checkpointUnsupportedVersionContent(detail, ctx, lang) {
     return renderMessage(msg('resume.refusal.checkpoint.content', { outlet }), lang);
 }
 const REFUSED_PARK_FIELD_TOKEN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+const REFUSED_PARK_CODE_TOKEN = /^(?=.{1,128}$)[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+)*$/;
 export function refusedParkFromError(failure) {
     if (typeof failure !== 'object' || failure === null)
         return null;
@@ -258,10 +259,22 @@ export function refusedParkFromError(failure) {
     const stillPending = reading === true ? true : status === 409 && reading === false ? false : undefined;
     const rawField = code === CHECKPOINT_CONFIG_REFUSED ? readErrorString(failure, 'field') : undefined;
     const field = rawField !== undefined && REFUSED_PARK_FIELD_TOKEN.test(rawField) ? rawField : undefined;
+    let blockedBy;
+    try {
+        const b = readBlockedBy(failure);
+        blockedBy = b.kind === 'named' && REFUSED_PARK_CODE_TOKEN.test(b.code) ? b.code : undefined;
+    }
+    catch {
+        blockedBy = undefined;
+    }
+    const rawReason = readErrorString(failure, 'reason');
+    const reason = rawReason !== undefined && REFUSED_PARK_FIELD_TOKEN.test(rawReason) ? rawReason : undefined;
     return Object.freeze({
         code,
         ...(field !== undefined ? { field } : {}),
         ...(stillPending !== undefined ? { stillPending } : {}),
+        ...(blockedBy !== undefined ? { blockedBy } : {}),
+        ...(reason !== undefined ? { reason } : {}),
     });
 }
 function refusedParkShownRunId(runId) {
@@ -272,6 +285,8 @@ function refusedParkWhy(code, field) {
         case CHECKPOINT_WALLTIME_AXIS_RETIRED:
             return msg('resume.refusal.park.whyWalltime');
         case CHECKPOINT_CONFIG_REFUSED:
+            if (field === 'deps')
+                return msg('resume.refusal.park.whyDeps');
             return msg(field === 'inheritedGate' ? 'resume.refusal.park.whyInheritedGate' : 'resume.refusal.park.whyConfigRefused');
         default:
             return msg('resume.refusal.park.whyUnsupported');
@@ -284,6 +299,7 @@ export function refusedParkContent(input, lang) {
     let rawCode;
     let field;
     let stillPending;
+    let blockedBy;
     try {
         what = input.what;
         lane = input.lane;
@@ -297,21 +313,23 @@ export function refusedParkContent(input, lang) {
         rawCode = facts.code;
         field = facts.field;
         stillPending = facts.stillPending;
+        blockedBy = facts.blockedBy;
     }
     catch {
-        rawCode = field = stillPending = undefined;
+        rawCode = field = stillPending = blockedBy = undefined;
     }
     const code = rawCode === CHECKPOINT_WALLTIME_AXIS_RETIRED || rawCode === CHECKPOINT_CONFIG_REFUSED ? rawCode : CHECKPOINT_UNSUPPORTED_VERSION;
     const shownWhat = typeof what === 'string' && what !== '' ? capForDisplay(what, 40) : msg('resume.refusal.park.whatDefault');
     const why = refusedParkWhy(code, typeof field === 'string' ? field : undefined);
     const shownRun = refusedParkShownRunId(runId);
     const head = msg('resume.refusal.park.head', { what: shownWhat, why });
-    const configMayReturn = code === CHECKPOINT_CONFIG_REFUSED && field !== 'inheritedGate' ? msg('resume.refusal.park.configMayReturn') : '';
+    const configMayReturn = code === CHECKPOINT_CONFIG_REFUSED && field !== 'inheritedGate' ? msg(field === 'deps' ? 'resume.refusal.park.depsMayReturn' : 'resume.refusal.park.configMayReturn') : '';
     if (lane === 'print') {
+        const blocked = typeof blockedBy === 'string' && REFUSED_PARK_CODE_TOKEN.test(blockedBy) ? msg('resume.refusal.park.blockedByTail', { blockedBy }) : '';
         if (stillPending === false)
-            return renderMessage(msg('resume.refusal.park.printEnded', { head, code }), lang);
+            return renderMessage(msg('resume.refusal.park.printEnded', { head, code, blocked }), lang);
         const cancel = `POST /v1/runs/${shownRun ?? '<run id>'}/cancel`;
-        return renderMessage(msg('resume.refusal.park.printHolds', { head, configMayReturn, code, cancel }), lang);
+        return renderMessage(msg('resume.refusal.park.printHolds', { head, configMayReturn, code, cancel, blocked }), lang);
     }
     if (stillPending === false)
         return renderMessage(msg('resume.refusal.park.interactiveEnded', { head }), lang);

package/dist/retryStatus.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 export type RetryStatus = {
     kind: 'stalled';
     deadline: number;
@@ -93,6 +94,24 @@ export interface RetryStatusNotice {
     readonly recourse?: 'switch_model' | 'wait' | 'fix_request';
     readonly phase: 'retrying' | 'reconnecting' | 'waiting_first_token' | 'gave_up' | 'cleared';
 }
+export interface RetryStatusParts {
+    readonly phase: RetryStatusNotice['phase'];
+    readonly model?: string;
+    readonly condition?: string;
+    readonly resendNote?: string;
+    readonly httpStatus?: number;
+    readonly source?: string;
+    readonly attempt?: number;
+    readonly maxAttempts?: number;
+    readonly elapsedMs?: number;
+    readonly timeoutMs?: number;
+    readonly retryAtMs?: number;
+    readonly detail?: string;
+    readonly recourse?: RetryStatusNotice['recourse'];
+}
+export declare function retryStatusParts(status: RetryStatus | null, ctx?: {
+    readonly modelName?: string;
+}): RetryStatusParts;
 export declare function retryStatusNotice(status: RetryStatus | null, ctx?: {
     readonly modelName?: string;
 }): RetryStatusNotice;
@@ -116,4 +135,11 @@ export interface ApiErrorNoticeCtx {
 }
 export declare function apiErrorFactsOfRow(row: ApiErrorRowLike | null | undefined): ApiErrorRowFacts;
 export declare function apiErrorNotice(facts: ApiErrorRowFacts | null | undefined, ctx?: ApiErrorNoticeCtx): ApiErrorNotice | undefined;
+export type ResultWayOutWord = NonNullable<ApiErrorNotice['recourse']>;
+export interface ResultWayOut {
+    readonly word: ResultWayOutWord;
+    readonly keySource?: string;
+}
+export declare function resultWayOutOf(frame: object | null | undefined): ResultWayOut | undefined;
+export declare function wayOutSentence(wayOut: ResultWayOut | null | undefined, lang?: UiLanguage): string | undefined;
 export {};

package/dist/retryStatus.js

@@ -1,5 +1,7 @@
 import { displayUntrusted } from './displayUntrusted.js';
 import { guardedRead, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { conditionRecourseOf, isHttpStatus, isServiceSideStatus, terminalRecourseOf } from './providerRejection.js';
 export const BRAIN_STATUS_PHASES = [
     'rate_limited',
     'retrying',
@@ -121,10 +123,10 @@ export function retryStatusFromArm(arm, nowMs) {
 }
 const WAIT_SWITCH_FRACTION = 0.5;
 const CONDITION_READINGS = Object.freeze({
-    quota_exhausted: { clause: 'this account cannot be served by the model service until someone acts or its usage window resets', recourse: 'switch_model' },
-    throttled: { clause: 'the model service is rate limiting requests, which clears on its own', recourse: 'switch_model' },
-    overloaded: { clause: 'the model service is overloaded', recourse: 'switch_model' },
-    stop_other: { clause: 'the model service refused this request', resendNote: 'resending will not change it', recourse: 'fix_request' },
+    quota_exhausted: { clause: 'this account cannot be served by the model service until someone acts or its usage window resets' },
+    throttled: { clause: 'the model service is rate limiting requests, which clears on its own' },
+    overloaded: { clause: 'the model service is overloaded' },
+    stop_other: { clause: 'the model service refused this request', resendNote: 'resending will not change it' },
     unknown: null,
 });
 function conditionReadingOf(word) {
@@ -151,7 +153,7 @@ function noticeCount(n) {
     return n !== undefined && Number.isInteger(n) && n >= 1 ? n : undefined;
 }
 function noticeHttp(n) {
-    return n !== undefined && Number.isInteger(n) && n >= 100 && n <= 999 ? n : undefined;
+    return isHttpStatus(n) ? n : undefined;
 }
 function spanText(ms) {
     const total = Math.floor(ms / 1000);
@@ -172,11 +174,38 @@ function noticeAttemptTail(attempt, maxRetries) {
 function sealNotice(line, phase, recourse) {
     return Object.freeze(recourse === undefined ? { line, phase } : { line, recourse, phase });
 }
-export function retryStatusNotice(status, ctx) {
+const SOURCE_PHRASES = Object.freeze({
+    unified_header: 'notice.retry.source.unifiedHeader',
+    provider_code: 'notice.retry.source.providerCode',
+    status: 'notice.retry.source.status',
+});
+function sourcePhraseOf(word) {
+    if (word === undefined || !Object.hasOwn(SOURCE_PHRASES, word))
+        return undefined;
+    return renderMessage(msg(SOURCE_PHRASES[word]));
+}
+function sealParts(p) {
+    return Object.freeze({
+        phase: p.phase,
+        ...(p.model !== undefined ? { model: p.model } : {}),
+        ...(p.condition !== undefined ? { condition: p.condition } : {}),
+        ...(p.resendNote !== undefined ? { resendNote: p.resendNote } : {}),
+        ...(p.httpStatus !== undefined ? { httpStatus: p.httpStatus } : {}),
+        ...(p.source !== undefined ? { source: p.source } : {}),
+        ...(p.attempt !== undefined ? { attempt: p.attempt } : {}),
+        ...(p.maxAttempts !== undefined ? { maxAttempts: p.maxAttempts } : {}),
+        ...(p.elapsedMs !== undefined ? { elapsedMs: p.elapsedMs } : {}),
+        ...(p.timeoutMs !== undefined ? { timeoutMs: p.timeoutMs } : {}),
+        ...(p.retryAtMs !== undefined ? { retryAtMs: p.retryAtMs } : {}),
+        ...(p.detail !== undefined ? { detail: p.detail } : {}),
+        ...(p.recourse !== undefined ? { recourse: p.recourse } : {}),
+    });
+}
+export function retryStatusParts(status, ctx) {
     const modelName = washedText(noticeText(ctx, 'modelName'))?.trim();
-    const prefix = modelName === undefined || modelName === '' ? '' : `${modelName}: `;
+    const model = modelName === undefined || modelName === '' ? undefined : modelName;
     if (status === null)
-        return sealNotice('', 'cleared', undefined);
+        return sealParts({ phase: 'cleared' });
     const armWord = noticeText(status, 'kind');
     const kind = armWord === 'stalled' || armWord === 'waiting' ? armWord : 'error';
     if (kind === 'waiting') {
@@ -184,41 +213,71 @@ export function retryStatusNotice(status, ctx) {
         const timeoutRaw = noticeNumber(status, 'timeoutMs');
         const elapsed = elapsedRaw !== undefined && elapsedRaw >= 0 && elapsedRaw <= Number.MAX_SAFE_INTEGER ? elapsedRaw : undefined;
         const ceiling = timeoutRaw !== undefined && timeoutRaw > 0 && timeoutRaw <= Number.MAX_SAFE_INTEGER ? timeoutRaw : undefined;
-        const progress = [...(elapsed === undefined ? [] : [`${spanText(elapsed)} so far`]), ...(ceiling === undefined ? [] : [`limit ${spanText(ceiling)}`])];
-        const offerSwitch = prefix !== '' && elapsed !== undefined && ceiling !== undefined && elapsed >= ceiling * WAIT_SWITCH_FRACTION;
-        const text = `${prefix}Waiting for the model's first token${progress.length === 0 ? '' : ` — ${progress.join(', ')}`}${offerSwitch ? '; keep waiting or switch model' : ''}`;
-        return sealNotice(text, 'waiting_first_token', offerSwitch ? 'switch_model' : 'wait');
+        const offerSwitch = model !== undefined && elapsed !== undefined && ceiling !== undefined && elapsed >= ceiling * WAIT_SWITCH_FRACTION;
+        return sealParts({ phase: 'waiting_first_token', model, elapsedMs: elapsed, timeoutMs: ceiling, recourse: offerSwitch ? 'switch_model' : 'wait' });
     }
     const terminal = kind === 'error' && noticeValue(status, 'terminal') === true;
-    const reading = conditionReadingOf(noticeText(status, 'providerCondition'));
+    const conditionWord = noticeText(status, 'providerCondition');
+    const reading = conditionReadingOf(conditionWord);
     const http = noticeHttp(noticeNumber(status, 'errorStatus'));
     const attempt = noticeCount(noticeNumber(status, 'attempt'));
     const maxRetries = noticeCount(noticeNumber(status, 'maxRetries'));
     const engineWords = kind === 'stalled' ? noticeText(status, 'detail') : noticeText(noticeValue(status, 'error'), 'formatted');
-    const httpPart = http === undefined ? '' : ` (HTTP ${http})`;
-    let first;
-    if (terminal) {
-        const after = attempt === undefined ? '' : ` after ${attempt} attempt${attempt === 1 ? '' : 's'}`;
-        const why = reading === undefined ? '' : `: ${reading.clause}${reading.resendNote === undefined ? '' : `, and ${reading.resendNote}`}`;
-        first = `Stopped${after}${why}${httpPart}`;
-    }
-    else {
-        const head = reading !== undefined ? `${reading.clause.charAt(0).toUpperCase()}${reading.clause.slice(1)}` : http !== undefined || kind === 'error' ? 'Request failed' : 'Waiting for the API response';
-        first = `${head}${httpPart} — ${kind === 'stalled' ? 'will retry' : 'retrying'}${noticeAttemptTail(attempt, maxRetries)}`;
-    }
     const note = washedText(engineWords);
-    const serviceSide = http !== undefined && (http === 429 || (http >= 500 && http <= 599));
+    const source = reading === undefined ? undefined : sourcePhraseOf(noticeText(status, 'providerConditionSource'));
+    const condition = reading === undefined ? undefined : `${reading.clause.charAt(0).toUpperCase()}${reading.clause.slice(1)}`;
+    const serviceSide = http !== undefined && isServiceSideStatus(http);
     const knownArm = armWord === 'stalled' || armWord === 'error';
     const recourse = !knownArm
         ? undefined
         : reading !== undefined
-            ? reading.recourse
+            ? conditionRecourseOf(conditionWord)
             : serviceSide
                 ? 'switch_model'
                 : !terminal
                     ? 'wait'
                     : undefined;
-    return sealNotice(`${prefix}${first}${note === undefined ? '' : ` · ${note}`}`, kind === 'stalled' ? 'reconnecting' : terminal ? 'gave_up' : 'retrying', recourse);
+    const deadlineRaw = knownArm && !terminal && noticeNumber(status, 'retryAtMs') !== undefined ? noticeNumber(status, 'deadline') : undefined;
+    const retryAtMs = deadlineRaw !== undefined && deadlineRaw > 0 ? deadlineRaw : undefined;
+    return sealParts({
+        phase: kind === 'stalled' ? 'reconnecting' : terminal ? 'gave_up' : 'retrying',
+        model,
+        condition,
+        resendNote: terminal ? reading?.resendNote : undefined,
+        httpStatus: http,
+        source,
+        attempt,
+        maxAttempts: maxRetries,
+        retryAtMs,
+        detail: note,
+        recourse,
+    });
+}
+function retryLineOfParts(parts) {
+    if (parts.phase === 'cleared')
+        return '';
+    const prefix = parts.model === undefined ? '' : `${parts.model}: `;
+    if (parts.phase === 'waiting_first_token') {
+        const progress = [...(parts.elapsedMs === undefined ? [] : [`${spanText(parts.elapsedMs)} so far`]), ...(parts.timeoutMs === undefined ? [] : [`limit ${spanText(parts.timeoutMs)}`])];
+        const offerSwitch = parts.recourse === 'switch_model';
+        return `${prefix}Waiting for the model's first token${progress.length === 0 ? '' : ` — ${progress.join(', ')}`}${offerSwitch ? '; keep waiting or switch model' : ''}`;
+    }
+    const httpPart = parts.httpStatus === undefined ? '' : ` (HTTP ${parts.httpStatus})`;
+    let first;
+    if (parts.phase === 'gave_up') {
+        const after = parts.attempt === undefined ? '' : ` after ${parts.attempt} attempt${parts.attempt === 1 ? '' : 's'}`;
+        const why = parts.condition === undefined ? '' : `: ${parts.condition.charAt(0).toLowerCase()}${parts.condition.slice(1)}${parts.resendNote === undefined ? '' : `, and ${parts.resendNote}`}`;
+        first = `Stopped${after}${why}${httpPart}`;
+    }
+    else {
+        const head = parts.condition !== undefined ? parts.condition : parts.httpStatus !== undefined || parts.phase === 'retrying' ? 'Request failed' : 'Waiting for the API response';
+        first = `${head}${httpPart} — ${parts.phase === 'reconnecting' ? 'will retry' : 'retrying'}${noticeAttemptTail(parts.attempt, parts.maxAttempts)}`;
+    }
+    return `${prefix}${first}${parts.detail === undefined ? '' : ` · ${parts.detail}`}`;
+}
+export function retryStatusNotice(status, ctx) {
+    const parts = retryStatusParts(status, ctx);
+    return sealNotice(retryLineOfParts(parts), parts.phase, parts.recourse);
 }
 const API_ERROR_PROVIDER_TEXT_MAX = 200;
 function isRecordObject(v) {
@@ -255,6 +314,52 @@ export function apiErrorNotice(facts, ctx) {
     };
     const modelName = noticeText(ctx, 'modelName');
     const notice = retryStatusNotice(terminal, modelName !== undefined ? { modelName } : undefined);
-    const recourse = status === 401 || status === 403 ? 'check_credentials' : notice.recourse;
+    const recourse = terminalRecourseOf(status, providerCondition);
     return Object.freeze(recourse === undefined ? { line: notice.line } : { line: notice.line, recourse });
 }
+const RESULT_WAY_OUT_WORDS = Object.freeze(['check_credentials', 'switch_model', 'wait', 'fix_request']);
+const _wayOutWordPins = [true, true];
+void _wayOutWordPins;
+const KEY_SOURCE_DISPLAY_MAX = 60;
+const WAY_OUT_SENTENCE_KEYS = Object.freeze({
+    check_credentials: 'notice.wayOut.checkCredentials',
+    switch_model: 'notice.wayOut.switchModel',
+    wait: 'notice.wayOut.wait',
+    fix_request: 'notice.wayOut.fixRequest',
+});
+function isResultWayOutWord(v) {
+    return typeof v === 'string' && RESULT_WAY_OUT_WORDS.includes(v);
+}
+export function resultWayOutOf(frame) {
+    try {
+        const raw = guardedRead(() => readOwnDataValue(frame, '_sema_wayOut'));
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+            return undefined;
+        const word = guardedRead(() => readOwnDataNonEmptyString(raw, 'word'));
+        if (!isResultWayOutWord(word))
+            return undefined;
+        const keySource = guardedRead(() => readOwnDataNonEmptyString(raw, 'keySource'));
+        return Object.freeze(keySource === undefined ? { word } : { word, keySource });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function wayOutSentence(wayOut, lang) {
+    try {
+        if (typeof wayOut !== 'object' || wayOut === null)
+            return undefined;
+        const word = readOwnDataNonEmptyString(wayOut, 'word');
+        if (!isResultWayOutWord(word))
+            return undefined;
+        if (word === 'check_credentials') {
+            const keySource = readOwnDataNonEmptyString(wayOut, 'keySource');
+            if (keySource !== undefined)
+                return renderMessage(msg('notice.wayOut.checkCredentialsFrom', { source: displayUntrusted(keySource, { max: KEY_SOURCE_DISPLAY_MAX }) }), lang);
+        }
+        return renderMessage(msg(WAY_OUT_SENTENCE_KEYS[word]), lang);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/rewindArchiveCapability.js

@@ -1,8 +1,8 @@
-import { engineWireTarget } from './engineWireTarget.js';
+import { engineWireTargetBaseUrl } from './engineWireTarget.js';
 import { rewindArchiveReadingAt, rewindConversationAvailability, } from './rewindArchiveReading.js';
 import { unreadableReadingDetail } from './engineCapReader.js';
 export { projectRewindArchiveCapability, rewindConversationAvailability } from './rewindArchiveReading.js';
-export function observedRewindArchive(baseUrl = engineWireTarget()?.baseUrl) {
+export function observedRewindArchive(baseUrl = engineWireTargetBaseUrl()) {
     return rewindArchiveReadingAt(baseUrl);
 }
 export function rewindCodeArchiveAvailability(reading, mode) {

package/dist/rewindEngineAction.d.ts

@@ -1,3 +1,4 @@
+import type { UiLanguage } from './env/uiLanguage.js';
 import { type RewindArchiveReading } from './rewindArchiveCapability.js';
 import { type RewindMode, type SeamRewindSpec } from './rewindWireCaps.js';
 export type RewindRestoreOption = RewindMode | 'summarize' | 'summarize_up_to' | 'nevermind';
@@ -19,3 +20,4 @@ export type RewindEngineAction = {
 };
 export declare function decideRewindEngineAction(option: RewindRestoreOption, resolved: RewindTargetResolution, reading?: RewindArchiveReading): RewindEngineAction;
 export declare function previewEngineRewind(option: RewindRestoreOption, resolved: RewindTargetResolution, reading?: RewindArchiveReading): RewindEngineAction['kind'];
+export declare function rewindConversationOnlyNotice(option: RewindRestoreOption, action: RewindEngineAction | null | undefined, lang?: UiLanguage, reading?: RewindArchiveReading): string | undefined;

package/dist/rewindEngineAction.js

@@ -1,4 +1,5 @@
-import { observedRewindArchive } from './rewindArchiveCapability.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { engineRewindRefusedNow, observedRewindArchive } from './rewindArchiveCapability.js';
 import { REWIND_MODES, rewindSpecForMode } from './rewindWireCaps.js';
 import { readOwnDataNonEmptyString, readOwnDataValue } from './ownKey.js';
 function modeOfOption(option) {
@@ -34,3 +35,24 @@ export function decideRewindEngineAction(option, resolved, reading = observedRew
 export function previewEngineRewind(option, resolved, reading = observedRewindArchive()) {
     return decideRewindEngineAction(option, resolved, reading).kind;
 }
+const UNOBSERVED_READING = { kind: 'unobserved' };
+export function rewindConversationOnlyNotice(option, action, lang, reading = observedRewindArchive()) {
+    try {
+        const mode = modeOfOption(option);
+        if (mode === undefined || rewindSpecForMode(mode, 'x', UNOBSERVED_READING).restoreFiles !== true)
+            return undefined;
+        if (typeof action !== 'object' || action === null || readOwnDataValue(action, 'kind') !== 'arm')
+            return undefined;
+        const spec = readOwnDataValue(action, 'spec');
+        if (typeof spec !== 'object' || spec === null)
+            return undefined;
+        if (readOwnDataValue(spec, 'restoreFiles') === true)
+            return undefined;
+        const codeOnlyMode = REWIND_MODES.find((m) => !carriesResumeAt(m));
+        const codeRouteDeadEnd = codeOnlyMode !== undefined && engineRewindRefusedNow(codeOnlyMode, reading);
+        return renderMessage(msg(codeRouteDeadEnd ? 'session.rewind.conversationOnly.noCodeRoute' : 'session.rewind.conversationOnly.withCodeRoute'), lang);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/rowKind.d.ts

@@ -0,0 +1,36 @@
+export declare const RUN_STOPPED_MESSAGE_PREFIX = "Run stopped";
+export declare const RUN_BLOCKED_MESSAGE_PREFIX = "Run blocked";
+export declare const PROMPT_BLOCKED_BY_HOOK_ROW_LEAD = "UserPromptSubmit operation blocked by hook";
+export declare const MODEL_OUTPUT_ERROR_PREFIX = "Model output error";
+export declare const OUTCOME_UNKNOWN_ROW_PREFIX = "Outcome unknown";
+export declare const SESSION_BUSY_ROW_LEAD = "This session is locked by an earlier run";
+export declare const SEMA_ROW_KIND_KEY = "_sema_row_kind";
+export declare const SEMA_ROW_KINDS: readonly [Readonly<{
+    kind: "api_error";
+    owner: "client-core";
+}>, Readonly<{
+    kind: "governance_stop";
+    owner: "client-core";
+}>, Readonly<{
+    kind: "model_output_error";
+    owner: "client-core";
+}>, Readonly<{
+    kind: "outcome_unknown";
+    owner: "client-core";
+}>, Readonly<{
+    kind: "session_busy";
+    owner: "client-core";
+}>, Readonly<{
+    kind: "engine_link";
+    owner: "client-core";
+}>];
+export type SemaRowKind = (typeof SEMA_ROW_KINDS)[number]['kind'];
+export declare function rowKindOf(m: object | null | undefined): SemaRowKind | undefined;
+export declare function rowKindOf<H extends string>(m: object | null | undefined, opts: {
+    readonly hostKinds: readonly H[];
+}): SemaRowKind | H | undefined;
+export declare function isSyntheticRow(m: object | null | undefined): boolean;
+export declare function legacyRowKindOfText(text: string): SemaRowKind | undefined;
+export declare function inferLegacyRowKind(m: object | null | undefined, opts?: {
+    readonly requireFlag?: boolean;
+}): SemaRowKind | undefined;

package/dist/rowKind.js

@@ -0,0 +1,97 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+export const RUN_STOPPED_MESSAGE_PREFIX = 'Run stopped';
+export const RUN_BLOCKED_MESSAGE_PREFIX = 'Run blocked';
+export const PROMPT_BLOCKED_BY_HOOK_ROW_LEAD = 'UserPromptSubmit operation blocked by hook';
+export const MODEL_OUTPUT_ERROR_PREFIX = 'Model output error';
+export const OUTCOME_UNKNOWN_ROW_PREFIX = 'Outcome unknown';
+export const SESSION_BUSY_ROW_LEAD = 'This session is locked by an earlier run';
+const API_ERROR_ROW_PREFIX = 'API Error';
+const LOGIN_API_ERROR_ROW_PREFIX = `Please run /login · ${API_ERROR_ROW_PREFIX}`;
+export const SEMA_ROW_KIND_KEY = '_sema_row_kind';
+export const SEMA_ROW_KINDS = Object.freeze([
+    Object.freeze({ kind: 'api_error', owner: 'client-core' }),
+    Object.freeze({ kind: 'governance_stop', owner: 'client-core' }),
+    Object.freeze({ kind: 'model_output_error', owner: 'client-core' }),
+    Object.freeze({ kind: 'outcome_unknown', owner: 'client-core' }),
+    Object.freeze({ kind: 'session_busy', owner: 'client-core' }),
+    Object.freeze({ kind: 'engine_link', owner: 'client-core' }),
+]);
+const KIND_WORDS = new Set(SEMA_ROW_KINDS.map((e) => e.kind));
+const ownData = (o, key) => guardedRead(() => readOwnDataValue(o, key));
+export function rowKindOf(m, opts) {
+    const v = ownData(m, SEMA_ROW_KIND_KEY);
+    if (typeof v !== 'string' || v.length === 0)
+        return undefined;
+    if (KIND_WORDS.has(v))
+        return v;
+    const hostKinds = opts === undefined ? undefined : ownData(opts, 'hostKinds');
+    if (Array.isArray(hostKinds)) {
+        try {
+            if (hostKinds.includes(v))
+                return v;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function hasSyntheticFlag(m) {
+    return ownData(m, '_sema_api_error_message') === true || ownData(m, 'isApiErrorMessage') === true;
+}
+export function isSyntheticRow(m) {
+    const v = ownData(m, SEMA_ROW_KIND_KEY);
+    if (typeof v === 'string' && v.length > 0)
+        return true;
+    return hasSyntheticFlag(m);
+}
+export function legacyRowKindOfText(text) {
+    const t = text.trimStart();
+    if (t.startsWith(API_ERROR_ROW_PREFIX) || t.startsWith(LOGIN_API_ERROR_ROW_PREFIX))
+        return 'api_error';
+    if (t.startsWith(`${RUN_STOPPED_MESSAGE_PREFIX}:`) || t.startsWith(RUN_BLOCKED_MESSAGE_PREFIX) || t.startsWith(PROMPT_BLOCKED_BY_HOOK_ROW_LEAD))
+        return 'governance_stop';
+    if (t.startsWith(`${MODEL_OUTPUT_ERROR_PREFIX}:`))
+        return 'model_output_error';
+    if (t.startsWith(`${OUTCOME_UNKNOWN_ROW_PREFIX}:`))
+        return 'outcome_unknown';
+    if (t.startsWith(SESSION_BUSY_ROW_LEAD))
+        return 'session_busy';
+    return undefined;
+}
+function singleTextOf(m) {
+    if (ownData(m, 'type') !== 'assistant')
+        return undefined;
+    const envelope = ownData(m, 'message');
+    if (typeof envelope !== 'object' || envelope === null)
+        return undefined;
+    const content = ownData(envelope, 'content');
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return undefined;
+    try {
+        if (content.length !== 1)
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    const block = ownData(content, '0');
+    if (ownData(block, 'type') !== 'text')
+        return undefined;
+    const text = ownData(block, 'text');
+    return typeof text === 'string' ? text : undefined;
+}
+export function inferLegacyRowKind(m, opts) {
+    const present = rowKindOf(m);
+    if (present !== undefined)
+        return present;
+    if (ownData(m, SEMA_ROW_KIND_KEY) !== undefined)
+        return undefined;
+    const requireFlag = opts === undefined ? true : ownData(opts, 'requireFlag') !== false;
+    if (requireFlag && !hasSyntheticFlag(m))
+        return undefined;
+    const text = singleTextOf(m);
+    return text === undefined ? undefined : legacyRowKindOfText(text);
+}

package/dist/ruleCompileVerdict.d.ts

@@ -8,3 +8,21 @@ export type RuleCompileVerdict = {
     readonly kind: 'unknown';
 };
 export declare function ruleCompileVerdict(rule: string, behavior: 'deny' | 'ask'): RuleCompileVerdict;
+export interface RuleCompilePathBases {
+    readonly cwd?: string;
+    readonly root?: string;
+    readonly home?: string;
+}
+export declare function ruleCompileVerdictUnder(rule: string, behavior: 'deny' | 'ask', pathBases: RuleCompilePathBases): RuleCompileVerdict;
+export type DenyEntryInertReason = 'grammar' | 'content_unsupported' | 'wildcard_all' | 'namespace_wildcard';
+export type DenyEntryReading = {
+    readonly kind: 'row';
+} | {
+    readonly kind: 'inert';
+    readonly reason: DenyEntryInertReason;
+} | {
+    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;