@sema-agent/client-core 0.112.1 → 0.113.0

package/dist/model/onboardSteps.d.ts

@@ -0,0 +1,19 @@
+import type { EngineTargetState, ModelPoolListResult } from '../seatContract.js';
+import type { ModelPoolView } from '../localConfig/modelPool.js';
+export declare const ONBOARD_STEPS: readonly ["model", "tiers", "optional", "ready"];
+export type OnboardStep = (typeof ONBOARD_STEPS)[number];
+export declare const ONBOARD_STEP_STATES: readonly ["required", "skippable", "skipped"];
+export type OnboardStepState = (typeof ONBOARD_STEP_STATES)[number];
+export declare const ONBOARD_STEP_REASONS: readonly ["already_configured", "pool_empty", "target_not_local"];
+export type OnboardStepReason = (typeof ONBOARD_STEP_REASONS)[number];
+export interface OnboardStepRow {
+    readonly step: OnboardStep;
+    readonly state: OnboardStepState;
+    readonly reason?: OnboardStepReason;
+}
+export type OnboardStepPlan = readonly [OnboardStepRow, OnboardStepRow, OnboardStepRow, OnboardStepRow];
+export interface OnboardStepPlanInput {
+    readonly target?: Pick<EngineTargetState, 'mode'> | undefined;
+    readonly view?: ModelPoolView | ModelPoolListResult | undefined;
+}
+export declare function onboardStepPlanOf(input?: OnboardStepPlanInput): OnboardStepPlan;

package/dist/model/onboardSteps.js

@@ -0,0 +1,76 @@
+import { modelPoolEnvReadingOf } from '../localConfig/modelPool.js';
+import { ownDataField, ownSnapshotRecordFaithful } from '../ownKey.js';
+export const ONBOARD_STEPS = Object.freeze(['model', 'tiers', 'optional', 'ready']);
+export const ONBOARD_STEP_STATES = Object.freeze(['required', 'skippable', 'skipped']);
+export const ONBOARD_STEP_REASONS = Object.freeze(['already_configured', 'pool_empty', 'target_not_local']);
+function slotOf(carrier, key) {
+    try {
+        return typeof carrier === 'object' && carrier !== null ? ownDataField(carrier, key) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const arrayOf = (v) => (Array.isArray(v) ? v : undefined);
+const recordOf = (v) => (typeof v === 'object' && v !== null && !Array.isArray(v) ? v : undefined);
+function poolFactsOf(view) {
+    const v = ownSnapshotRecordFaithful(view);
+    if (v === undefined || v['kind'] === 'unavailable')
+        return undefined;
+    const catalog = v['catalog'];
+    if (catalog !== 'read' && catalog !== 'absent' && catalog !== 'unreadable')
+        return undefined;
+    if (catalog === 'unreadable')
+        return undefined;
+    const entries = arrayOf(v['entries']);
+    if (entries === undefined)
+        return undefined;
+    let enabled = 0;
+    for (let i = 0; i < entries.length; i++) {
+        if (!(i in entries))
+            return undefined;
+        const entry = recordOf(entries[i]);
+        const on = entry === undefined ? undefined : entry['enabled'];
+        if (typeof on !== 'boolean')
+            return undefined;
+        if (on)
+            enabled++;
+    }
+    if (catalog === 'absent' && entries.length > 0)
+        return undefined;
+    const certainlyEmpty = catalog === 'absent' || (catalog === 'read' && v['completeness'] === 'complete' && enabled === 0);
+    return { enabled, certainlyEmpty, env: modelPoolEnvReadingOf(v), envModels: envModelsOf(v['envModels']) };
+}
+function envModelsOf(raw) {
+    const models = arrayOf(raw);
+    if (models === undefined)
+        return 'unknown';
+    for (let i = 0; i < models.length; i++) {
+        if (!(i in models) || typeof models[i] !== 'string')
+            return 'unknown';
+    }
+    return models.length === 0 ? 'empty' : 'some';
+}
+const row = (step, state, reason) => Object.freeze(reason === undefined ? { step, state } : { step, state, reason });
+function planOf(mode, pool) {
+    let model = row('model', 'skippable');
+    if (mode === 'cloud')
+        model = row('model', 'skippable', 'target_not_local');
+    else if (mode === 'local' && pool !== undefined) {
+        if (pool.certainlyEmpty && pool.env === 'read' && pool.envModels === 'empty')
+            model = row('model', 'required');
+        else if (pool.enabled > 0 || (pool.env === 'read' && pool.envModels === 'some'))
+            model = row('model', 'skippable', 'already_configured');
+    }
+    const tiers = pool !== undefined && pool.certainlyEmpty ? row('tiers', 'skipped', 'pool_empty') : row('tiers', 'skippable');
+    return Object.freeze([model, tiers, row('optional', 'skippable'), row('ready', 'required')]);
+}
+export function onboardStepPlanOf(input) {
+    try {
+        const mode = slotOf(slotOf(input, 'target'), 'mode');
+        return planOf(typeof mode === 'string' ? mode : undefined, poolFactsOf(slotOf(input, 'view')));
+    }
+    catch {
+        return planOf(undefined, undefined);
+    }
+}

package/dist/notifications.js

@@ -440,6 +440,9 @@ export function enqueuePlanReviewOutcome(value, meta) {
 function planReviewOutcomeRefrozen(meta, questionId) {
     const effect = meta.effect;
     const cause = planReviewOutcomeCauseOf(effect, meta.cause);
+    const delivery = guardedRead(() => readOwnDataValue(meta, 'delivery'));
+    const gateIdOmitted = guardedRead(() => readOwnDataValue(meta, 'gateIdOmitted'));
+    const wayOut = guardedRead(() => readOwnDataNonEmptyString(meta, 'wayOut'));
     return Object.freeze({
         taskId: meta.taskId,
         dispatchNo: meta.dispatchNo,
@@ -447,6 +450,9 @@ function planReviewOutcomeRefrozen(meta, questionId) {
         effect,
         ...(cause !== undefined ? { cause } : {}),
         ...(questionId !== undefined ? { questionId } : {}),
+        ...(delivery === 'submit' || delivery === 'follow' ? { delivery } : {}),
+        ...(gateIdOmitted === true ? { gateIdOmitted: true } : {}),
+        ...(wayOut !== undefined ? { wayOut } : {}),
     });
 }
 export function resupplyTruncatedSentence(facts, lang) {

package/dist/ownKey.d.ts

@@ -5,13 +5,17 @@ export declare function readOwnDataNonEmptyString(v: object | null | undefined,
 export declare function readOwnDataFiniteNumber(v: object | null | undefined, key: string): number | undefined;
 export declare function readOwnDataValue<T>(v: object | null | undefined, key: string): T | undefined;
 export declare function carriesAnswerText(text: string): boolean;
+export declare function sameJson(a: {} | null | undefined, b: {} | null | undefined): boolean;
 export declare function appendOwnElement<T>(list: T[], value: T): void;
 export declare function toolResultBlockOf(record: object): object | undefined;
 export declare function guardedRead<T>(read: () => T | undefined): T | undefined;
+export type HostPresence = 'here' | 'left' | 'unconfirmed';
+export declare function hostPresenceOf(host: object | null | undefined, call?: (ask: () => boolean | undefined) => boolean | undefined): HostPresence;
 export declare function ownDataField(v: object, key: string): unknown;
 export declare function ownSendableField(v: object, key: string): unknown;
 export declare function ownDataRefusalKeyOf(e: unknown): string | undefined;
 export declare function readFrameStringKey(frame: unknown, key: string): string | undefined;
+export declare function readFrameEntryIdList(frame: object | null | undefined, key: string): readonly string[] | undefined;
 export declare function readFrameTrueMark(frame: object | null | undefined, key: string): boolean;
 export type FrameTrueMarkReading = 'marked' | 'absent' | 'unreadable';
 export declare function readFrameTrueMarkReading(frame: object | null | undefined, key: string): FrameTrueMarkReading;

package/dist/ownKey.js

@@ -37,6 +37,21 @@ export function readOwnDataValue(v, key) {
 export function carriesAnswerText(text) {
     return text.trim().length > 0;
 }
+export function sameJson(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((x, i) => sameJson(x, b[i]));
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length)
+        return false;
+    return ka.every((k) => Object.hasOwn(b, k) && sameJson(a[k], b[k]));
+}
 export function appendOwnElement(list, value) {
     Object.defineProperty(list, list.length, { value, writable: true, enumerable: true, configurable: true });
 }
@@ -63,6 +78,29 @@ export function guardedRead(read) {
         return undefined;
     }
 }
+export function hostPresenceOf(host, call) {
+    if (typeof host !== 'object' || host === null)
+        return 'here';
+    let port;
+    try {
+        port = host.stillHere;
+    }
+    catch {
+        return 'unconfirmed';
+    }
+    if (port === undefined)
+        return 'here';
+    if (typeof port !== 'function')
+        return 'unconfirmed';
+    try {
+        const ask = () => port.call(host);
+        const answer = call === undefined ? ask() : call(ask);
+        return answer === true ? 'here' : answer === false ? 'left' : 'unconfirmed';
+    }
+    catch {
+        return 'unconfirmed';
+    }
+}
 export function ownDataField(v, key) {
     return ownField(v, key, false);
 }
@@ -94,6 +132,29 @@ export function readFrameStringKey(frame, key) {
         return undefined;
     }
 }
+export function readFrameEntryIdList(frame, key) {
+    try {
+        if (frame === null || typeof frame !== 'object' || Array.isArray(frame))
+            return undefined;
+        const list = readOwnDataValue(frame, key);
+        if (!Array.isArray(list))
+            return undefined;
+        const len = readOwnDataValue(list, 'length');
+        if (typeof len !== 'number' || !Number.isInteger(len) || len < 0 || len > 1024)
+            return undefined;
+        const out = [];
+        for (let i = 0; i < len; i++) {
+            const id = readOwnDataNonEmptyString(list, String(i));
+            if (id === undefined)
+                return undefined;
+            appendOwnElement(out, id);
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function readFrameTrueMark(frame, key) {
     return readFrameTrueMarkReading(frame, key) === 'marked';
 }

package/dist/pathShape.d.ts

@@ -0,0 +1,14 @@
+export declare const PATH_LENGTH_LIMIT = 4096;
+export type PathRootKind = 'posix' | 'drive' | 'unc' | 'relative';
+export type PathCut = 'both' | '/' | '\\';
+export interface PathShape {
+    readonly kind: PathRootKind;
+    readonly root: string;
+    readonly names: readonly string[];
+    readonly hasEmptySegment: boolean;
+    readonly hasTrailingSeparator: boolean;
+    readonly hasDotSegment: boolean;
+    readonly hasParentSegment: boolean;
+}
+export declare function isDotSegment(seg: string): boolean;
+export declare function pathShapeOf(raw: string, cut?: PathCut): PathShape | undefined;

package/dist/pathShape.js

@@ -0,0 +1,44 @@
+export const PATH_LENGTH_LIMIT = 4096;
+export function isDotSegment(seg) {
+    return seg === '.' || seg === '..';
+}
+export function pathShapeOf(raw, cut = 'both') {
+    if (typeof raw !== 'string' || raw === '' || raw.includes('\u0000'))
+        return undefined;
+    let kind = 'relative';
+    let root = '';
+    if (raw.charAt(0) === '/') {
+        kind = 'posix';
+        root = '/';
+    }
+    else if (/^[A-Za-z]:[\\/]/.test(raw)) {
+        kind = 'drive';
+        root = raw.slice(0, 3);
+    }
+    else {
+        const unc = /^\\\\[^\\/]+[\\/][^\\/]+/.exec(raw);
+        if (unc !== null) {
+            kind = 'unc';
+            root = unc[0];
+        }
+    }
+    let from = root.length;
+    if (kind === 'unc' && (raw.charAt(from) === '/' || raw.charAt(from) === '\\'))
+        from += 1;
+    const tail = raw.slice(from);
+    const pieces = tail === '' ? [] : tail.split(cut === 'both' ? /[\\/]/ : cut);
+    let end = pieces.length;
+    while (end > 0 && pieces[end - 1] === '')
+        end -= 1;
+    const body = pieces.slice(0, end);
+    const all = raw.split(/[\\/]/);
+    return Object.freeze({
+        kind,
+        root,
+        names: Object.freeze(body.filter((p) => p !== '')),
+        hasEmptySegment: body.some((p) => p === ''),
+        hasTrailingSeparator: end < pieces.length,
+        hasDotSegment: all.some(isDotSegment),
+        hasParentSegment: all.some((p) => p === '..'),
+    });
+}

package/dist/planReviewCardFacts.d.ts

@@ -64,6 +64,7 @@ interface PlanReviewRunRecord {
     gate?: PlanReviewGateEntry;
     generation: number;
     cardIssued: boolean;
+    lastCardGate?: string;
 }
 export declare function _resetPlanReviewRunsForTest(): void;
 export interface PlanReviewFactsTicket {
@@ -83,6 +84,8 @@ export interface PlanReviewCurrentGate {
 export declare function currentPlanReviewGateOf(sessionKey: string, taskId: string): PlanReviewCurrentGate | undefined;
 export declare function planReviewRunGeneration(sessionKey: string, taskId: string): number;
 export declare function notePlanReviewCardIssued(sessionKey: string, taskId: string): boolean;
+export declare function noteCardGateHandedOver(sessionKey: string, taskId: string, checkpointId: string | undefined): void;
+export declare function planReviewCardReplacesEarlier(sessionKey: string, facts: PlanReviewCardFacts): boolean;
 export declare function planReviewGateHighWaterOf(sessionKey: string, taskId: string, checkpointId: string): string | undefined;
 export interface PlanBodyClaimLeg {
     taskId?: string;

package/dist/planReviewCardFacts.js

@@ -134,7 +134,13 @@ export function pausedCheckpointIdOf(carrier) {
 }
 const SETTLED_CALLS_MAX = 10_000;
 const PLAN_REVIEW_RUNS_MAX = 64;
-const planReviewRuns = new Map();
+class PlanReviewRunTable extends Map {
+    generationSeq = 0;
+}
+function nextRunGeneration() {
+    return ++planReviewRuns.generationSeq;
+}
+const planReviewRuns = new PlanReviewRunTable();
 const runKey = (sessionKey, taskId) => `${sessionKey}\u0000${taskId}`;
 function emptyWindow() {
     return { presented: [], malformed: false, ambiguous: false, unreadable: false };
@@ -146,7 +152,7 @@ function recordFor(sessionKey, taskId) {
         planReviewRuns.delete(key);
     }
     else {
-        rec = { open: new Set(), settled: new Set(), window: emptyWindow(), sawPlanFrame: false, dirty: false, generation: 0, cardIssued: false };
+        rec = { open: new Set(), settled: new Set(), window: emptyWindow(), sawPlanFrame: false, dirty: false, generation: nextRunGeneration(), cardIssued: false };
     }
     planReviewRuns.set(key, rec);
     while (planReviewRuns.size > PLAN_REVIEW_RUNS_MAX) {
@@ -162,7 +168,7 @@ export function _resetPlanReviewRunsForTest() {
 }
 export function beginPlanReviewFactsRead(sessionKey, taskId) {
     const rec = recordFor(sessionKey, taskId);
-    rec.generation += 1;
+    rec.generation = nextRunGeneration();
     return { sessionKey, taskId, generation: rec.generation };
 }
 export function commitPlanReviewFacts(ticket, facts, claim, highWater) {
@@ -216,6 +222,17 @@ export function notePlanReviewCardIssued(sessionKey, taskId) {
     rec.cardIssued = true;
     return before;
 }
+export function noteCardGateHandedOver(sessionKey, taskId, checkpointId) {
+    const rec = recordFor(sessionKey, taskId);
+    if (checkpointId === undefined)
+        delete rec.lastCardGate;
+    else
+        rec.lastCardGate = checkpointId;
+}
+export function planReviewCardReplacesEarlier(sessionKey, facts) {
+    const last = planReviewRuns.get(runKey(sessionKey, facts.taskId))?.lastCardGate;
+    return last !== undefined && facts.checkpointId !== undefined && last !== facts.checkpointId;
+}
 export function planReviewGateHighWaterOf(sessionKey, taskId, checkpointId) {
     const gate = planReviewRuns.get(runKey(sessionKey, taskId))?.gate;
     return gate !== undefined && gate.checkpointId === checkpointId ? gate.highWater : undefined;

package/dist/pluginHooksWire.d.ts

@@ -1,18 +1,27 @@
 import type { HostSettingsSource } from './hostSettingsSource.js';
 import type { WireHooksConfig } from './finalVerifyWire.js';
-import type { PluginHookSource, SessionHookOrigin, SessionHookSource } from './host.js';
+import { SETTINGS_ENGINE_OWNED_HOOK_EVENTS } from './generated/settingsSchemaTables.js';
+import { type PluginHookSource, type SessionHookOrigin, type SessionHookSource } from './host.js';
 import type { HttpPolicyDropRow } from './httpHookPolicy.js';
 import type { SubmissionIdentity } from './request/submissionIdentity.js';
+import type { HooksEntryKeyReader } from './hooksReaderGenerations.js';
 import { type HooksSalvageDrop, type HooksSalvageMask, type HooksSalvageRejection } from './settingsHooksSalvage.js';
-export declare const ENGINE_FIRED_HOOK_EVENTS: readonly ["PreToolUse", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "PreCompact", "PostCompact", "Stop", "StopFailure", "UserPromptSubmit"];
-export type EngineFiredHookEvent = (typeof ENGINE_FIRED_HOOK_EVENTS)[number];
+export type EngineFiredHookEvent = (typeof SETTINGS_ENGINE_OWNED_HOOK_EVENTS)[number];
+export interface HooksWireSettingsContract {
+    readonly version: string;
+    readonly basis: 'reported' | 'absent' | 'unreadable';
+}
+export declare const SUPPORT_FLOOR_SETTINGS_CONTRACT: HooksWireSettingsContract;
+export declare function contractOwnsHookEventAt(event: string, contractVersion: string): boolean | undefined;
+export declare function engineLaneOf(reading: HooksWireSettingsContract | undefined): (event: string) => boolean;
+export declare function planSettingsContractOf(plan: object | undefined): HooksWireSettingsContract | undefined;
 export declare const PLUGIN_HOOK_DISPOSITIONS: readonly ["engine", "shell", "not_run"];
 export type PluginHookDisposition = (typeof PLUGIN_HOOK_DISPOSITIONS)[number];
 export declare const PLUGIN_HOOK_REASONS: readonly ["projected", "shell_event", "no_executor", "engine_not_local", "engine_locality_unknown", "engine_capability_absent", "engine_capability_unknown", "not_command", "sensitive_options", "engine_limit", "shell_form_user_config", "user_config_unset", "malformed_entry", "engine_hooks_off", "engine_hooks_unknown", "engine_type_skipped", "engine_llm_limit", "engine_unconfirmed", "engine_elsewhere", "hooks_module", "scope_unsupported", "source_incomplete", "compaction_local_fallback", "key_not_read", "source_not_authored"];
 export type PluginHookReason = (typeof PLUGIN_HOOK_REASONS)[number];
 export declare const PLUGIN_HOOK_EXCLUSION_REASONS: readonly ["workspace_untrusted", "governance_unreadable", "policy_disable_all", "startup_mode", "managed_plugins_only", "prompt_not_user_authored"];
 export type PluginHookExclusionReason = (typeof PLUGIN_HOOK_EXCLUSION_REASONS)[number];
-export declare const SETTINGS_HOOK_DROP_REASONS: readonly ["exec_form_unsupported", "mcp_tool_unsupported", "key_not_read", "source_not_authored", "workspace_untrusted", "governance_unreadable", "policy_disable_all", "no_executor"];
+export declare const SETTINGS_HOOK_DROP_REASONS: readonly ["exec_form_unsupported", "mcp_tool_unsupported", "key_not_read", "source_not_authored", "workspace_untrusted", "governance_unreadable", "policy_disable_all", "no_executor", "layer_degraded"];
 export type SettingsHookDropReason = (typeof SETTINGS_HOOK_DROP_REASONS)[number];
 export type HookEntryTypeWord = 'command' | 'prompt' | 'agent' | 'http' | 'mcp_tool';
 export declare const HOOK_ENTRY_TYPE_WORDS: readonly ["command", "prompt", "agent", "http", "mcp_tool"];
@@ -39,6 +48,7 @@ export interface SettingsHookDrop {
     readonly type?: HookEntryTypeWord;
     readonly reason: SettingsHookDropReason;
     readonly notRun: boolean;
+    readonly guard: boolean;
     readonly unreadKeys?: readonly (readonly (string | number)[])[];
 }
 export interface SettingsHookVerdict {
@@ -67,7 +77,7 @@ export interface SettingsHooksSalvageRow {
 }
 export interface SettingsLayerWithheldRow {
     readonly source: HookSettingsSource;
-    readonly cause: 'trust_withheld';
+    readonly cause: 'trust_withheld' | 'layer_degraded';
     readonly notice: string;
 }
 export interface PluginHookModuleVerdict {
@@ -89,6 +99,8 @@ export interface HooksWireEngineFacts {
     readonly ownedByThisShell: boolean | null;
     readonly pluginHooksCapable: boolean | null;
     readonly hooksCapable: boolean | null;
+    readonly settingsContract: HooksWireSettingsContract;
+    readonly hookEntryFields?: 'reported' | 'not_reported' | 'unreadable' | null;
 }
 export type PluginHookReaderState = 'present' | 'absent' | 'failed';
 export interface HooksWirePlan {
@@ -138,7 +150,7 @@ type HookExecutor = {
 };
 type WireHookGroup = NonNullable<WireHooksConfig[string]>[number];
 type WireHookEntry = WireHookGroup['hooks'][number];
-export declare function isEngineFiredHookEvent(event: string): boolean;
+export declare function isEngineFiredHookEvent(event: string, contract: HooksWireSettingsContract): boolean;
 export interface EventOccupancy {
     readonly groups: number;
     readonly entries: number;
@@ -153,7 +165,7 @@ export interface PluginHookDecisionInput {
     readonly promptAuthoredByUser: boolean;
     readonly occupied: ReadonlyMap<string, EventOccupancy>;
     readonly suppressedLocally?: ReadonlySet<string>;
-    readonly readerNotRead: readonly string[];
+    readonly reader: HooksEntryKeyReader;
 }
 export interface PluginHookDecision {
     readonly verdicts: readonly PluginHookVerdict[];
@@ -173,7 +185,7 @@ export declare function decideSessionHooks(input: SessionHookDecisionInput): {
     readonly verdicts: readonly SessionHookVerdict[];
     readonly unreadable: number;
 };
-export declare function filterSettingsHookGroups(source: HookSettingsSource, event: string, groups: readonly WireHookGroup[], execFormCapable: boolean, shellRunsType: (type: string | undefined) => boolean, judge: SettingsHookJudge, readerNotRead: readonly string[], mask?: HooksSalvageMask): SettingsHookFilterResult;
+export declare function filterSettingsHookGroups(source: HookSettingsSource, event: string, groups: readonly WireHookGroup[], execFormCapable: boolean, shellRunsType: (type: string | undefined) => boolean, judge: SettingsHookJudge, reader: HooksEntryKeyReader, contract: HooksWireSettingsContract, mask?: HooksSalvageMask): SettingsHookFilterResult;
 export declare function hookEntryTypeWordOf(entry: {} | null | undefined): {
     readonly type?: HookEntryTypeWord;
 };