@sema-agent/client-core 0.85.0 → 0.85.1

package/dist/adapter/activeRunSelfHeal.js

@@ -79,11 +79,105 @@ export function readCancelRequested(body) {
     const v = body.cancelRequested;
     return typeof v === 'boolean' ? v : undefined;
 }
+const REOPEN_VERDICT_KEYS = [
+    'reopened',
+    'firstSight',
+    'presented',
+    'decidedWithoutCard',
+    'pendingRowGone',
+    '_sema_decisionInFlight',
+    'dismissedByUser',
+    '_sema_noPresentationSurface',
+];
+function snapshotReopenVerdict(raw) {
+    if (raw === null || raw === undefined)
+        return { reopened: false };
+    if (typeof raw !== 'object' && typeof raw !== 'function')
+        return raw;
+    const src = raw;
+    let nullProto = false;
+    try {
+        nullProto = Object.getPrototypeOf(raw) === null;
+    }
+    catch {
+        nullProto = false;
+    }
+    const snap = nullProto ? Object.create(null) : {};
+    const put = (k, v) => {
+        Object.defineProperty(snap, k, { value: v, enumerable: true, writable: true, configurable: true });
+    };
+    let own = [];
+    try {
+        own = Reflect.ownKeys(raw);
+    }
+    catch {
+        own = [];
+    }
+    const copied = new Set();
+    for (const k of own) {
+        let enumerable = false;
+        try {
+            enumerable = Object.prototype.propertyIsEnumerable.call(raw, k);
+        }
+        catch {
+            enumerable = false;
+        }
+        if (!enumerable)
+            continue;
+        let v;
+        let readable = true;
+        try {
+            v = src[k];
+        }
+        catch {
+            readable = false;
+        }
+        if (!readable)
+            continue;
+        put(k, v);
+        copied.add(k);
+    }
+    for (const k of REOPEN_VERDICT_KEYS) {
+        if (copied.has(k))
+            continue;
+        let v;
+        let readable = true;
+        try {
+            v = src[k];
+        }
+        catch {
+            readable = false;
+        }
+        if (readable && v !== undefined)
+            put(k, v);
+    }
+    return snap;
+}
 function reopenRefusedForDecisionInFlight(verdict) {
-    return verdict !== null && verdict.reopened === false && verdict._sema_decisionInFlight === true;
+    try {
+        return verdict !== null && verdict.reopened === false && verdict._sema_decisionInFlight === true;
+    }
+    catch {
+        return false;
+    }
 }
 function reopenRefusedForUserDismissal(verdict) {
-    return verdict !== null && verdict.reopened === false && verdict.dismissedByUser === true;
+    try {
+        return verdict !== null && verdict.reopened === false && verdict.dismissedByUser === true;
+    }
+    catch {
+        return false;
+    }
+}
+function reopenRefusedForNoPresentationSurface(verdict) {
+    try {
+        return (verdict !== null &&
+            verdict.reopened === false &&
+            verdict._sema_noPresentationSurface === true);
+    }
+    catch {
+        return false;
+    }
 }
 function planReviewReopenTriggerFor(origin) {
     if (origin === 'user')
@@ -93,7 +187,31 @@ function planReviewReopenTriggerFor(origin) {
     return undefined;
 }
 function reopenDelivered(verdict) {
-    return verdict.reopened === true && verdict.presented !== false;
+    let reopened;
+    let presented;
+    try {
+        reopened = verdict.reopened;
+    }
+    catch {
+        return false;
+    }
+    if (reopened !== true)
+        return false;
+    try {
+        presented = verdict.presented;
+    }
+    catch {
+        presented = undefined;
+    }
+    return presented !== false;
+}
+function reopenedOfOutcome(outcome) {
+    try {
+        return outcome.reopened ?? null;
+    }
+    catch {
+        return null;
+    }
 }
 export function atMostOnceFailureClass(e) {
     const status = e?.status;
@@ -299,7 +417,7 @@ async function planVerdict(taskId, deps) {
     try {
         const trigger = planReviewReopenTriggerFor(deps?.submissionOrigin);
         const verdict = trigger === undefined ? deps?.reopenPlanReview?.(taskId) : deps?.reopenPlanReview?.(taskId, { trigger });
-        return (await verdict) ?? { reopened: false };
+        return snapshotReopenVerdict(await verdict);
     }
     catch {
         return { reopened: false };
@@ -307,7 +425,7 @@ async function planVerdict(taskId, deps) {
 }
 async function askVerdict(taskId, deps) {
     try {
-        return (await deps?.reopenAskPark?.(taskId)) ?? { reopened: false };
+        return snapshotReopenVerdict(await deps?.reopenAskPark?.(taskId));
     }
     catch {
         return { reopened: false };
@@ -324,6 +442,7 @@ async function planReviewArm(taskId, signal, deps) {
         ...(reopenRefusedForDecisionInFlight(verdict) ? { decisionInFlight: true } : {}),
         ...(verdict.pendingRowGone === true ? { pendingRowGone: true } : {}),
         ...(reopenRefusedForUserDismissal(verdict) ? { dismissedByUser: true } : {}),
+        ...(reopenRefusedForNoPresentationSurface(verdict) ? { noPresentationSurface: true } : {}),
     };
 }
 async function askParkArm(taskId, signal, runs, deps) {
@@ -364,6 +483,7 @@ async function askParkArm(taskId, signal, runs, deps) {
         decidePath: signal.pendingGate?.decidePath ?? null,
         ...(inFlight ? { decisionInFlight: true } : {}),
         ...(verdict.pendingRowGone === true ? { pendingRowGone: true } : {}),
+        ...(reopenRefusedForNoPresentationSurface(verdict) ? { noPresentationSurface: true } : {}),
     };
 }
 async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
@@ -655,6 +775,7 @@ export function activeRunSelfHealRow(outcome, signal, copy, origin, follow) {
 }
 const INJECTED_LEAD = 'A follow-up message sema sent on its own (not one you typed)';
 const USER_CLOSED_CARD_NOT_PUT_BACK = 'sema does not put a card you closed back on screen by itself';
+const NO_CARD_VIEW_ATTACHED = 'this session has no view attached that can show decision cards';
 function injectedSubmissionRow(outcome, following = false) {
     const lead = INJECTED_LEAD;
     const id = 'taskId' in outcome && outcome.taskId ? ` (id ${outcome.taskId})` : '';
@@ -677,17 +798,19 @@ function injectedSubmissionRow(outcome, following = false) {
     }
     if (outcome.kind === 'running-steered' && outcome.delivery === 'queued') {
         const queuedOn = `${lead} is queued on an earlier reply${id} that is paused waiting for a decision`;
-        if (outcome.reopened !== null && reopenDelivered(outcome.reopened)) {
+        const reopened = reopenedOfOutcome(outcome);
+        if (reopened !== null && reopenDelivered(reopened)) {
             return `${queuedOn}; sema has shown that decision card, and the message is picked up once you answer it.`;
         }
-        if (reopenRefusedForDecisionInFlight(outcome.reopened)) {
+        if (reopenRefusedForDecisionInFlight(reopened)) {
             return `${queuedOn}; your answer to it is still on its way, and the message is picked up once that answer is applied.`;
         }
-        if (reopenRefusedForUserDismissal(outcome.reopened)) {
+        if (reopenRefusedForUserDismissal(reopened)) {
             return (`${queuedOn}; you closed that card yourself, so sema did not put it back on screen — send a message to bring it ` +
                 `back, and the message is picked up once that decision is made.`);
         }
-        return `${queuedOn} sema could not show here; the message is picked up only once that decision is made.`;
+        const noView = reopenRefusedForNoPresentationSurface(reopened) ? ` (${NO_CARD_VIEW_ATTACHED})` : '';
+        return `${queuedOn} sema could not show here${noView}; the message is picked up only once that decision is made.`;
     }
     if (outcome.kind === 'running-steered' && outcome.delivery === 'parked_for_wake') {
         return (`${lead} has not reached the model: the earlier reply${id} had already finished, so the message was set aside on it ` +
@@ -710,9 +833,13 @@ function injectedSubmissionRow(outcome, following = false) {
                     `sema is following that reply and will show whatever it asks for next; nothing for you to do now.`
                 : `${lead} was passed to the reply already in progress${id} instead of starting a new one — ` +
                     `watch that reply for what it does with it.`;
-        case 'not-delivered':
+        case 'not-delivered': {
+            const noView = (outcome.kind === 'ask-reopen-failed' || outcome.kind === 'plan-review-reopen-failed') && outcome.noPresentationSurface === true
+                ? ` (${NO_CARD_VIEW_ATTACHED})`
+                : '';
             return (`${lead} was not delivered: this session was still busy with an earlier reply${id}, and there was no open card ` +
-                `you could answer to free it. sema did not retry, so the model has not seen it.`);
+                `you could answer to free it${noView}. sema did not retry, so the model has not seen it.`);
+        }
     }
 }
 function decisionInFlightRow(parkedOn) {
@@ -780,8 +907,9 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
             const viaEngine = engineDecide && outcome.decidePath
                 ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
                 : '';
+            const noView = outcome.noPresentationSurface === true ? `: ${NO_CARD_VIEW_ATTACHED}` : '';
             return (`The previous turn is parked waiting for your decision (run ${outcome.taskId}) and sema could ` +
-                `not reopen that card here. It did NOT cancel the run — that would have decided it for you. ` +
+                `not reopen that card here${noView}. It did NOT cancel the run — that would have decided it for you. ` +
                 (keepSessionWayOut !== null
                     ? `Your message was NOT sent. To keep this conversation, ${keepSessionWayOut}: the card comes back when the session resumes, if it is still waiting. Or ${wayOut} if you no longer want it.${viaEngine}`
                     : `Your message was NOT sent; ${wayOut} if you no longer want it.${viaEngine}`));
@@ -797,8 +925,9 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
             const viaEngine = engineDecide && outcome.decidePath
                 ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
                 : '';
+            const noView = outcome.noPresentationSurface === true ? `: ${NO_CARD_VIEW_ATTACHED}` : '';
             return (`The previous turn is parked waiting for a plan review (run ${outcome.taskId}) and sema could not ` +
-                `reopen that approval card. It did NOT cancel the run — that would have discarded the plan for ` +
+                `reopen that approval card${noView}. It did NOT cancel the run — that would have discarded the plan for ` +
                 (keepSessionWayOut !== null
                     ? `you. Your message was NOT sent. To keep this conversation, ${keepSessionWayOut}: the card comes back when the session resumes, if it is still waiting. Or ${wayOut} if you no longer want that plan.${viaEngine}`
                     : `you. Your message was NOT sent; ${wayOut} if you no longer want that plan.${viaEngine}`));
@@ -816,15 +945,18 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
             }
             if (outcome.delivery === 'queued') {
                 const parked = outcome.status ? `parked (status ${outcome.status})` : 'parked';
-                const next = outcome.reopened !== null && reopenDelivered(outcome.reopened)
+                const reopened = reopenedOfOutcome(outcome);
+                const next = reopened !== null && reopenDelivered(reopened)
                     ? `sema has surfaced that decision card — answering it is what lets that run resume and pick your message up.`
-                    : reopenRefusedForDecisionInFlight(outcome.reopened)
+                    : reopenRefusedForDecisionInFlight(reopened)
                         ? `Your answer to that decision is still on its way to the engine, so sema did not show the card again; ` +
                             `that run moves on once the engine applies it.`
-                        : reopenRefusedForUserDismissal(outcome.reopened)
+                        : reopenRefusedForUserDismissal(reopened)
                             ? `You closed that decision card yourself, so sema did not put it back on screen; nothing will resume that ` +
                                 `run until that decision is made — send a message to bring the card back.`
-                            : `sema could not surface that decision card here, so nothing will resume that run until that decision is made; ` +
+                            : `sema could not surface that decision card here` +
+                                (reopenRefusedForNoPresentationSurface(reopened) ? ` (${NO_CARD_VIEW_ATTACHED})` : '') +
+                                `, so nothing will resume that run until that decision is made; ` +
                                 `${wayOut} if you no longer want it.`;
                 return (`${handle} is not actually working right now: the engine reports it ${parked} on a decision it needs ` +
                     `from you, so it queued your message on that park instead of running it. ${next} ${textOnly} ` +

package/dist/hitl/armedGateRegistry.d.ts

@@ -9,6 +9,7 @@ export declare function gateArmedWaitMs(): number;
 export declare function waitForGateArmed(keys: readonly string[], timeoutMs: number): Promise<boolean>;
 export declare function waitForGateArmedFor(sessionKey: string, keys: readonly string[], timeoutMs: number): Promise<boolean>;
 export declare function registerArmedGateFromQuestionId(questionId: unknown): void;
+export declare function registerArmedGateFromQuestionIdFor(sessionKey: string, questionId: unknown): void;
 export declare function planReviewArmedKey(taskId: string): string;
 export declare function planReviewArmedKeyFor(sessionKey: string, taskId: string): string;
 export declare function notePlanReviewAnswered(questionId: unknown): void;

package/dist/hitl/armedGateRegistry.js

@@ -120,7 +120,7 @@ function armedKeyForQuestionIdFor(sessionKey, questionId) {
 export function registerArmedGateFromQuestionId(questionId) {
     registerArmedGateFromQuestionIdFor(DEFAULT_SESSION_KEY, questionId);
 }
-function registerArmedGateFromQuestionIdFor(sessionKey, questionId) {
+export function registerArmedGateFromQuestionIdFor(sessionKey, questionId) {
     if (typeof questionId !== 'string' || questionId.length === 0)
         return;
     if (questionId.startsWith(PLAN_REVIEW_QUESTION_ID_PREFIX) && !questionId.includes(REOPEN_ID_TAIL)) {

package/dist/hitl/planReviewWire.js

@@ -827,6 +827,12 @@ function mintPlanReviewReopenCard(taskId, opts, sessionKey, receiptMs) {
     revokePlanReviewUserDismissal(sessionKey, taskId, markBefore);
     return { reopened: true, firstSight };
 }
+function noPresentationSurfaceVerdict(taskId, sessionKey) {
+    const verdict = { reopened: false, _sema_noPresentationSurface: true };
+    hostLog('debug', `planReviewWire: reopen for task ${taskId} refused — nothing is subscribed to question frames for session ` +
+        `${JSON.stringify(sessionKey)} (onQuestionFrameFor), so the card has nowhere to render`);
+    return verdict;
+}
 async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, mark, recheckReadStart) {
     const refusedByUser = { reopened: false, dismissedByUser: true };
     try {
@@ -863,6 +869,11 @@ async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, ma
             hostLog('debug', `planReviewWire: reopen for task ${taskId} not minted — the dismissal record changed while it was being checked (stale evaluation)`);
             return await staleDismissalVerdict(current, sessionKey, taskId, receiptMs);
         }
+        if (!hasQuestionOverlayFor(sessionKey)) {
+            if (fresh)
+                dropDismissalEntry(sessionKey, taskId, mark);
+            return noPresentationSurfaceVerdict(taskId, sessionKey);
+        }
         if (!fresh) {
             hostLog('debug', `planReviewWire: automatic reopen for task ${taskId} refused — the user closed this gate's card (no newer gate instance proven)`);
             return refusedByUser;
@@ -878,8 +889,7 @@ async function reopenAfterDismissalCheck(taskId, opts, sessionKey, receiptMs, ma
         putDismissalEntry(sessionKey, taskId, reopening);
         let verdict = { reopened: false };
         try {
-            if (hasQuestionOverlayFor(sessionKey))
-                verdict = await mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs);
+            verdict = await mintPlanReviewReopen(taskId, opts, sessionKey, receiptMs);
         }
         finally {
             const presented = verdict.reopened === true;
@@ -937,7 +947,8 @@ export function reopenPlanReviewCard(taskId, opts) {
         const recheckReadStart = readStart === undefined ? guardStartedAt : Math.min(readStart, guardStartedAt);
         const sessionKey = opts?.sessionKey ?? DEFAULT_SESSION_KEY;
         if (!hasQuestionOverlayFor(sessionKey)) {
-            return receiptMs === undefined ? { reopened: false } : Promise.resolve({ reopened: false });
+            const noSurface = noPresentationSurfaceVerdict(taskId, sessionKey);
+            return receiptMs === undefined ? noSurface : Promise.resolve(noSurface);
         }
         if (sessionKey !== DEFAULT_SESSION_KEY && opts?.deliverDecision === undefined && opts?.wire === undefined) {
             hostLog('error', `planReviewWire: plan_review 卡未重开 —— sessionKey=${JSON.stringify(sessionKey)} 是非默认槽,` +

package/dist/host.d.ts

@@ -56,7 +56,7 @@ export interface HostPorts {
 }
 export declare function installHost(ports: HostPorts): () => void;
 export declare function installHostFor(sessionKey: string, ports: Omit<HostPorts, 'queue'>): () => void;
-export declare function hostLog(level: AdapterLogLevel, msg: string, data?: unknown): void;
+export declare function hostLog(level: AdapterLogLevel, msg: string, data?: unknown): boolean;
 export declare function hostProbe(channel: string, line: string): void;
 export declare function hostSettings(): SettingsPort | undefined;
 export declare function hostSettingsFor(sessionKey: string): SettingsPort | undefined;

package/dist/host.js

@@ -46,11 +46,20 @@ export function installHostFor(sessionKey, ports) {
         slot.state = prev;
     };
 }
+function callDiagnosticPort(call) {
+    try {
+        call();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function hostLog(level, msg, data) {
-    hostSlot(DEFAULT_SESSION_KEY).state.log?.(level, msg, data);
+    return callDiagnosticPort(() => hostSlot(DEFAULT_SESSION_KEY).state.log?.(level, msg, data));
 }
 export function hostProbe(channel, line) {
-    hostSlot(DEFAULT_SESSION_KEY).state.probe?.(channel, line);
+    callDiagnosticPort(() => hostSlot(DEFAULT_SESSION_KEY).state.probe?.(channel, line));
 }
 export function hostSettings() {
     return hostSettingsFor(DEFAULT_SESSION_KEY);

package/dist/index.d.ts

@@ -169,7 +169,7 @@ export * from './coreValuePorts.js';
 export * from './hitl/askGateWire.js';
 export * from './hitl/planReviewWire.js';
 export { PLAN_REVIEW_QUESTION_ID_PREFIX, REOPEN_ID_TAIL, approvalCallKey, askGateQuestionId, planReviewQuestionId, liveFrameCallKey, armedKeyFromQuestionId, } from './hitl/gateIdentity.js';
-export { _resetArmedGateRegistryForTest, _setGateArmedWaitMsForTest, clearArmedGate, gateArmedWaitMs, notePlanReviewAnswered, onGateArmed, planReviewArmedKey, registerArmedGate, registerArmedGateFor, registerArmedGateFromQuestionId, waitForGateArmed, wasGateArmed, wasGateArmedFor, } from './hitl/armedGateRegistry.js';
+export { _resetArmedGateRegistryForTest, _setGateArmedWaitMsForTest, clearArmedGate, gateArmedWaitMs, notePlanReviewAnswered, onGateArmed, planReviewArmedKey, registerArmedGate, registerArmedGateFor, registerArmedGateFromQuestionId, registerArmedGateFromQuestionIdFor, waitForGateArmed, wasGateArmed, wasGateArmedFor, } from './hitl/armedGateRegistry.js';
 export * from './hitl/parkOwnership.js';
 export * from './hitl/parkRowBirthWait.js';
 export * from './hitl/approvalDecisionNoteAudit.js';

package/dist/index.js

@@ -155,7 +155,7 @@ export * from './coreValuePorts.js';
 export * from './hitl/askGateWire.js';
 export * from './hitl/planReviewWire.js';
 export { PLAN_REVIEW_QUESTION_ID_PREFIX, REOPEN_ID_TAIL, approvalCallKey, askGateQuestionId, planReviewQuestionId, liveFrameCallKey, armedKeyFromQuestionId, } from './hitl/gateIdentity.js';
-export { _resetArmedGateRegistryForTest, _setGateArmedWaitMsForTest, clearArmedGate, gateArmedWaitMs, notePlanReviewAnswered, onGateArmed, planReviewArmedKey, registerArmedGate, registerArmedGateFor, registerArmedGateFromQuestionId, waitForGateArmed, wasGateArmed, wasGateArmedFor, } from './hitl/armedGateRegistry.js';
+export { _resetArmedGateRegistryForTest, _setGateArmedWaitMsForTest, clearArmedGate, gateArmedWaitMs, notePlanReviewAnswered, onGateArmed, planReviewArmedKey, registerArmedGate, registerArmedGateFor, registerArmedGateFromQuestionId, registerArmedGateFromQuestionIdFor, waitForGateArmed, wasGateArmed, wasGateArmedFor, } from './hitl/armedGateRegistry.js';
 export * from './hitl/parkOwnership.js';
 export * from './hitl/parkRowBirthWait.js';
 export * from './hitl/approvalDecisionNoteAudit.js';

package/dist/request/taskRequest.d.ts

@@ -71,6 +71,8 @@ export interface TaskRequestOmission {
     readonly cause: TaskRequestOmissionCause;
 }
 export declare function taskRequestOmissionCauseDetail(cause: unknown): string;
+export declare const TASK_REQUEST_OMISSION_CAUSE_NOTICES: Readonly<Record<TaskRequestOmissionCause, string>>;
+export declare function taskRequestOmissionCauseNotice(cause: unknown): string;
 export interface TaskRequestAssembly {
     readonly request: TaskRequestLike;
     readonly omitted: readonly TaskRequestOmission[];

package/dist/request/taskRequest.js

@@ -75,6 +75,18 @@ export function taskRequestOmissionCauseDetail(cause) {
     const word = typeof cause === 'string' && cause.length > 0 ? cause : '(none)';
     return `a cause this build does not know (${word}) — this build does not know this cause: receipt causes come from this build's own frozen vocabulary, so a word outside it was not produced here; check whatever supplied it`;
 }
+export const TASK_REQUEST_OMISSION_CAUSE_NOTICES = Object.freeze({
+    upstream_absent: 'Not sent with this request: this version has no way to send this setting in any request, so giving it or leaving it out makes no difference to what is sent.',
+    other_channel: 'Not sent from here: that part of the request belongs to a separate step, so what goes out for it, if anything, is decided there rather than by the value given here.',
+    off_lane: 'Not sent with this request: this kind of request does not carry this setting, so giving it or leaving it out makes no difference to what this request sends.',
+    not_live: 'Not sent with this request: the request was marked as not going to a live engine (for example an offline or test run), and this setting is only sent on requests that go to one.',
+});
+const TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_NOTICE = 'Not sent with this request, for a reason this version does not recognize.';
+export function taskRequestOmissionCauseNotice(cause) {
+    return typeof cause === 'string' && Object.hasOwn(TASK_REQUEST_OMISSION_CAUSE_NOTICES, cause)
+        ? TASK_REQUEST_OMISSION_CAUSE_NOTICES[cause]
+        : TASK_REQUEST_OMISSION_UNKNOWN_CAUSE_NOTICE;
+}
 const row = (field) => ({ via: 'matrix', field });
 const INPUT_KEY_ROUTES = {
     objective: { via: 'always' },

package/dist/subagent/subagentOwnerAbsence.js

@@ -11,12 +11,9 @@ export function noteBgOwnerAbsence(leg, taskId) {
             noted.delete(oldest);
     }
     noted.add(key);
-    try {
-        hostLog('warn', `[subagent-owner] ${leg}: no host-run mapping for ${taskId} — not connecting (owner ledger absent ⇒ honest absence; active-run fallback removed per [4000] Q3)`);
-    }
-    catch {
+    const delivered = hostLog('warn', `[subagent-owner] ${leg}: no host-run mapping for ${taskId} — not connecting (owner ledger absent ⇒ honest absence; active-run fallback removed per [4000] Q3)`);
+    if (!delivered)
         noted.delete(key);
-    }
 }
 export function __resetBgOwnerAbsenceForTests() {
     noted.clear();