@sema-agent/client-core 0.83.4 → 0.83.6

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -112,6 +112,7 @@ export type SelfHealOutcome = {
     kind: 'ask-decided-without-card';
     taskId: string;
     released: true;
+    releaseConfirmedByEngine?: true;
 } | {
     kind: 'ask-decided-release-unknown';
     taskId: string;
@@ -130,6 +131,7 @@ export type SelfHealOutcome = {
 } | {
     kind: 'running-cancelled';
     taskId: string;
+    releaseConfirmedByEngine?: true;
 } | {
     kind: 'running-cancel-timeout';
     taskId: string;
@@ -147,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

@@ -341,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);
         }
@@ -447,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 };
     }
@@ -488,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 {
@@ -580,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 };
         }
@@ -690,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. ` +
@@ -749,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` +
@@ -838,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) {
@@ -872,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;