@sema-agent/client-core 0.107.0 → 0.108.0

package/dist/seatContract.js

@@ -4,6 +4,8 @@ import { REWIND_MODES } from "./rewindWireCaps.js";
 import { SETTINGS_MODEL_API_WORDS } from "./generated/settingsSchemaTables.js";
 import { PROBE_VERDICTS } from "./modelCapabilityProbe.js";
 import { guardedRead, ownDataField, ownDataRefusalKeyOf, ownSendableField, readOwnDataValue } from "./ownKey.js";
+import { isPlainRecord as isJsonPlainRecord } from "./jsonFaithful.js";
+import { displayUntrustedMarks, quoteUntrustedForSentence } from "./displayUntrusted.js";
 import { MCP_LIVENESS_STATES } from "./mcpLiveness.js";
 import { THINKING_LATCH_EVENTS, THINKING_LATCH_ROW_WORDS } from "./thinkingLatchWords.js";
 import { EXECUTION_PLACEMENT_ROLES } from "./executionPlacementWords.js";
@@ -18,12 +20,7 @@ const nested = (prefix, verdict) => {
     const reason = verdict.reason.startsWith(`${prefix}:`) ? verdict.reason : `${prefix}: ${verdict.reason}`;
     return bad(reason, path);
 };
-const isPlainRecord = (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);
-};
+const isPlainRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v) && isJsonPlainRecord(v);
 const isAbsent = (v) => typeof v === "undefined";
 const optionalString = (v) => isAbsent(v) || typeof v === "string";
 const isFolderPath = (v) => typeof v === "string" && v.length > 0;
@@ -185,6 +182,8 @@ const R_NUM = ruleOf("finite number", (v) => typeof v === "number" && Number.isF
 const R_NUM0 = ruleOf("finite non-negative number", (v) => typeof v === "number" && Number.isFinite(v) && v >= 0);
 const R_INT0 = ruleOf("non-negative integer", (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0);
 const R_INT1 = ruleOf("positive integer", (v) => typeof v === "number" && Number.isSafeInteger(v) && v > 0);
+const SESSION_ENGINE_KIND_WORDS = Object.freeze(["local", "cloud"]);
+const R_ENGINE_LANE = oneOfRule("engine lane", SESSION_ENGINE_KIND_WORDS);
 const keyWords = (k) => k
     .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
     .toLowerCase()
@@ -333,6 +332,7 @@ export const HITL_RESOLUTION_OUTCOMES = [
     "accept",
     "decline",
     "cancel",
+    "engine_unavailable",
 ];
 export const SEAT_STREAM_DELTA_TYPE_OF_CHANNEL = Object.freeze({ text: "text_delta", thinking: "thinking_delta" });
 export function seatStreamDeltaMessage(event, ids) {
@@ -381,7 +381,7 @@ export function readSeatStreamDelta(message) {
         return Object.freeze({ kind: "malformed" });
     }
 }
-export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly"]);
+export const SEAT_CAPABILITY_NAMES = Object.freeze(["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions"]);
 const notReported = () => Object.freeze({ kind: "not_reported" });
 const malformedReading = () => Object.freeze({ kind: "malformed" });
 const reported = (available) => Object.freeze({ kind: "reported", available });
@@ -460,6 +460,7 @@ const SEAT_CAPABILITY_PHRASES = Object.freeze({
     thinkingLatch: Object.freeze({ action: "Switching thinking", ability: "switch thinking", support: "thinking-switch support" }),
     computerUseSwitch: Object.freeze({ action: "Computer use", ability: "be switched", support: "switch support" }),
     engineModeDefaultOnly: Object.freeze({ action: "Default-only engine switching", ability: "keep existing sessions on their engine", support: "default-only engine switching" }),
+    seatActions: Object.freeze({ action: "App menu actions", ability: "send actions to this window", support: "app action support" }),
 });
 export function seatCapabilityUnavailableDetail(name, reading) {
     const phrase = Object.hasOwn(SEAT_CAPABILITY_PHRASES, name)
@@ -668,6 +669,7 @@ export const ENGINE_TARGET_REFUSALS = Object.freeze([
     "not_configured",
     "not_signed_in",
     "probe_failed",
+    "cloud_unreachable",
     "org_policy",
     "url_refused",
     "login_failed",
@@ -766,7 +768,7 @@ const ENGINE_TARGET_LOCAL = shapeRule("local", {
     mcp: optF(SEAT_LOCAL_MCP_READING),
 });
 const ENGINE_TARGET_STATE = shapeRule("engine target", {
-    mode: reqF(oneOfRule("engine mode", ["local", "cloud"])),
+    mode: reqF(R_ENGINE_LANE),
     generation: reqF(R_INT0),
     cloud: reqF(ENGINE_TARGET_CLOUD),
     local: reqF(ENGINE_TARGET_LOCAL),
@@ -1064,6 +1066,119 @@ export function planSetComputerUse(request, lockedByEnv) {
         return Object.freeze({ kind: "refused", reason: "confirmation-required" });
     return Object.freeze({ kind: "apply", enabled: intent.kind === "enable" });
 }
+export const SEAT_ACTION_NAMES = Object.freeze(["new-project", "prefill-composer"]);
+const SEAT_PREFILL_TEXT_MAX = 14336;
+const SEAT_PREFILL_CWD_MAX = 4096;
+const SEAT_ACTIONS_CLAIM_MAX = 16;
+const SEAT_ACTION_WORD_MAX = 64;
+const SEAT_TEXT_FACE = Object.freeze({ foldLines: false, keepLayout: "crlf", credentialUrls: false, credentialWords: false });
+const SEAT_PATH_FACE = Object.freeze({ foldLines: false, credentialUrls: false, credentialWords: false });
+const faceClean = (v, face) => displayUntrustedMarks(v, face).marks.length === 0;
+const R_PREFILL_TEXT = ruleOf(`prefill text (1–${SEAT_PREFILL_TEXT_MAX} chars, no control, bidi or other invisible characters)`, (v) => typeof v === "string" && v.length > 0 && v.length <= SEAT_PREFILL_TEXT_MAX && faceClean(v, SEAT_TEXT_FACE));
+const R_PREFILL_CWD = ruleOf(`folder path (1–${SEAT_PREFILL_CWD_MAX} chars, no control, bidi or other invisible characters)`, (v) => isFolderPath(v) && v.length <= SEAT_PREFILL_CWD_MAX && faceClean(v, SEAT_PATH_FACE));
+const SEAT_ACTION_ARMS = {
+    "new-project": {},
+    "prefill-composer": { text: reqF(R_PREFILL_TEXT), cwd: optF(R_PREFILL_CWD) },
+};
+export const checkSeatAction = seatShapeCheck(armsRule("seat action", "action", SEAT_ACTION_ARMS));
+const seatActionMalformed = (reason) => Object.freeze({ kind: "malformed", reason });
+export function readSeatAction(ev) {
+    try {
+        if (!isPlainRecord(ev))
+            return seatActionMalformed("not a plain object");
+        const name = own(ev, "action");
+        if (typeof name !== "string")
+            return seatActionMalformed("action must be a string");
+        if (!inTuple(SEAT_ACTION_NAMES, name))
+            return Object.freeze({ kind: "unknown", name: name.slice(0, SEAT_ACTION_WORD_MAX) });
+        const verdict = checkSeatAction(ev);
+        if (verdict !== true) {
+            return seatActionMalformed(`${verdict.field ? `${verdict.field}: ` : ""}${verdict.reason}`);
+        }
+        if (name === "new-project")
+            return Object.freeze({ kind: "action", action: Object.freeze({ action: "new-project" }) });
+        const text = own(ev, "text");
+        const cwd = own(ev, "cwd");
+        if (R_PREFILL_TEXT.test(text, "text") !== true || typeof text !== "string")
+            return seatActionMalformed("text: payload changed while being read");
+        if (!isAbsent(cwd) && (R_PREFILL_CWD.test(cwd, "cwd") !== true || typeof cwd !== "string"))
+            return seatActionMalformed("cwd: payload changed while being read");
+        return Object.freeze({
+            kind: "action",
+            action: Object.freeze({ action: "prefill-composer", text, ...(typeof cwd === "string" ? { cwd } : {}) }),
+        });
+    }
+    catch {
+        return seatActionMalformed("payload could not be read");
+    }
+}
+const quoteSeatWord = (w) => quoteUntrustedForSentence(w, SEAT_ACTION_WORD_MAX) ?? '""';
+const R_CLAIM_WORD = {
+    label: "action word",
+    test: (v, path) => typeof v === "string"
+        ? inTuple(SEAT_ACTION_NAMES, v)
+            ? true
+            : bad(`unknown action word ${quoteSeatWord(v)} (closed set: ${SEAT_ACTION_NAMES.join("|")})`, path)
+        : bad("bad value (action word)", path),
+};
+const claimListOnce = (v, path) => {
+    const n = ownDataField(v, "length");
+    if (typeof n !== "number" || !Number.isSafeInteger(n) || n < 0)
+        return bad("bad value (action list)", path);
+    if (n > SEAT_ACTIONS_CLAIM_MAX)
+        return bad(`bad value (at most ${SEAT_ACTIONS_CLAIM_MAX} actions)`, path);
+    for (const k of Reflect.ownKeys(v)) {
+        if (typeof k === "string" && !isArraySlotKey(k, n))
+            return bad("unknown key", pathAt(path, k));
+    }
+    const words = [];
+    for (let i = 0; i < n; i += 1)
+        words.push(own(v, String(i)));
+    return words;
+};
+const R_CLAIM_LIST = {
+    label: `action list (at most ${SEAT_ACTIONS_CLAIM_MAX})`,
+    test: (v, path) => {
+        if (!Array.isArray(v))
+            return bad("bad value (action list)", path);
+        const words = claimListOnce(v, path);
+        if (!Array.isArray(words))
+            return words;
+        for (let i = 0; i < words.length; i += 1) {
+            const verdict = R_CLAIM_WORD.test(words[i], `${path}[${i}]`);
+            if (verdict !== true)
+                return verdict;
+        }
+        return true;
+    },
+};
+const checkSeatActionsClaimShape = seatShapeCheck(shapeRule("seat actions claim", { actions: reqF(R_CLAIM_LIST) }));
+export const checkSeatActionsClaim = seatCheck((v) => isPlainRecord(v) ? checkSeatActionsClaimShape(v) : bad("claimSeatActions request is not a plain object"));
+export function claimedSeatActionsOf(claim) {
+    try {
+        if (!isPlainRecord(claim))
+            return Object.freeze([]);
+        const snap = Object.create(null);
+        for (const k of Reflect.ownKeys(claim)) {
+            if (typeof k === "string")
+                snap[k] = own(claim, k);
+        }
+        const list = snap.actions;
+        if (Array.isArray(list)) {
+            const words = claimListOnce(list, "actions");
+            if (!Array.isArray(words))
+                return Object.freeze([]);
+            snap.actions = words;
+        }
+        if (checkSeatActionsClaim(snap) !== true)
+            return Object.freeze([]);
+        const taken = snap.actions;
+        return Object.freeze(SEAT_ACTION_NAMES.filter((name) => taken.includes(name)));
+    }
+    catch {
+        return Object.freeze([]);
+    }
+}
 const checkLocalSessionRecord = seatCheck((s) => {
     if (!isPlainRecord(s))
         return bad("session record is not a plain object");
@@ -1608,6 +1723,16 @@ export const checkSetThinkingLatchRequest = seatCheck((v) => isPlainRecord(v) ?
 export function isSetThinkingLatchRequest(v) {
     return checkSetThinkingLatchRequest(v) === true;
 }
+const checkStartSessionOptionsShape = seatShapeCheck(shapeRule("start options", {
+    model: optF(R_STR),
+    title: optF(R_STR),
+    cwd: optF(R_STR),
+    excludeTools: optF(arrayRule(R_STR)),
+    engine: optF(R_ENGINE_LANE),
+}));
+export const checkStartSessionOptions = seatCheck((v) => isAbsent(v) ? true : isPlainRecord(v) ? checkStartSessionOptionsShape(v) : bad("start options are not a plain object"));
+const checkSeatResourceScopeShape = seatShapeCheck(shapeRule("resource scope", { sessionId: reqF(R_NONEMPTY) }));
+export const checkSeatResourceScope = seatCheck((v) => isAbsent(v) ? true : isPlainRecord(v) ? checkSeatResourceScopeShape(v) : bad("resource scope is not a plain object"));
 const checkSendMessageAck = seatCheck((v) => {
     if (!isPlainRecord(v))
         return bad("sendMessage ack is not a plain object");
@@ -1782,8 +1907,10 @@ export const LOCAL_SESSIONS_SPEC = {
         setThinkingLatch: { kind: "invoke", check: checkOkAck },
         getComputerUse: { kind: "invoke", check: checkComputerUseState },
         setComputerUse: { kind: "invoke", check: checkSetComputerUseResult },
+        claimSeatActions: { kind: "invoke", check: checkOkAck },
         onEvent: { kind: "event", check: checkLocalSessionEvent },
         onToolPermissionRequest: { kind: "event", check: checkToolPermissionRequest },
+        onSeatAction: { kind: "event", check: checkSeatAction },
     },
     stores: {
         sessionsState: { check: checkSessionsState },
@@ -1832,8 +1959,10 @@ export const SEAT_METHOD_NAMES = [
     "setThinkingLatch",
     "getComputerUse",
     "setComputerUse",
+    "claimSeatActions",
     "onEvent",
     "onToolPermissionRequest",
+    "onSeatAction",
 ];
 export const SEAT_STORE_PROPS = [
     "sessionsStateStore",
@@ -1842,7 +1971,7 @@ export const SEAT_STORE_PROPS = [
     "seatCapabilitiesStateStore",
     "engineTargetStateStore",
 ];
-export const SEAT_EVENT_METHOD_NAMES = ["onEvent", "onToolPermissionRequest"];
+export const SEAT_EVENT_METHOD_NAMES = ["onEvent", "onToolPermissionRequest", "onSeatAction"];
 export const LOCAL_SESSION_EVENT_KEYS = [
     "type",
     "sessionId",
@@ -1934,7 +2063,7 @@ export const TOOL_PERMISSION_DECISION_KEYS = [
     "updatedInput",
     "remember",
 ];
-export const START_SESSION_OPTION_KEYS = ["model", "title", "cwd", "excludeTools"];
+export const START_SESSION_OPTION_KEYS = ["model", "title", "cwd", "excludeTools", "engine"];
 export const SEAT_VALIDATOR_KEY_COVERAGE = {
     LocalSessionRecord: {
         guard: "isLocalSessionRecord",
@@ -2039,6 +2168,10 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
                 key: "modelPlane",
                 why: "诊断面(0.106.0 CC-1156;这台引擎服务的是哪张模型表 / 最近一份目录候选的结局),三态读法归 modelPlaneOf(含坏形 unreadable、表外词整位不给);出站门为它拒掉整份目录 = 选单为一行诊断整个消失。",
             },
+            {
+                key: "aliases",
+                why: "受理面(0.108.0 CC-944;除行名之外引擎还认的模型词),读法归 modelAcceptanceOf(缺席 = 更早的服务端,照旧判;在场而坏形 ⇒ 没找到行的词读 catalog_unreadable);出站门为它拒掉整份目录 = 选单为一份受理数据整个消失。",
+            },
         ],
     },
     SendMessageRequest: {
@@ -2073,6 +2206,21 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
         validated: ["sessionId", "event"],
         unchecked: [],
     },
+    StartSessionOptions: {
+        check: checkStartSessionOptions,
+        validated: ["model", "title", "cwd", "excludeTools", "engine"],
+        unchecked: [],
+    },
+    SeatResourceScope: {
+        check: checkSeatResourceScope,
+        validated: ["sessionId"],
+        unchecked: [],
+    },
+    SeatActionsClaim: {
+        check: checkSeatActionsClaim,
+        validated: ["actions"],
+        unchecked: [],
+    },
     ApplyModelConfigResult: {
         check: checkApplyModelConfigResult,
         validated: ["ok", "requiresRestart", "reason", "detail"],
@@ -2126,7 +2274,7 @@ export const SEAT_VALIDATOR_KEY_COVERAGE = {
     },
     SeatCapabilitiesState: {
         check: checkSeatCapabilitiesState,
-        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly"],
+        validated: ["pickFolder", "rewind", "recents", "patchSession", "devices", "engineTarget", "onboard", "mcpToolToggles", "thinkingLatch", "computerUseSwitch", "engineModeDefaultOnly", "seatActions"],
         unchecked: [],
     },
     RecentFoldersResult: {
@@ -2192,6 +2340,7 @@ export const SEAT_VALIDATOR_COVERAGE_EXEMPT = [
         ["ComputerUseState", checkComputerUseState],
         ["SetComputerUseResult", checkSetComputerUseResult],
         ["SetComputerUseRequest", checkSetComputerUseRequest],
+        ["SeatAction", checkSeatAction],
     ].map(([label, check]) => ({
         label,
         check,
@@ -2251,5 +2400,9 @@ const _seatContractPins = [
     true, true,
     true, true, true, true,
     true, true,
+    true, true, true,
+    true, true, true, true,
+    true, true,
+    true, true, true, true, true, true, true,
 ];
 void _seatContractPins;

package/dist/sessionEngine.d.ts

@@ -134,7 +134,7 @@ export interface SessionEngineWiring {
     readonly auth: EngineTargetCloudAuth | undefined;
     readonly explicitAddresses?: readonly string[];
 }
-export type SessionDispatchRefusal = 'not-wired' | 'scope-mismatch' | 'scope-unproven' | 'unresolved';
+export type SessionDispatchRefusal = 'not-wired' | 'scope-mismatch' | 'scope-unproven' | 'unresolved' | 'session-ambiguous';
 export type SessionDispatchDecision = {
     readonly kind: 'self';
     readonly wiringSnapshotId: string;
@@ -153,4 +153,5 @@ export declare function sessionEngineBindingFor(input: SessionEngineBindingInput
 export declare function isSessionEngineView(v: {} | null | undefined): boolean;
 export declare function readSessionEngine(record: SessionMapRecord | undefined): SessionEngineReading;
 export declare function commitSessionEngine(store: SessionMapStorePort, session: SessionEngineSessionRef, request: SessionEngineCommitRequest): SessionEngineCommitResult;
+export declare function sessionDispatchRefusedFor(refusal: SessionDispatchRefusal): SessionDispatchRefused;
 export declare function sessionDispatchTarget(reading: SessionEngineReading, ctx: SessionEngineWiring): SessionDispatchDecision;

package/dist/sessionEngine.js

@@ -382,8 +382,13 @@ const REFUSAL_KEYS = {
     'scope-mismatch': 'session.engine.dispatch.scopeMismatch',
     'scope-unproven': 'session.engine.dispatch.scopeUnproven',
     unresolved: 'session.engine.dispatch.unresolved',
+    'session-ambiguous': 'session.engine.dispatch.sessionAmbiguous',
 };
 const refused = (refusal) => Object.freeze({ kind: 'refused', refusal, message: msg(REFUSAL_KEYS[refusal]) });
+export function sessionDispatchRefusedFor(refusal) {
+    const word = Object.keys(REFUSAL_KEYS).find((w) => w === refusal);
+    return refused(word ?? 'unresolved');
+}
 function authOf(ctx) {
     const slot = slotReadOf(ctx, 'auth');
     if (slot.presence === 'absent' || (slot.presence === 'present' && slot.value === undefined))

package/dist/settingsHooksSalvage.d.ts

@@ -40,6 +40,11 @@ export declare function hooksSalvageMaskOf(dropped: readonly {
     readonly path: readonly (string | number)[];
 }[]): HooksSalvageMask;
 export declare function salvageSettingsHooksEntries(doc: SettingsDocument | null | undefined): HooksSalvage;
+export declare function hooksGroupUnreadKeys(event: string, group: object): readonly string[] | undefined;
+export type HooksGroupAuthoredSource = 'absent' | 'present' | 'unreadable';
+export declare function hooksGroupAuthoredSource(group: object): HooksGroupAuthoredSource;
+export declare function hooksEntryUnreadKeys(event: string, entry: object, notRead: readonly string[]): readonly string[] | undefined;
+export declare function hooksKeyCoordinateText(path: readonly (string | number)[]): string;
 export declare const HOOK_SETTINGS_SOURCE_TEXT: Readonly<Record<HookSettingsSource, string>>;
 export declare function layerNotAppliedRefusesTurn(source: HookSettingsSource): boolean;
 export declare function settingsHooksSalvageNotice(salvage: HooksSalvage, source: HookSettingsSource, doc?: SettingsDocument | null): string | undefined;

package/dist/settingsHooksSalvage.js

@@ -1,5 +1,6 @@
 import { displayUntrusted } from './displayUntrusted.js';
 import { msg, renderMessage } from './i18n/translate.js';
+import { appendOwnElement } from './ownKey.js';
 import { SETTINGS_CLASSIFY_HOOKS_CONFIG, } from './generated/settingsSchemaFns.js';
 const _tuplePins = [true, true, true, true, true, true];
 void _tuplePins;
@@ -110,6 +111,59 @@ export function salvageSettingsHooksEntries(doc) {
         rejections: Object.freeze([]),
     });
 }
+const READER_GROUP_WIRE_KEYS = ['source'];
+const READER_COMMAND_WIRE_KEYS = ['plugin', 'args'];
+function unreadOf(raw, carried, wireKeys, notRead) {
+    const out = [];
+    for (const k of Object.keys(raw)) {
+        if (own(raw, k) === undefined || wireKeys.includes(k))
+            continue;
+        if (Object.hasOwn(carried, k) && !notRead.includes(k))
+            continue;
+        appendOwnElement(out, k);
+    }
+    return Object.freeze(out);
+}
+function carriedGroupOf(event, group) {
+    const r = SETTINGS_CLASSIFY_HOOKS_CONFIG({ hooks: { [event]: [group] } });
+    if (r.outcome !== 'loaded' || !isRecord(r.hooks))
+        return undefined;
+    const groups = own(r.hooks, event);
+    const g = Array.isArray(groups) ? groups[0] : undefined;
+    return isRecord(g) ? g : undefined;
+}
+export function hooksGroupUnreadKeys(event, group) {
+    const raw = group;
+    const carried = carriedGroupOf(event, { ...raw, hooks: [] });
+    return carried === undefined ? undefined : unreadOf(raw, carried, READER_GROUP_WIRE_KEYS, []);
+}
+export function hooksGroupAuthoredSource(group) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(group, READER_GROUP_WIRE_KEYS[0]);
+        if (d === undefined)
+            return 'absent';
+        if (!Object.hasOwn(d, 'value'))
+            return 'unreadable';
+        if (d.value !== undefined)
+            return 'present';
+        return Reflect.get(group, READER_GROUP_WIRE_KEYS[0]) === undefined ? 'absent' : 'unreadable';
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+export function hooksEntryUnreadKeys(event, entry, notRead) {
+    const raw = entry;
+    const g = carriedGroupOf(event, { hooks: [raw] });
+    const entries = g === undefined ? undefined : own(g, 'hooks');
+    const carried = Array.isArray(entries) ? entries[0] : undefined;
+    if (!isRecord(carried))
+        return undefined;
+    return unreadOf(raw, carried, own(carried, 'type') === 'command' ? READER_COMMAND_WIRE_KEYS : [], notRead);
+}
+export function hooksKeyCoordinateText(path) {
+    return `settings.${path.map(labelOf).join('.')}`;
+}
 export const HOOK_SETTINGS_SOURCE_TEXT = Object.freeze({
     policySettings: 'Managed settings',
     userSettings: 'User settings',

package/dist/subagentContentStore.js

@@ -812,7 +812,7 @@ export function recordSubagentOwnerFromProgress(ev, ownerRunId, ownerSessionId,
     if (typeof ev !== 'object' || ev === null)
         return;
     const o = ev;
-    if (o.type !== 'task_progress')
+    if (o.type !== 'task_progress' && o.type !== 'task_started')
         return;
     if (typeof o.taskId !== 'string' || o.taskId === '')
         return;

package/dist/supportFloor.js

@@ -40,6 +40,8 @@ function judgeAgainst(version, base, floor, caller) {
     const got = releaseTriple(version);
     if (got === undefined)
         return { need: need.text, tier: 'unknown' };
+    if (got[0] === 0)
+        return { need: need.text, tier: 'unknown' };
     return { need: need.text, tier: compareTriple(got, need.triple) >= 0 ? 'engine' : 'legacy' };
 }
 export function engineVersionTier(version, floor) {

package/dist/taskNotificationAdmission.d.ts

@@ -0,0 +1,19 @@
+import type { RunRecord } from '@sema-agent/sdk';
+export type TaskNotificationAdmissionVerdict = 'admitted' | 'pending' | 'not_found' | 'unreadable';
+export type TaskNotificationAdmissionWhy = 'admitted_at' | 'turns_positive' | 'zero_turns' | 'no_turn_count' | 'key_unbound' | 'read_error' | 'record_malformed' | 'input_unrecognized';
+export type TaskNotificationRunRecordView = RunRecord & {
+    readonly admittedAt?: string | null;
+};
+export type TaskNotificationReadResult = {
+    readonly kind: 'record';
+    readonly record: TaskNotificationRunRecordView;
+} | {
+    readonly kind: 'not_found';
+} | {
+    readonly kind: 'error';
+};
+export interface TaskNotificationAdmission {
+    readonly verdict: TaskNotificationAdmissionVerdict;
+    readonly why: TaskNotificationAdmissionWhy;
+}
+export declare function taskNotificationAdmissionOf(readResult: TaskNotificationReadResult): TaskNotificationAdmission;

package/dist/taskNotificationAdmission.js

@@ -0,0 +1,84 @@
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+function verdictOfWhy(why) {
+    switch (why) {
+        case 'admitted_at':
+        case 'turns_positive':
+            return 'admitted';
+        case 'zero_turns':
+        case 'no_turn_count':
+            return 'pending';
+        case 'key_unbound':
+            return 'not_found';
+        case 'read_error':
+        case 'record_malformed':
+        case 'input_unrecognized':
+            return 'unreadable';
+        default: {
+            const unreachable = why;
+            return unreachable;
+        }
+    }
+}
+function ownData(o, key) {
+    return guardedRead(() => readOwnDataValue(o, key));
+}
+function isJsonObject(v) {
+    if (typeof v !== 'object' || v === null)
+        return false;
+    try {
+        return !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function admittedAtProves(v) {
+    if (typeof v !== 'string')
+        return false;
+    const m = /^(\d{4})-(\d{2})-(\d{2})T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/.exec(v);
+    if (m === null)
+        return false;
+    const year = Number(m[1]);
+    const month = Number(m[2]);
+    const day = Number(m[3]);
+    const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    const daysInMonth = month === 2 ? (leap ? 29 : 28) : month === 4 || month === 6 || month === 9 || month === 11 ? 30 : 31;
+    return month >= 1 && month <= 12 && day >= 1 && day <= daysInMonth && Number.isFinite(Date.parse(v));
+}
+function recordWhy(record) {
+    if (admittedAtProves(ownData(record, 'admittedAt')))
+        return 'admitted_at';
+    const result = ownData(record, 'result');
+    const stats = isJsonObject(result) ? ownData(result, 'stats') : undefined;
+    const turns = isJsonObject(stats) ? ownData(stats, 'turns') : undefined;
+    if (typeof turns === 'number' && Number.isInteger(turns)) {
+        if (turns > 0)
+            return 'turns_positive';
+        if (turns === 0)
+            return 'zero_turns';
+    }
+    return 'no_turn_count';
+}
+function readWhy(readResult) {
+    if (typeof readResult !== 'object' || readResult === null)
+        return 'input_unrecognized';
+    const kind = ownData(readResult, 'kind');
+    if (kind === 'not_found')
+        return 'key_unbound';
+    if (kind === 'error')
+        return 'read_error';
+    if (kind !== 'record')
+        return 'input_unrecognized';
+    const record = ownData(readResult, 'record');
+    return isJsonObject(record) ? recordWhy(record) : 'record_malformed';
+}
+export function taskNotificationAdmissionOf(readResult) {
+    let why;
+    try {
+        why = readWhy(readResult);
+    }
+    catch {
+        why = 'input_unrecognized';
+    }
+    return Object.freeze({ verdict: verdictOfWhy(why), why });
+}

package/dist/toolResult.js

@@ -9,11 +9,12 @@ import { displayUntrusted } from './displayUntrusted.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
 export const STRUCTURED_DETAIL_TYPES = frozenSet(CORE_ENGINE_CARD_TYPES);
+const LEGACY_STRUCTURED_DETAIL_TYPE = 'task-output';
 export function structuredDetailType(structured) {
     if (typeof structured !== 'object' || structured === null)
         return undefined;
     const t = structured.type;
-    return typeof t === 'string' && STRUCTURED_DETAIL_TYPES.has(t) ? t : undefined;
+    return typeof t === 'string' && (STRUCTURED_DETAIL_TYPES.has(t) || t === LEGACY_STRUCTURED_DETAIL_TYPE) ? t : undefined;
 }
 const MAX_STRUCTURED_FIELD_CHARS = 1_000_000;
 export const PROTOCOL_MARKERS = {

package/dist/webSearchWireCaps.js

@@ -1,5 +1,6 @@
 import { SETTINGS_IS_HIERARCHICAL_URL } from './generated/settingsSchemaFns.js';
 import { hostEnv } from './hostEnv.js';
+import { msg, renderMessage } from './i18n/translate.js';
 export const WEBSEARCH_ENV = {
     provider: 'SEMA_WEBSEARCH_PROVIDER',
     endpoint: 'SEMA_WEBSEARCH_ENDPOINT',
@@ -49,6 +50,9 @@ function apiKeyHeaderValue(provider, key) {
             return `Bearer ${key}`;
     }
 }
+function apiKeyWayOutSentence() {
+    return renderMessage(msg('config.webSearch.apiKeyWayOut'));
+}
 function judgeApiKey(provider, raw) {
     const text = judgeText(raw);
     if (!text.ok || text.value === undefined)
@@ -215,17 +219,18 @@ function envNameOfField(field) {
 export function webSearchVerdictMessage(verdict, context = 'submit') {
     if (verdict.kind !== 'malformed')
         return undefined;
+    const wayOut = verdict.field === 'apiKey' && verdict.issue === API_KEY_ISSUE ? ` ${apiKeyWayOutSentence()}` : '';
     if (verdict.source === 'host') {
         const head = `Web search is misconfigured: the API key your host supplied for webSearch is malformed; it ${verdict.issue}.`;
         return context === 'submit'
-            ? `${head} The request was not sent — the key needs replacing where your host keeps it.`
-            : `${head} Requests will be refused until the key is replaced where your host keeps it.`;
+            ? `${head} The request was not sent — the key needs replacing where your host keeps it.${wayOut}`
+            : `${head} Requests will be refused until the key is replaced where your host keeps it.${wayOut}`;
     }
     const where = verdict.source === 'env' ? envNameOfField(verdict.field) : verdict.field === 'section' ? 'the webSearch section in settings' : `webSearch.${verdict.field} in settings`;
     const fix = verdict.source === 'env' ? 'fix it or unset the SEMA_WEBSEARCH_* variables' : 'fix it or remove the webSearch section';
     return context === 'submit'
-        ? `Web search is misconfigured: ${where} ${verdict.issue}. The request was not sent — ${fix}.`
-        : `Web search is misconfigured: ${where} ${verdict.issue}. Requests will be refused until you ${fix}.`;
+        ? `Web search is misconfigured: ${where} ${verdict.issue}. The request was not sent — ${fix}.${wayOut}`
+        : `Web search is misconfigured: ${where} ${verdict.issue}. Requests will be refused until you ${fix}.${wayOut}`;
 }
 export function webSearchEndpointForDisplay(raw) {
     if (typeof raw !== 'string' || !SETTINGS_IS_HIERARCHICAL_URL(raw))

package/dist/wireRefusalCopy.d.ts

@@ -143,7 +143,8 @@ 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 type SessionArchiveStampedScenario = 'fork' | 'push';
+export declare function sessionArchiveStampedContent(lang?: UiLanguage, scenario?: SessionArchiveStampedScenario): string;
 export interface UnsupportedRuleRefusalProblem {
     readonly code: string;
     readonly field?: string;

package/dist/wireRefusalCopy.js

@@ -812,8 +812,8 @@ export function autonomyLaneRefusalContent(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);
+export function sessionArchiveStampedContent(lang, scenario) {
+    return renderMessage(msg(scenario === 'fork' ? 'notice.wireRefusal.sessionArchiveStamped.fork' : 'notice.wireRefusal.sessionArchiveStamped'), lang);
 }
 const REQUEST_UNPROCESSABLE = 'request.unprocessable';
 const UNSUPPORTED_RULE_PROBLEMS_MAX = REFUSAL_PROBLEMS_READ_MAX;