@sema-agent/client-core 0.105.0 → 0.107.0

package/dist/adapt/arms.js

@@ -15,7 +15,7 @@ import { readToolHistoryMismatchKey } from '../toolHistoryMismatch.js';
 import { isMintedRowCcError, readProviderRejectionResendKey } from '../providerRejection.js';
 import { rowKindOf } from '../rowKind.js';
 import { terminalCodedDetailOf } from '../runTerminal.js';
-import { contextUsageReadingOf, guardedRead, humanInputAttachmentsOf, ownSnapshotRecord, ownSnapshotWhenTyped, readOwnDataValue, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, workflowCompletionExtrasOf } from '../ownKey.js';
+import { contextUsageReadingOf, guardedRead, humanInputAttachmentsOf, ownSnapshotRecord, ownSnapshotWhenTyped, readOwnDataNonEmptyString, readOwnDataValue, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, workflowCompletionExtrasOf } from '../ownKey.js';
 import { CORE_USER_ATTACHMENT_LABEL_MAX } from '../generated/engineFactTables.js';
 import { ESCAPE_FACE, paintAndCap, washCredentials } from '../displayUntrusted.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
@@ -388,6 +388,13 @@ const approvalFrameArm = (kind) => function* (m) {
         return;
     yield chrome({ kind, laneProof: mainLane(), frame, schemaVersion });
 };
+const sessionTitledArm = function* (m) {
+    const sessionId = guardedRead(() => readOwnDataNonEmptyString(m, 'sessionId'));
+    const title = guardedRead(() => readOwnDataNonEmptyString(m, 'title'));
+    if (sessionId === undefined || title === undefined)
+        return;
+    yield chrome({ kind: 'session_titled', laneProof: mainLane(), sessionId, title });
+};
 const toolDisclosureArm = function* (m) {
     if (isSubFlowSegmentEnd(m))
         return;
@@ -1099,6 +1106,8 @@ export const ARMS = new Map([
     ['wiring_manifest', wiringManifestArm],
     ['approval_request', approvalFrameArm('approval_request')],
     ['approval_revoke', approvalFrameArm('approval_revoke')],
+    ['approval_complete', approvalFrameArm('approval_complete')],
+    ['session_titled', sessionTitledArm],
     ['prompt_suggestions', promptSuggestionsArm],
     ['retry_status', retryStatusArm],
 ]);

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -3,9 +3,10 @@ import type { ActiveRunBusySignal } from './runStream.js';
 import type { RejectedSubmissionOrigin } from '../request/submissionIdentity.js';
 import type { PlanReviewReopenTrigger } from '../hitl/planReviewWire.js';
 import { type AskParkAutoReopenBlock } from '../hitl/askParkAutoReopenBlock.js';
+import { type CheckpointRowVerdictReading } from '../checkpointRowVerdict.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
 export declare const PLAN_REVIEW_GATE_KIND = "plan_review";
-export type DurableDecideLeg = 'approval' | 'plan_review' | 'other_gate' | 'unreadable' | 'absent';
+export type DurableDecideLeg = 'approval' | 'plan_review' | 'other_gate' | 'unreadable';
 export declare function durableDecideLegOf(row: {
     readonly gateKind?: string | null;
 } | null | undefined): DurableDecideLeg;
@@ -44,6 +45,9 @@ export type ReopenCardVerdict = {
     _sema_errorCode?: string;
     _sema_reopenRefusal?: PlanReviewReopenRefusal;
     _sema_policyBlocked?: AskParkAutoReopenBlock;
+    _sema_rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
 } | {
     reopened: true;
     firstSight: boolean;
@@ -87,6 +91,7 @@ export interface ActiveRunSelfHealDeps {
     signal?: AbortSignal;
     cancelReleaseWaitMs?: number;
     submissionOrigin?: RejectedSubmissionOrigin;
+    injectedCarriers?: readonly object[];
     sessionId?: string;
     wasRecentlyTerminatedByUs?: (taskId: string) => boolean;
     interruptedSettle?: InterruptedSettleWindow;
@@ -146,6 +151,9 @@ export type SelfHealOutcome = {
     noPresentationSurface?: true;
     errorCode?: string;
     policyBlocked?: AskParkAutoReopenBlock;
+    rowVerdict?: Exclude<CheckpointRowVerdictReading, {
+        readonly kind: 'ok';
+    }>;
 } | {
     kind: 'ask-decided-without-card';
     taskId: string;
@@ -161,6 +169,7 @@ export type SelfHealOutcome = {
     delivery: string | null;
     status: string | null;
     reopened: ReopenCardVerdict | null;
+    messageId?: string;
 } | {
     kind: 'running-steer-failed';
     taskId: string;
@@ -171,6 +180,12 @@ export type SelfHealOutcome = {
 } | {
     kind: 'running-attach';
     taskId: string;
+} | {
+    kind: 'injected-redundant';
+    taskId: string;
+} | {
+    kind: 'injected-deferred';
+    taskId: string;
 } | {
     kind: 'running-cancelled';
     taskId: string;
@@ -215,7 +230,7 @@ export type SelfHealOutcome = {
     alreadyOffered?: true;
 };
 export type { RejectedSubmissionOrigin };
-export type SelfHealSubmissionDisposition = 'held-for-decision' | 'resending' | 'handed-off' | 'not-delivered';
+export type SelfHealSubmissionDisposition = 'held-for-decision' | 'resending' | 'handed-off' | 'not-delivered' | 'superseded' | 'deferred';
 export declare function selfHealSubmissionDisposition(outcome: SelfHealOutcome): SelfHealSubmissionDisposition;
 export type SteerFollowIntent = {
     kind: 'tail';
@@ -226,11 +241,15 @@ export type SteerFollowIntent = {
 } | {
     kind: 'after-wake';
     taskId: string;
+} | {
+    kind: 'follow-resumed';
+    taskId: string;
 };
 export declare function steerFollowIntent(outcome: SelfHealOutcome | null | undefined): SteerFollowIntent | null;
 export interface SelfHealFollowDeclaration {
     following?: boolean;
 }
+export declare function injectedResubmitAfter(outcome: SelfHealOutcome | null | undefined, runStatus: string | null | undefined): boolean;
 export declare function readCancelRequested(body: unknown): boolean | undefined;
 export { atMostOnceFailureClass };
 export declare function clearRunningChoiceOffer(taskId: string, sessionId?: string): void;

package/dist/adapter/activeRunSelfHeal.js

@@ -6,6 +6,8 @@ import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { ASK_PARK_AUTO_REOPEN_BLOCKS, askParkAutoReopenBlockedContent } from '../hitl/askParkAutoReopenBlock.js';
 import { corruptStoredRowContent, corruptStoredRowWhere, effectiveWireErrorCode } from '../wireErrorTriage.js';
 import { readThrownStatusSlot } from '../wireFailureShape.js';
+import { checkpointRowBarOf, checkpointRowBarSentence } from '../checkpointRowVerdict.js';
+import { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { steerBodyOf, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
 import { readSteerReceipt } from '../steerReceipt.js';
@@ -28,7 +30,7 @@ function gateKindReadingOf(row) {
         return { leg: 'unreadable', kind: null };
     }
     if (typeof kind !== 'string' || kind === '')
-        return { leg: 'absent', kind: null };
+        return { leg: 'unreadable', kind: null };
     if (APPROVAL_LEG_GATE_KINDS.includes(kind))
         return { leg: 'approval', kind };
     if (PLAN_LEG_GATE_KINDS.includes(kind))
@@ -42,7 +44,7 @@ export function durableDecideLegOf(row) {
 }
 export function askParkForeignGateKind(row) {
     const r = gateKindReadingOf(row);
-    return r.leg === 'approval' || r.leg === 'absent' ? null : (r.kind ?? '(unreadable)');
+    return r.leg === 'approval' ? null : (r.kind ?? '(unreadable)');
 }
 export const PLAN_REVIEW_STATES = Object.freeze(['needs_review']);
 export const ASK_PARK_STATES = Object.freeze(['suspended']);
@@ -70,12 +72,20 @@ export function selfHealSubmissionDisposition(outcome) {
             return 'not-delivered';
         case 'running-attach':
             return 'not-delivered';
+        case 'injected-redundant':
+            return 'superseded';
+        case 'injected-deferred':
+            return 'deferred';
         default:
             return 'not-delivered';
     }
 }
 export function steerFollowIntent(outcome) {
-    if (typeof outcome !== 'object' || outcome === null || outcome.kind !== 'running-steered')
+    if (typeof outcome !== 'object' || outcome === null)
+        return null;
+    if (outcome.kind === 'injected-redundant')
+        return { kind: 'follow-resumed', taskId: outcome.taskId };
+    if (outcome.kind !== 'running-steered')
         return null;
     const taskId = outcome.taskId;
     if (outcome.delivery === 'queued')
@@ -84,6 +94,64 @@ export function steerFollowIntent(outcome) {
         return { kind: 'after-wake', taskId };
     return { kind: 'tail', taskId };
 }
+const injectedResubmitReleased = new WeakSet();
+export function injectedResubmitAfter(outcome, runStatus) {
+    try {
+        if (typeof outcome !== 'object' || outcome === null || outcome.kind !== 'injected-deferred')
+            return false;
+        if (!isSdkRunTerminal(runStatus) && !isSdkRunParked(runStatus))
+            return false;
+        if (injectedResubmitReleased.has(outcome))
+            return false;
+        injectedResubmitReleased.add(outcome);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const PLAN_REVIEW_CARRIER_KEY = '_sema_planReviewOutcome';
+function planReviewCarrierOf(item) {
+    const meta = guardedRead(() => (typeof item === 'object' && item !== null && !Array.isArray(item) ? readOwnDataValue(item, PLAN_REVIEW_CARRIER_KEY) : undefined));
+    if (guardedRead(() => typeof meta === 'object' && meta !== null && !Array.isArray(meta)) !== true)
+        return null;
+    return { run: guardedRead(() => readOwnDataNonEmptyString(meta, 'taskId')) };
+}
+function injectedCarrierVerdict(items, busyTaskId) {
+    const length = guardedRead(() => (Array.isArray(items) ? readOwnDataValue(items, 'length') : undefined));
+    if (typeof length !== 'number' || !Number.isSafeInteger(length) || length <= 0)
+        return null;
+    const keys = guardedRead(() => Object.keys(items));
+    if (!Array.isArray(keys))
+        return null;
+    let present = 0;
+    let carriers = 0;
+    let allNameBusyRun = true;
+    for (let k = 0; k < keys.length; k++) {
+        const key = keys[k];
+        const index = Number(key);
+        if (typeof key !== 'string' || !Number.isSafeInteger(index) || index < 0 || index >= length || String(index) !== key)
+            continue;
+        present++;
+        const carrier = planReviewCarrierOf(guardedRead(() => readOwnDataValue(items, key)));
+        if (carrier === null) {
+            allNameBusyRun = false;
+            continue;
+        }
+        carriers++;
+        if (carrier.run === undefined || carrier.run !== busyTaskId)
+            allNameBusyRun = false;
+    }
+    if (carriers === 0)
+        return null;
+    return allNameBusyRun && present === length ? 'redundant' : 'deferred';
+}
+function injectedCarrierVerdictOf(deps, busyTaskId) {
+    return deps?.submissionOrigin === 'injected' ? injectedCarrierVerdict(guardedRead(() => deps?.injectedCarriers), busyTaskId) : null;
+}
+function runSettledOutcome(carrierVerdict, settled) {
+    return carrierVerdict === 'redundant' ? { kind: 'injected-redundant', taskId: settled.taskId } : settled;
+}
 function sessionOpts(deps) {
     const sessionId = deps?.sessionId;
     return typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {};
@@ -146,6 +214,7 @@ const REOPEN_VERDICT_KEYS = [
     '_sema_errorCode',
     '_sema_reopenRefusal',
     '_sema_policyBlocked',
+    '_sema_rowVerdict',
 ];
 function snapshotReopenVerdict(raw) {
     if (raw === null || raw === undefined)
@@ -259,6 +328,16 @@ function reopenPolicyBlockedOf(verdict) {
         return undefined;
     }
 }
+function reopenRowVerdictOf(verdict) {
+    try {
+        if (verdict.reopened !== false)
+            return undefined;
+        return checkpointRowBarOf({ rowVerdict: verdict._sema_rowVerdict });
+    }
+    catch {
+        return undefined;
+    }
+}
 function reopenRefusalOf(verdict) {
     try {
         if (verdict.reopened !== false)
@@ -522,14 +601,15 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
             detail: 'the engine did not name the run that holds this session',
         };
     }
+    const carrierVerdict = injectedCarrierVerdictOf(deps, taskId);
     const gateKind = signal.pendingGate?.kind ?? null;
-    const gateLeg = gateKind !== null ? durableDecideLegOf({ gateKind }) : 'absent';
+    const gateLeg = durableDecideLegOf({ gateKind });
     const pendingCp = signal.pendingGate?.checkpointId;
     const sameTaskCp = pendingCp !== undefined && registeredPlanReviewCardFacts(DEFAULT_SESSION_KEY, taskId, pendingCp) !== undefined ? pendingCp : undefined;
     if (gateLeg === 'plan_review')
         return planReviewArm(taskId, signal, deps, sameTaskCp);
     if (gateLeg === 'approval')
-        return askParkArm(taskId, signal, runs, deps);
+        return askParkArm(taskId, signal, runs, carrierVerdict, deps);
     let status = signal.activeTaskStatus;
     const statusFresh = status === null;
     if (status === null) {
@@ -549,16 +629,16 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
         return { kind: 'state-unknown', taskId, detail: 'the engine reported no status for that run' };
     }
     if (isSdkRunTerminal(status))
-        return { kind: 'running-settled', taskId, status };
+        return runSettledOutcome(carrierVerdict, { kind: 'running-settled', taskId, status });
     const triageGate = signal.pendingGate && !statusFresh ? { pendingGateKind: signal.pendingGate.kind ?? null } : {};
     if (gateKind !== null)
         return { kind: 'not-parked', taskId, status, ...triageGate };
     if (PLAN_REVIEW_STATES.includes(status))
         return planReviewArm(taskId, signal, deps);
     if (ASK_PARK_STATES.includes(status))
-        return askParkArm(taskId, signal, runs, deps);
+        return askParkArm(taskId, signal, runs, carrierVerdict, deps);
     if (RUNNING_STATES.includes(status)) {
-        return runningChoiceArm(taskId, status, signal, signal.activeTaskStatus !== null, runs, deps);
+        return runningChoiceArm(taskId, status, signal, signal.activeTaskStatus !== null, runs, carrierVerdict, deps);
     }
     return { kind: 'not-parked', taskId, status, ...triageGate };
 }
@@ -607,7 +687,7 @@ async function planReviewArm(taskId, signal, deps, checkpointId) {
         ...(reopenRefusal !== undefined ? { reopenRefusal } : {}),
     };
 }
-async function askParkArm(taskId, signal, runs, deps) {
+async function askParkArm(taskId, signal, runs, carrierVerdict, deps) {
     const verdict = await askVerdict(taskId, deps);
     if (reopenDelivered(verdict))
         return { kind: 'ask-reopened', taskId, firstSight: verdict.firstSight === true };
@@ -631,17 +711,18 @@ async function askParkArm(taskId, signal, runs, deps) {
             };
         }
         if (release.lastStatus !== null && RUNNING_STATES.includes(release.lastStatus)) {
-            return runningChoiceArm(taskId, release.lastStatus, signal, false, runs, deps);
+            return runningChoiceArm(taskId, release.lastStatus, signal, false, runs, carrierVerdict, deps);
         }
         return { kind: 'ask-decided-release-unknown', taskId, lastStatus: release.lastStatus };
     }
     const inFlight = reopenRefusedForDecisionInFlight(verdict);
     if (verdict.reopened === false && verdict.decidedWithoutCard !== true && verdict.pendingRowGone === true && !inFlight) {
-        return staleParkArm(taskId, signal, runs, deps);
+        return staleParkArm(taskId, signal, runs, carrierVerdict, deps);
     }
     const noView = reopenRefusedForNoPresentationSurface(verdict);
     const policyBlocked = inFlight || noView ? undefined : reopenPolicyBlockedOf(verdict);
-    const errorCode = inFlight || noView || reopenRefusedForUserDismissal(verdict) || policyBlocked !== undefined ? undefined : reopenErrorCodeOf(verdict);
+    const rowVerdict = inFlight ? undefined : reopenRowVerdictOf(verdict);
+    const errorCode = inFlight || noView || reopenRefusedForUserDismissal(verdict) || policyBlocked !== undefined || rowVerdict !== undefined ? undefined : reopenErrorCodeOf(verdict);
     return {
         kind: 'ask-reopen-failed',
         taskId,
@@ -651,6 +732,7 @@ async function askParkArm(taskId, signal, runs, deps) {
         ...(noView ? { noPresentationSurface: true } : {}),
         ...(errorCode !== undefined ? { errorCode } : {}),
         ...(policyBlocked !== undefined ? { policyBlocked } : {}),
+        ...(rowVerdict !== undefined ? { rowVerdict } : {}),
     };
 }
 async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
@@ -677,7 +759,7 @@ async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
         status = readStatusGuarded(record);
     return errorCode !== undefined ? { status, ghost, errorCode } : { status, ghost };
 }
-async function staleParkArm(taskId, busy, runs, deps) {
+async function staleParkArm(taskId, busy, runs, carrierVerdict, deps) {
     const reopenFailed = {
         kind: 'ask-reopen-failed',
         taskId,
@@ -705,11 +787,11 @@ async function staleParkArm(taskId, busy, runs, deps) {
     if (fresh === null)
         return withFailureCode(reopenFailed, first.errorCode);
     if (RUNNING_STATES.includes(fresh))
-        return runningChoiceArm(taskId, fresh, busy, false, runs, deps);
+        return runningChoiceArm(taskId, fresh, busy, false, runs, carrierVerdict, deps);
     if (PLAN_REVIEW_STATES.includes(fresh))
         return planReviewArm(taskId, busy, deps);
     if (isSdkRunTerminal(fresh))
-        return { kind: 'ask-run-settled', taskId, status: fresh };
+        return runSettledOutcome(carrierVerdict, { kind: 'ask-run-settled', taskId, status: fresh });
     if (!ASK_PARK_STATES.includes(fresh))
         return reopenFailed;
     const offer = deps?.offerStaleParkChoice;
@@ -748,7 +830,7 @@ async function staleParkArm(taskId, busy, runs, deps) {
         return withFailureCode(reopenFailedAfterCard, afterCard.errorCode);
     if (!ASK_PARK_STATES.includes(afterCard.status)) {
         if (isSdkRunTerminal(afterCard.status))
-            return { kind: 'ask-run-settled', taskId, status: afterCard.status };
+            return runSettledOutcome(carrierVerdict, { kind: 'ask-run-settled', taskId, status: afterCard.status });
         if (RUNNING_STATES.includes(afterCard.status))
             return { kind: 'not-parked', taskId, status: afterCard.status };
         return !CLAIM_HELD_STATES.includes(afterCard.status) ? reopenFailed : reopenFailedAfterCard;
@@ -810,7 +892,7 @@ async function cancelAndConfirmRelease(taskId, durable, durableGet, deps) {
             (verdict.lastStatus !== null && CLAIM_HELD_STATES.includes(verdict.lastStatus)),
     };
 }
-async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps) {
+async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, carrierVerdict, deps) {
     const notParked = { kind: 'not-parked', taskId, status };
     const offer = deps?.offerRunningChoice;
     const injected = deps?.submissionOrigin === 'injected';
@@ -820,9 +902,9 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     const canSteer = typeof runs?.steer === 'function' && text.length > 0;
     const canCancel = typeof runs?.cancel === 'function' && typeof runs?.get === 'function';
     const canAttach = runningAttachOffered(deps?.canAttachRunning);
-    if (!canSteer && !canCancel && !canAttach)
+    if (!canSteer && !canCancel && !canAttach && carrierVerdict === null)
         return notParked;
-    if (injected && !canSteer)
+    if (injected && !canSteer && carrierVerdict === null)
         return notParked;
     const probeCallerAborted = () => deps?.signal?.aborted === true;
     if (statusFromWire && typeof runs?.get === 'function' && !probeCallerAborted()) {
@@ -833,7 +915,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
         if (probeCallerAborted())
             return notParked;
         if (fresh !== null) {
-            const routed = await routeFreshNonRunning(fresh, taskId, busy, runs, deps);
+            const routed = await routeFreshNonRunning(fresh, taskId, busy, runs, deps, carrierVerdict);
             if (routed !== undefined)
                 return routed;
         }
@@ -847,6 +929,10 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     if (injected) {
         if (probeCallerAborted())
             return notParked;
+        if (carrierVerdict === 'redundant')
+            return { kind: 'injected-redundant', taskId };
+        if (carrierVerdict === 'deferred')
+            return { kind: 'injected-deferred', taskId };
         choice = 'steer';
     }
     else if (typeof offer === 'function') {
@@ -870,16 +956,17 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     if (choice === 'steer' && canSteer && runs?.steer !== undefined) {
         try {
             const receipt = await runs.steer(taskId, steerBodyOf({ text }, UNOBSERVED_STEER_PRIORITY), sessionOpts(deps));
-            const { delivery, status: receiptStatus } = readSteerReceipt(receipt);
+            const { delivery, status: receiptStatus, messageId } = readSteerReceipt(receipt);
+            const handedId = messageId !== undefined ? { messageId } : {};
             if (delivery === 'queued') {
                 const verdict = receiptStatus !== null && PLAN_REVIEW_STATES.includes(receiptStatus)
                     ? await planVerdict(taskId, deps)
                     : receiptStatus !== null && ASK_PARK_STATES.includes(receiptStatus)
                         ? await askVerdict(taskId, deps)
                         : null;
-                return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: verdict };
+                return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: verdict, ...handedId };
             }
-            return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: null };
+            return { kind: 'running-steered', taskId, delivery, status: receiptStatus, reopened: null, ...handedId };
         }
         catch (e) {
             const delivery = atMostOnceFailureClass(e);
@@ -908,7 +995,7 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
             return { kind: 'running-not-found', taskId };
         if (probeCallerAborted() || preFire.status === null)
             return notParked;
-        const rerouted = await routeFreshNonRunning(preFire.status, taskId, busy, runs, deps);
+        const rerouted = await routeFreshNonRunning(preFire.status, taskId, busy, runs, deps, carrierVerdict);
         if (rerouted !== undefined)
             return rerouted;
         const verdict = await cancelAndConfirmRelease(taskId, runs, runs.get, deps);
@@ -930,15 +1017,15 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
         return { kind: 'running-attach', taskId };
     return notParked;
 }
-async function routeFreshNonRunning(fresh, taskId, busy, runs, deps) {
+async function routeFreshNonRunning(fresh, taskId, busy, runs, deps, carrierVerdict) {
     if (RUNNING_STATES.includes(fresh))
         return undefined;
     if (PLAN_REVIEW_STATES.includes(fresh))
         return planReviewArm(taskId, busy, deps);
     if (ASK_PARK_STATES.includes(fresh))
-        return askParkArm(taskId, busy, runs, deps);
+        return askParkArm(taskId, busy, runs, carrierVerdict, deps);
     if (isSdkRunTerminal(fresh))
-        return { kind: 'running-settled', taskId, status: fresh };
+        return runSettledOutcome(carrierVerdict, { kind: 'running-settled', taskId, status: fresh });
     return { kind: 'not-parked', taskId, status: fresh };
 }
 export const INTERACTIVE_WAY_OUT = EN_MESSAGES['session.selfHeal.wayOut.interactive'];
@@ -998,7 +1085,7 @@ export function activeRunSelfHealRow(outcome, signal, copy, origin, follow, lang
     if (typeof override === 'string')
         return override;
     const following = follow?.following === true && steerFollowIntent(outcome)?.kind === 'tail';
-    if (origin === 'injected')
+    if (origin === 'injected' || outcome.kind === 'injected-redundant' || outcome.kind === 'injected-deferred')
         return injectedSubmissionRow(outcome, following, lang);
     const engineDecide = copy?.engineDecidePath !== false;
     const keep = (outcome.kind === 'plan-review-reopen-failed' || outcome.kind === 'ask-reopen-failed') &&
@@ -1071,6 +1158,10 @@ function injectedSubmissionRow(outcome, following = false, lang) {
             return following
                 ? say(lang, 'session.selfHeal.injected.handedOffFollowing', { lead, id })
                 : say(lang, 'session.selfHeal.injected.handedOffWatch', { lead, id });
+        case 'superseded':
+            return say(lang, 'session.selfHeal.injected.redundant', { lead, id });
+        case 'deferred':
+            return say(lang, 'session.selfHeal.injected.deferred', { lead, id });
         case 'not-delivered': {
             const noView = (outcome.kind === 'ask-reopen-failed' || outcome.kind === 'plan-review-reopen-failed') && outcome.noPresentationSurface === true
                 ? msg('session.selfHeal.noCardView.inParens')
@@ -1120,6 +1211,13 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
         case 'ask-reopen-failed': {
             if (outcome.decisionInFlight === true)
                 return decisionInFlightRow('ask', outcome.taskId, lang);
+            if (outcome.rowVerdict !== undefined) {
+                return say(lang, 'session.selfHeal.row.askReopenFailed.rowUnresumable', {
+                    taskId: outcome.taskId,
+                    sentence: checkpointRowBarSentence(outcome.rowVerdict),
+                    unbound: msg('approval.decide.unboundWayOut'),
+                });
+            }
             if (outcome.policyBlocked !== undefined)
                 return askParkAutoReopenBlockedContent(outcome.policyBlocked, outcome.taskId, 'interactive', lang);
             const viaEngine = engineDecide && outcome.decidePath ? msg('session.selfHeal.viaEngine', { decidePath: outcome.decidePath }) : '';
@@ -1182,6 +1280,9 @@ function activeRunSelfHealBaseRow(outcome, wayOut, following = false, keepSessio
             return outcome.delivery === 'rejected'
                 ? say(lang, 'session.selfHeal.row.steerFailed.rejected', { taskId: outcome.taskId, detail: outcome.detail })
                 : say(lang, 'session.selfHeal.row.steerFailed.unknown', { taskId: outcome.taskId, detail: outcome.detail });
+        case 'injected-redundant':
+        case 'injected-deferred':
+            return injectedSubmissionRow(outcome, following, lang);
         case 'running-attach':
             return say(lang, 'session.selfHeal.row.attach', { disclosure: resumeAttachReplayDisclosure(outcome.taskId) });
         case 'running-cancelled':

package/dist/adapter/downstream/eventToSdkMessage.d.ts

@@ -60,11 +60,6 @@ export interface WiringManifestAutoConsolidationView {
 export interface WiringManifestReadDenyView {
     builtinTiers: readonly string[];
 }
-export interface WiringManifestHookEntryView {
-    family: string;
-    owner: string;
-    observational?: true;
-}
 export interface WiringManifestLspSeamView {
     mounted: boolean;
     lane?: string;

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -42,7 +42,9 @@ export const INTERNAL_SDK_ARM_TYPES = frozenSet([
     'wiring_manifest',
     'approval_request',
     'approval_revoke',
+    'approval_complete',
     'message_committed',
+    'session_titled',
 ]);
 function assistantArm(ctx, content, eventId, parentToolCallId, recovered) {
     const id = typeof eventId === 'string' && eventId.length > 0 ? eventId : undefined;
@@ -113,7 +115,14 @@ function projectEvent(ev, ctx) {
         return compactionStartedProjection(ev, ctx);
     if (isBeyondFloorArm(ev)) {
         const word = ev.type;
-        return word === 'cross_boundary_taint' ? nothing('not_in_slice') : dropped('unsupported_arm', word);
+        if (word === 'cross_boundary_taint')
+            return nothing('not_in_slice');
+        if (word === 'session_titled')
+            return sessionTitledProjection(ev, ctx);
+        const body = approvalFrameBody(ev);
+        if (body === undefined)
+            return dropped('malformed', 'approval_complete');
+        return projected(internalArmExit(stamp(ctx, armBody({ type: 'approval_complete', ...body }))));
     }
     switch (ev.type) {
         case 'task_started':
@@ -632,7 +641,6 @@ function wiringManifestSupersetBody(ev) {
     const autoMode = projectAutoModeSection(ev.autoMode);
     const mcp = projectMcpSection(ev.mcp);
     const tools = projectToolRoster(ev);
-    const hooks = projectHooksSection(ev.hooks);
     const lsp = projectLspSection(ev.lsp);
     const writeProtection = projectWriteProtectionSection(ev.writeProtection);
     const autoConsolidation = projectAutoConsolidationSection(ev.autoConsolidation);
@@ -642,14 +650,13 @@ function wiringManifestSupersetBody(ev) {
     const instructions = readInstructionsSegment(ev, 'instructions');
     const fleet = readFleetSegment(ev, 'fleet');
     const mods = projectModsSection(ev);
-    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && hooks === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined && fileHistory === undefined && instructions === undefined && fleet === undefined && mods === undefined)
+    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined && fileHistory === undefined && instructions === undefined && fleet === undefined && mods === undefined)
         return undefined;
     return {
         ...(modelGate !== undefined ? { _sema_modelGate: modelGate } : {}),
         ...(autoMode !== undefined ? { _sema_autoMode: autoMode } : {}),
         ...(mcp !== undefined ? { _sema_mcp: mcp } : {}),
         ...(tools !== undefined ? { _sema_tools: tools } : {}),
-        ...(hooks !== undefined ? { _sema_hooks: hooks } : {}),
         ...(lsp !== undefined ? { _sema_lsp: lsp } : {}),
         ...(writeProtection !== undefined ? { _sema_writeProtection: writeProtection } : {}),
         ...(autoConsolidation !== undefined ? { _sema_autoConsolidation: autoConsolidation } : {}),
@@ -710,20 +717,6 @@ function projectModsSection(holder) {
         return undefined;
     }
 }
-function projectHooksSection(raw) {
-    if (!Array.isArray(raw))
-        return undefined;
-    const rows = [];
-    for (const r of raw) {
-        if (typeof r !== 'object' || r === null || Array.isArray(r))
-            continue;
-        const o = r;
-        if (typeof o.family !== 'string' || o.family.length === 0 || typeof o.owner !== 'string' || o.owner.length === 0)
-            continue;
-        rows.push({ family: o.family, owner: o.owner, ...(o.observational === true ? { observational: true } : {}) });
-    }
-    return rows.length > 0 ? rows : undefined;
-}
 function projectLspSection(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
         return undefined;
@@ -809,6 +802,13 @@ function compactionOutcomeProjection(frame, ctx) {
         ...identity,
     }))));
 }
+function sessionTitledProjection(frame, ctx) {
+    const sessionId = guardedRead(() => readOwnDataNonEmptyString(frame, 'sessionId'));
+    const title = guardedRead(() => readOwnDataNonEmptyString(frame, 'title'));
+    if (sessionId === undefined || title === undefined)
+        return dropped('malformed', 'session_titled');
+    return projected(internalArmExit(stamp(ctx, armBody({ type: 'session_titled', sessionId, title }))));
+}
 function compactionStartedProjection(frame, ctx) {
     const ev = frame;
     const { identity, bad } = identityOrMalformed(ev, 'compaction_started');
@@ -917,7 +917,8 @@ function engineNoticeProjection(ev, ctx) {
         ...(seq !== undefined ? { eventSeq: seq } : {}),
     })));
 }
-function approvalFrameBody(ev) {
+function approvalFrameBody(frame) {
+    const ev = frame;
     const schemaVersion = typeof ev.schemaVersion === 'number' && Number.isFinite(ev.schemaVersion)
         ? ev.schemaVersion
         : undefined;

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -702,12 +702,11 @@ export function doneToSdkResult(ev, ctx, observed) {
 }
 function doneToSdkResultBody(ev, ctx, observed) {
     const view = doneResultView(ev.result);
-    const rRaw = view.engine;
+    const rRaw = view.body;
     const rec = typeof rRaw === 'object' && rRaw !== null ? rRaw : {};
     const r = rec;
     const stats = r.stats;
-    const nestedSid = r.sessionId;
-    const echoedSid = typeof nestedSid === 'string' && nestedSid.length > 0 ? nestedSid : view.row?.sessionId;
+    const echoedSid = r.sessionId;
     if (typeof echoedSid === 'string' && echoedSid.length > 0)
         ctx.sessionId = echoedSid;
     const terminal = readRunTerminal(ev.result);

package/dist/adapter/downstream/wiringManifestView.d.ts

@@ -1,11 +1,10 @@
-import type { WiringManifestModelGate, WiringManifestAutoMode, WiringManifestMcpEntryView, WiringManifestHookEntryView, WiringManifestLspSeamView, WiringManifestWriteProtectionView, WiringManifestAutoConsolidationView, WiringManifestReadDenyView, WiringManifestModView } from './eventToSdkMessage.js';
+import type { WiringManifestModelGate, WiringManifestAutoMode, WiringManifestMcpEntryView, WiringManifestLspSeamView, WiringManifestWriteProtectionView, WiringManifestAutoConsolidationView, WiringManifestReadDenyView, WiringManifestModView } from './eventToSdkMessage.js';
 import type { ToolRosterView, WiringManifestHandsView } from '../../toolRoster.js';
 export type WiringManifestSections = {
     _sema_modelGate?: WiringManifestModelGate;
     _sema_autoMode?: WiringManifestAutoMode;
     _sema_mcp?: WiringManifestMcpEntryView[];
     _sema_tools?: ToolRosterView;
-    _sema_hooks?: WiringManifestHookEntryView[];
     _sema_lsp?: WiringManifestLspSeamView;
     _sema_writeProtection?: WiringManifestWriteProtectionView;
     _sema_autoConsolidation?: WiringManifestAutoConsolidationView;
@@ -27,7 +26,6 @@ export interface WiringManifestView {
     autoMode?: WiringManifestAutoMode;
     mcp?: readonly WiringManifestMcpEntryView[];
     tools?: ToolRosterView;
-    hooks?: readonly WiringManifestHookEntryView[];
     lsp?: WiringManifestLspSeamView;
     writeProtection?: WiringManifestWriteProtectionView;
     autoConsolidation?: WiringManifestAutoConsolidationView;

package/dist/adapter/downstream/wiringManifestView.js

@@ -51,7 +51,6 @@ export function wiringManifestViewOf(s) {
         ...(isObj(s._sema_autoMode) ? { autoMode: s._sema_autoMode } : {}),
         ...(Array.isArray(s._sema_mcp) ? { mcp: s._sema_mcp } : {}),
         ...(isObj(s._sema_tools) ? { tools: s._sema_tools } : {}),
-        ...(Array.isArray(s._sema_hooks) ? { hooks: s._sema_hooks } : {}),
         ...(isObj(s._sema_lsp) ? { lsp: s._sema_lsp } : {}),
         ...(isObj(s._sema_writeProtection) ? { writeProtection: s._sema_writeProtection } : {}),
         ...(isObj(s._sema_autoConsolidation) ? { autoConsolidation: s._sema_autoConsolidation } : {}),