@sema-agent/client-core 0.83.3 → 0.83.5

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -1,4 +1,5 @@
 import type { ActiveRunBusySignal } from './runStream.js';
+import type { PlanReviewReopenTrigger } from '../hitl/planReviewWire.js';
 export declare const PLAN_REVIEW_GATE_KIND = "plan_review";
 export declare const PLAN_REVIEW_GATE_KINDS: readonly string[];
 export declare const ASK_PARK_GATE_KINDS: readonly string[];
@@ -33,6 +34,7 @@ export type ReopenCardVerdict = {
     decidedWithoutCard?: true;
     pendingRowGone?: true;
     _sema_decisionInFlight?: true;
+    dismissedByUser?: true;
 } | {
     reopened: true;
     firstSight: boolean;
@@ -54,7 +56,9 @@ export interface ActiveRunSelfHealDeps {
     listOwnedPendingApprovals?: (opts?: {
         signal?: AbortSignal;
     }) => Promise<number>;
-    reopenPlanReview?: (taskId: string) => ReopenCardVerdict | Promise<ReopenCardVerdict>;
+    reopenPlanReview?: (taskId: string, opts?: {
+        trigger?: PlanReviewReopenTrigger;
+    }) => ReopenCardVerdict | Promise<ReopenCardVerdict>;
     reopenAskPark?: (taskId: string) => Promise<ReopenCardVerdict>;
     offerRunningChoice?: (req: RunningChoiceRequest) => Promise<'steer' | 'cancel' | 'wait'>;
     offerStaleParkChoice?: (req: StaleParkChoiceRequest) => Promise<'cancel' | 'wait'>;
@@ -81,6 +85,7 @@ export type SelfHealOutcome = {
     decidePath: string | null;
     decisionInFlight?: true;
     pendingRowGone?: true;
+    dismissedByUser?: true;
 } | {
     kind: 'not-parked';
     taskId: string;
@@ -107,6 +112,7 @@ export type SelfHealOutcome = {
     kind: 'ask-decided-without-card';
     taskId: string;
     released: true;
+    releaseConfirmedByEngine?: true;
 } | {
     kind: 'ask-decided-release-unknown';
     taskId: string;
@@ -125,6 +131,7 @@ export type SelfHealOutcome = {
 } | {
     kind: 'running-cancelled';
     taskId: string;
+    releaseConfirmedByEngine?: true;
 } | {
     kind: 'running-cancel-timeout';
     taskId: string;
@@ -142,6 +149,7 @@ export type SelfHealOutcome = {
 } | {
     kind: 'stale-park-cancelled';
     taskId: string;
+    releaseConfirmedByEngine?: true;
 } | {
     kind: 'stale-park-cancel-timeout';
     taskId: string;

package/dist/adapter/activeRunSelfHeal.js

@@ -82,6 +82,16 @@ export function readCancelRequested(body) {
 function reopenRefusedForDecisionInFlight(verdict) {
     return verdict !== null && verdict.reopened === false && verdict._sema_decisionInFlight === true;
 }
+function reopenRefusedForUserDismissal(verdict) {
+    return verdict !== null && verdict.reopened === false && verdict.dismissedByUser === true;
+}
+function planReviewReopenTriggerFor(origin) {
+    if (origin === 'user')
+        return 'user';
+    if (origin === 'injected')
+        return 'automatic';
+    return undefined;
+}
 function reopenDelivered(verdict) {
     return verdict.reopened === true && verdict.presented !== false;
 }
@@ -287,7 +297,9 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
 }
 async function planVerdict(taskId, deps) {
     try {
-        return (await deps?.reopenPlanReview?.(taskId)) ?? { reopened: false };
+        const trigger = planReviewReopenTriggerFor(deps?.submissionOrigin);
+        const verdict = trigger === undefined ? deps?.reopenPlanReview?.(taskId) : deps?.reopenPlanReview?.(taskId, { trigger });
+        return (await verdict) ?? { reopened: false };
     }
     catch {
         return { reopened: false };
@@ -311,6 +323,7 @@ async function planReviewArm(taskId, signal, deps) {
         decidePath: signal.pendingGate?.decidePath ?? null,
         ...(reopenRefusedForDecisionInFlight(verdict) ? { decisionInFlight: true } : {}),
         ...(verdict.pendingRowGone === true ? { pendingRowGone: true } : {}),
+        ...(reopenRefusedForUserDismissal(verdict) ? { dismissedByUser: true } : {}),
     };
 }
 async function askParkArm(taskId, signal, runs, deps) {
@@ -328,8 +341,14 @@ async function askParkArm(taskId, signal, runs, deps) {
             ...(deps?.signal !== undefined ? { signal: deps.signal } : {}),
             ...sessionOpts(deps),
         });
-        if (release.released)
-            return { kind: 'ask-decided-without-card', taskId, released: true };
+        if (release.released) {
+            return {
+                kind: 'ask-decided-without-card',
+                taskId,
+                released: true,
+                ...(release.lastHolder === 'released' ? { releaseConfirmedByEngine: true } : {}),
+            };
+        }
         if (release.lastStatus !== null && RUNNING_STATES.includes(release.lastStatus)) {
             return runningChoiceArm(taskId, release.lastStatus, signal, false, runs, deps);
         }
@@ -434,8 +453,9 @@ async function staleParkArm(taskId, busy, runs, deps) {
     if (stillGone !== 0)
         return reopenFailedAfterCard;
     const verdict = await cancelAndConfirmRelease(taskId, runs, durableGet, deps);
-    if (verdict.outcome === 'released')
-        return { kind: 'stale-park-cancelled', taskId };
+    if (verdict.outcome === 'released') {
+        return { kind: 'stale-park-cancelled', taskId, ...(verdict.engineStatedRelease ? { releaseConfirmedByEngine: true } : {}) };
+    }
     if (verdict.outcome === 'failed') {
         return { kind: 'stale-park-cancel-failed', taskId, detail: verdict.detail, delivery: verdict.delivery };
     }
@@ -475,7 +495,7 @@ async function cancelAndConfirmRelease(taskId, durable, durableGet, deps) {
         ...sessionOpts(deps),
     });
     if (verdict.released)
-        return { outcome: 'released' };
+        return { outcome: 'released', engineStatedRelease: verdict.lastHolder === 'released' };
     if (cancelFailure !== null)
         return { outcome: 'failed', ...cancelFailure };
     return {
@@ -567,8 +587,9 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     }
     if (choice === 'cancel' && canCancel && runs?.cancel !== undefined && runs.get !== undefined) {
         const verdict = await cancelAndConfirmRelease(taskId, runs, runs.get, deps);
-        if (verdict.outcome === 'released')
-            return { kind: 'running-cancelled', taskId };
+        if (verdict.outcome === 'released') {
+            return { kind: 'running-cancelled', taskId, ...(verdict.engineStatedRelease ? { releaseConfirmedByEngine: true } : {}) };
+        }
         if (verdict.outcome === 'failed') {
             return { kind: 'running-cancel-failed', taskId, detail: verdict.detail, delivery: verdict.delivery };
         }
@@ -617,7 +638,8 @@ export function activeRunSelfHealRow(outcome, signal, copy, origin, follow) {
     const engineDecide = copy?.engineDecidePath !== false;
     const keep = (outcome.kind === 'plan-review-reopen-failed' || outcome.kind === 'ask-reopen-failed') &&
         outcome.decisionInFlight !== true &&
-        outcome.pendingRowGone !== true
+        outcome.pendingRowGone !== true &&
+        (outcome.kind !== 'plan-review-reopen-failed' || outcome.dismissedByUser !== true)
         ? keepSessionWayOutOf(copy)
         : null;
     const base = activeRunSelfHealBaseRow(outcome, signal, copy?.wayOut ?? DEFAULT_WAY_OUT, following, keep, engineDecide);
@@ -632,6 +654,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';
 function injectedSubmissionRow(outcome, following = false) {
     const lead = INJECTED_LEAD;
     const id = 'taskId' in outcome && outcome.taskId ? ` (id ${outcome.taskId})` : '';
@@ -647,6 +670,11 @@ function injectedSubmissionRow(outcome, following = false) {
         return (`${lead} was not delivered: this session is still busy with an earlier reply${id}, and your answer to the decision ` +
             `it is waiting on is still on its way. sema did not retry, so the model has not seen it.`);
     }
+    if (outcome.kind === 'plan-review-reopen-failed' && outcome.dismissedByUser === true) {
+        return (`${lead} was not delivered: this session is held by an earlier reply${id} whose plan is waiting for your review, and ` +
+            `you closed that approval card — ${USER_CLOSED_CARD_NOT_PUT_BACK}. Send a message when you want the card back; ` +
+            `sema did not retry, so the model has not seen it.`);
+    }
     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)) {
@@ -655,6 +683,10 @@ function injectedSubmissionRow(outcome, following = false) {
         if (reopenRefusedForDecisionInFlight(outcome.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)) {
+            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.`;
     }
     if (outcome.kind === 'running-steered' && outcome.delivery === 'parked_for_wake') {
@@ -666,8 +698,12 @@ function injectedSubmissionRow(outcome, following = false) {
             return (`${lead} is on hold: this session is busy with an earlier reply${id} that is waiting on a decision. ` +
                 `sema kept the message queued and will send it after you answer the open card.`);
         case 'resending':
-            return (`${lead} was held back because this session was busy with an earlier reply${id}; the session is free again, ` +
-                `so sema is sending the message now — nothing for you to do.`);
+            return 'releaseConfirmedByEngine' in outcome && outcome.releaseConfirmedByEngine === true
+                ? `${lead} was held back because this session was busy with an earlier reply${id}; the session is free again, ` +
+                    `so sema is sending the message now — nothing for you to do.`
+                : `${lead} was held back because this session was busy with an earlier reply${id}; that reply is now reported ` +
+                    `as finished, so sema is sending the message now — nothing for you to do (if the session has not quite ` +
+                    `freed up yet, it may be held back once more).`;
         case 'handed-off':
             return following
                 ? `${lead} was passed to the reply already in progress${id} instead of starting a new one. ` +
@@ -725,8 +761,14 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
                 `reopened it. Answer it and send your message again. (sema did NOT cancel the run: cancelling ` +
                 `would have thrown the plan away on your behalf.)`);
         case 'ask-decided-without-card':
+            if (outcome.releaseConfirmedByEngine === true) {
+                return (`The previous turn was parked on an approval that your permission rules decided on their own (no card was ` +
+                    `needed); run ${outcome.taskId} resumed and the engine confirmed it is no longer holding this session — ` +
+                    `sema is re-sending your message.`);
+            }
             return (`The previous turn was parked on an approval that your permission rules decided on their own (no card was ` +
-                `needed); run ${outcome.taskId} resumed and has since finished — sema is re-sending your message.`);
+                `needed); run ${outcome.taskId} resumed and has since finished — sema is re-sending your message; if that ` +
+                `run has not fully let go of the session yet, you may have to send it once more.`);
         case 'ask-decided-release-unknown':
             return (`The previous turn was parked on an approval that your permission rules decided on their own (no card was ` +
                 `needed), so run ${outcome.taskId} should be resuming` +
@@ -747,6 +789,11 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
         case 'plan-review-reopen-failed': {
             if (outcome.decisionInFlight === true)
                 return decisionInFlightRow(`on a plan review (run ${outcome.taskId})`);
+            if (outcome.dismissedByUser === true) {
+                return (`The previous turn is parked waiting for a plan review (run ${outcome.taskId}), and you closed its approval card — ` +
+                    `${USER_CLOSED_CARD_NOT_PUT_BACK}. It did NOT cancel the run — that would have discarded the plan for you. ` +
+                    `Your message was NOT sent; send it again to bring the card back.`);
+            }
             const viaEngine = engineDecide && outcome.decidePath
                 ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
                 : '';
@@ -774,8 +821,11 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
                     : reopenRefusedForDecisionInFlight(outcome.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.`
-                        : `sema could not surface that decision card here, so nothing will resume that run until that decision is made; ` +
-                            `${wayOut} if you no longer want it.`;
+                        : reopenRefusedForUserDismissal(outcome.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; ` +
+                                `${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} ` +
                     `Nothing was cancelled, and your message did NOT start a new turn.`);
@@ -806,8 +856,12 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
                 `cancel that run. That run may or may not have received your message — watch what it does next ` +
                 `before sending it again.`);
         case 'running-cancelled':
-            return (`You chose to cancel run ${outcome.taskId}. The engine confirmed it is no longer holding this session, ` +
-                `so sema is sending your message now.`);
+            return outcome.releaseConfirmedByEngine === true
+                ? `You chose to cancel run ${outcome.taskId}. The engine confirmed it is no longer holding this session, ` +
+                    `so sema is sending your message now.`
+                : `You chose to cancel run ${outcome.taskId}. The engine now reports that run as finished, so sema is ` +
+                    `sending your message now; if that run has not fully let go of the session yet, you may have to send ` +
+                    `it once more.`;
         case 'running-cancel-timeout': {
             const waited = `${String(Math.max(1, Math.round(outcome.waitedMs / 1000)))}s`;
             if (outcome.aborted) {
@@ -840,6 +894,11 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
                 `not allowed to read. Either way sema has nothing it can act on here, so it did NOT cancel anything. ` +
                 `Your message was NOT sent; send it again (if the session really is free it will just run), or ${wayOut}.`);
         case 'stale-park-cancelled':
+            if (outcome.releaseConfirmedByEngine === true) {
+                return (`Run ${outcome.taskId} was parked on an approval that no longer exists on the engine, so there was ` +
+                    `nothing left for you to answer. You chose to cancel that run, and the engine confirmed it is no longer ` +
+                    `holding this session, so sema is sending your message again now.`);
+            }
             return (`Run ${outcome.taskId} was parked on an approval that no longer exists on the engine, so there was ` +
                 `nothing left for you to answer. You chose to cancel that run: the engine now reports it as finished, ` +
                 `so it will not resume — whatever that turn had left to do is not coming back. sema is sending your ` +

package/dist/compensations.js

@@ -30,7 +30,7 @@ export const MIGRATED_COMPENSATIONS = [
     },
     {
         id: 'T36',
-        what: '子代永不发终态 tick ⇒ 四处防御 sweep 兜住面板行,不让它们永远转圈',
+        what: '子代终态 tick 缺席时(老服务端 / 丢帧 / 断流)四处防御 sweep 兜住面板行,不让它们永远转圈;终态 tick 在场时按它落终态',
         disposition: 'in-library',
         libraryHalf: 'adapt.ts settlePanelTasks 的四个调用点(tool_end 关卡 / result / turn 末 / abort)',
         chromeArm: 'inline_task_stats',

package/dist/displayUntrusted.d.ts

@@ -6,6 +6,7 @@ export interface DisplayFace {
     readonly unsafe: RegExp | null;
     readonly fold: boolean;
     readonly mark: DisplayMark;
+    readonly keepBlanks?: boolean;
 }
 export declare const LEGACY_ESCAPE_FACE: DisplayFace;
 export declare const LEGACY_LABEL_FACE: DisplayFace;
@@ -20,5 +21,17 @@ export interface DisplayUntrustedOptions {
     readonly keepLayout?: boolean;
     readonly mark?: DisplayMark;
     readonly max?: number;
+    readonly escapeBackslashes?: boolean;
+    readonly blanks?: boolean;
+}
+export interface DisplayMarkSpan {
+    readonly start: number;
+    readonly end: number;
+    readonly codePoint: number;
+}
+export interface DisplayUntrustedMarked {
+    readonly text: string;
+    readonly marks: readonly DisplayMarkSpan[];
 }
 export declare function displayUntrusted(text: string, opts?: DisplayUntrustedOptions): string;
+export declare function displayUntrustedMarks(text: string, opts?: DisplayUntrustedOptions): DisplayUntrustedMarked;