@sema-agent/client-core 0.104.1 → 0.106.0

package/dist/adapt/arms.js

@@ -2,7 +2,7 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../gateOutcome.js';
 import { terminalOwnerOf } from '../seam.js';
 import { isSubFlowSegmentEnd, SEGMENT_END_IDENTITY_KEYS, snapshotSegmentIdentity, snapshotIsSubFlow } from '../adapter/types.js';
 import { classifyPeerNotification, renderPeerFrameTranscriptText } from '../peerFrames.js';
-import { dropQueuedNotificationsForRun, freezeTaskNotificationFields, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, markEngineWorkflowNotified, noteOwnWorkflowRun, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, renderTaskNotificationXml, taskNotificationDedupKey } from '../notifications.js';
+import { dropQueuedNotificationsForRun, freezeTaskNotificationFields, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, markEngineWorkflowNotified, noteOwnWorkflowRun, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, renderTaskNotificationXml, taskNotificationRenderKeys } from '../notifications.js';
 import { retryStatusFromArm } from '../retryStatus.js';
 import { steeringInjectedToAttachments } from '../steering.js';
 import { projectDiagnosticsFrame } from '../diagnostics.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 } 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;
@@ -961,15 +968,19 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
                 : {}),
         });
     }
-    const dedupKey = taskNotificationDedupKey({
+    const dedupKeys = taskNotificationRenderKeys({
         taskId,
         status: rawStatus,
         ...(typeof n.seq === 'number' || typeof n.seq === 'string' ? { seq: n.seq } : {}),
         ...(typeof n.task_type === 'string' ? { taskType: n.task_type } : {}),
+        ...(fields.completionId !== undefined ? { completionId: fields.completionId } : {}),
     });
-    if (inst.hasRenderedNotification(dedupKey))
+    const sameFrameSeen = inst.hasRenderedNotification(dedupKeys[0]);
+    const sameCompletionSeen = !sameFrameSeen && dedupKeys.slice(1).some((k) => inst.hasRenderedNotification(k));
+    for (const k of dedupKeys)
+        inst.addRenderedNotification(k);
+    if (sameFrameSeen)
         return;
-    inst.addRenderedNotification(dedupKey);
     if (n.task_type !== 'external' && terminal) {
         yield chrome({
             kind: 'notification_terminal',
@@ -990,6 +1001,8 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
     if (peerFrame === null && n.task_type !== 'external')
         markEngineWorkflowNotified(taskId);
     const fact = peerFrame === null ? freezeTaskNotificationFields(fields) : undefined;
+    if (sameCompletionSeen)
+        return;
     yield transcript({
         type: 'user',
         message: {
@@ -1019,7 +1032,8 @@ const workflowCompleteArm = function* (frame) {
     const wfStatus = m.status === 'failed' ? 'failed' : 'completed';
     const wfSummary = typeof m.summary === 'string' ? m.summary : '';
     noteWorkflowCompletionCardEnqueued(runId);
-    const notification = freezeTaskNotificationFields({ taskId: runId, taskType: 'workflow', status: wfStatus, summary: wfSummary });
+    const extras = workflowCompletionExtrasOf(m);
+    const notification = freezeTaskNotificationFields({ taskId: runId, taskType: 'workflow', status: wfStatus, summary: wfSummary, ...(extras.completionId !== undefined ? { completionId: extras.completionId } : {}) });
     yield chrome({
         kind: 'workflow_notification_enqueue',
         laneProof: mainLane(),
@@ -1028,6 +1042,7 @@ const workflowCompleteArm = function* (frame) {
         summary: wfSummary,
         message: renderTaskNotificationXml(notification),
         notification,
+        ...(extras.diagnostics !== undefined ? { diagnostics: extras.diagnostics } : {}),
     });
 };
 const retryStatusArm = function* (m, { ctx, flags }) {
@@ -1091,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

@@ -5,7 +5,7 @@ import type { PlanReviewReopenTrigger } from '../hitl/planReviewWire.js';
 import { type AskParkAutoReopenBlock } from '../hitl/askParkAutoReopenBlock.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;
@@ -75,6 +75,7 @@ export interface ActiveRunSelfHealDeps {
     }) => Promise<number>;
     reopenPlanReview?: (taskId: string, opts?: {
         trigger?: PlanReviewReopenTrigger;
+        checkpointId?: string;
     }) => ReopenCardVerdict | Promise<ReopenCardVerdict>;
     reopenAskPark?: (taskId: string, opts?: {
         trigger?: PlanReviewReopenTrigger;
@@ -86,6 +87,7 @@ export interface ActiveRunSelfHealDeps {
     signal?: AbortSignal;
     cancelReleaseWaitMs?: number;
     submissionOrigin?: RejectedSubmissionOrigin;
+    injectedCarriers?: readonly object[];
     sessionId?: string;
     wasRecentlyTerminatedByUs?: (taskId: string) => boolean;
     interruptedSettle?: InterruptedSettleWindow;
@@ -170,6 +172,12 @@ export type SelfHealOutcome = {
 } | {
     kind: 'running-attach';
     taskId: string;
+} | {
+    kind: 'injected-redundant';
+    taskId: string;
+} | {
+    kind: 'injected-deferred';
+    taskId: string;
 } | {
     kind: 'running-cancelled';
     taskId: string;
@@ -214,7 +222,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';
@@ -225,11 +233,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

@@ -1,9 +1,12 @@
 import { abortableSleep } from '../abortableSleep.js';
 import { EN_MESSAGES } from '../i18n/messages.en.js';
 import { msg, renderMessage } from '../i18n/translate.js';
+import { registeredPlanReviewCardFacts } from '../planReviewCardFacts.js';
+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 { guardedRead, readOwnDataNonEmptyString, readOwnDataValue } from '../ownKey.js';
 import { steerBodyOf, UNOBSERVED_STEER_PRIORITY } from '../controlRouter.js';
 import { atMostOnceFailureClass } from '../atMostOnce.js';
 import { readSteerReceipt } from '../steerReceipt.js';
@@ -26,7 +29,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))
@@ -40,7 +43,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']);
@@ -68,12 +71,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')
@@ -82,6 +93,58 @@ 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 sessionOpts(deps) {
     const sessionId = deps?.sessionId;
     return typeof sessionId === 'string' && sessionId.length > 0 ? { session: sessionId } : {};
@@ -521,9 +584,11 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
         };
     }
     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);
+        return planReviewArm(taskId, signal, deps, sameTaskCp);
     if (gateLeg === 'approval')
         return askParkArm(taskId, signal, runs, deps);
     let status = signal.activeTaskStatus;
@@ -558,10 +623,11 @@ export async function attemptActiveRunSelfHeal(signal, runs, deps) {
     }
     return { kind: 'not-parked', taskId, status, ...triageGate };
 }
-async function planVerdict(taskId, deps) {
+async function planVerdict(taskId, deps, checkpointId) {
     try {
         const trigger = planReviewReopenTriggerFor(deps?.submissionOrigin);
-        const verdict = trigger === undefined ? deps?.reopenPlanReview?.(taskId) : deps?.reopenPlanReview?.(taskId, { trigger });
+        const second = { ...(trigger !== undefined ? { trigger } : {}), ...(checkpointId !== undefined && checkpointId.length > 0 ? { checkpointId } : {}) };
+        const verdict = Object.keys(second).length === 0 ? deps?.reopenPlanReview?.(taskId) : deps?.reopenPlanReview?.(taskId, second);
         return snapshotReopenVerdict(await verdict);
     }
     catch (e) {
@@ -581,8 +647,8 @@ async function askVerdict(taskId, deps) {
         return thrownReopenVerdict(e);
     }
 }
-async function planReviewArm(taskId, signal, deps) {
-    const verdict = await planVerdict(taskId, deps);
+async function planReviewArm(taskId, signal, deps, checkpointId) {
+    const verdict = await planVerdict(taskId, deps, checkpointId);
     if (reopenDelivered(verdict))
         return { kind: 'plan-review-reopened', taskId, firstSight: verdict.firstSight === true };
     const inFlight = reopenRefusedForDecisionInFlight(verdict);
@@ -809,15 +875,16 @@ async function runningChoiceArm(taskId, status, busy, statusFromWire, runs, deps
     const notParked = { kind: 'not-parked', taskId, status };
     const offer = deps?.offerRunningChoice;
     const injected = deps?.submissionOrigin === 'injected';
+    const carrierVerdict = injected ? injectedCarrierVerdict(guardedRead(() => deps?.injectedCarriers), taskId) : null;
     if (typeof offer !== 'function' && !injected)
         return notParked;
     const text = typeof deps?.deniedMessage === 'string' ? deps.deniedMessage : '';
     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()) {
@@ -842,6 +909,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') {
@@ -993,7 +1064,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') &&
@@ -1066,6 +1137,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')
@@ -1177,6 +1252,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

@@ -5,7 +5,7 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf, toolInputRewriteOf } from '.
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpAuthorization, readMcpLiveness } from '../../mcpLiveness.js';
-import { contextUsageReadingOf, humanInputAttachmentsOf, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, readOwnDataFiniteNumber, readOwnDataNonEmptyString } from '../../ownKey.js';
+import { contextUsageReadingOf, humanInputAttachmentsOf, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameStringKey, readFrameTrueMark, readOwnDataFiniteNumber, readOwnDataNonEmptyString, workflowCompletionExtrasOf } from '../../ownKey.js';
 import { SEGMENT_END_IDENTITY_KEYS, eventSeq, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.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':
@@ -166,6 +175,7 @@ function projectEvent(ev, ctx) {
                 runId: wf.runId,
                 status: wf.status,
                 summary: typeof wf.summary === 'string' ? wf.summary : '',
+                ...workflowCompletionExtrasOf(wf),
             })));
         }
         case 'text':
@@ -283,10 +293,9 @@ function projectEvent(ev, ctx) {
             const nonEmptyStr = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
             const providerCondition = nonEmptyStr(ev.providerCondition);
             const providerConditionSource = nonEmptyStr(ev.providerConditionSource);
-            const stWait = ev;
-            const sleptMsRaw = guardedRead(() => readOwnDataFiniteNumber(stWait, 'sleptMs'));
+            const sleptMsRaw = guardedRead(() => readOwnDataFiniteNumber(ev, 'sleptMs'));
             const sleptMs = sleptMsRaw !== undefined && sleptMsRaw >= 0 ? sleptMsRaw : undefined;
-            const waitSegment = readFrameStringKey(stWait, 'waitSegment');
+            const waitSegment = readFrameStringKey(ev, 'waitSegment');
             const seat = readFrameStringKey(ev, 'seat');
             return projected(stamp(ctx, armBody({
                 type: 'retry_status',
@@ -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;
@@ -47,3 +45,9 @@ export declare function readInstructionsSegment(holder: object, key: 'instructio
 export declare function readFleetSegment(holder: object, key: 'fleet' | '_sema_fleet'): WiringManifestFleetView | undefined;
 export declare function wiringManifestViewOf(s: WiringManifestSections): WiringManifestView | undefined;
 export declare function modRowsOf(records: unknown): readonly WiringManifestModView[] | undefined;
+export interface PermissionModeReceiptView {
+    readonly requested?: string;
+    readonly effective: string;
+    readonly foldedBy?: string;
+}
+export declare function readPermissionModeReceiptSegment(holder: object, key: 'permissionMode'): PermissionModeReceiptView | undefined;

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 } : {}),
@@ -208,3 +207,28 @@ export function modRowsOf(records) {
         return undefined;
     }
 }
+export function readPermissionModeReceiptSegment(holder, key) {
+    try {
+        const seg = ownSlot(holder, key);
+        if (seg.state !== 'value' || !isModRecordObject(seg.value))
+            return undefined;
+        const raw = seg.value;
+        const effective = nonEmpty(ownSlot(raw, 'effective'));
+        if (effective === undefined)
+            return undefined;
+        const requestedSlot = ownSlot(raw, 'requested');
+        const foldedBySlot = ownSlot(raw, 'foldedBy');
+        const requested = nonEmpty(requestedSlot);
+        const foldedBy = nonEmpty(foldedBySlot);
+        if ((requestedSlot.state !== 'absent' && requested === undefined) || (foldedBySlot.state !== 'absent' && foldedBy === undefined))
+            return undefined;
+        return Object.freeze({
+            ...(requested !== undefined ? { requested } : {}),
+            effective,
+            ...(foldedBy !== undefined ? { foldedBy } : {}),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/adapter/runStream.js

@@ -5,7 +5,7 @@ import { terminalPartsOfObserved, readRunCostFacts, terminalToSdkResult, TOOL_IN
 import { terminalRunIdOf, terminalUuidOf } from '../engineRowRef.js';
 import { publishSubagentContentEvent, subagentContentEventOf } from '../subagentContentStore.js';
 import { OUTPUT_INVALID, activeRunBusyCarrierOf, classifyActiveRunBusy, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
-import { doneResultView, isReplayedTerminal } from '../replayBody.js';
+import { doneResultView, isReplayedTerminal, terminalLayerOf } from '../replayBody.js';
 import { carriesAnswerText, guardedRead, readFrameStringKey } from '../ownKey.js';
 import { ccErrorOfProviderStatus } from '../providerRejection.js';
 import { corruptSessionContent } from '../corruptSessionCopy.js';
@@ -20,6 +20,7 @@ import { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESS
 export { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX };
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
 import { resumeReopenContent, resumeReopenFromError, suspendedReopenOf } from '../hitl/suspendedReopen.js';
+import { openPlanBodyClaimLeg, planReviewParkFacts, stepPlanBodyClaim } from '../planReviewCardFacts.js';
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
 const ENGINE_TURN_USAGE_KEYS = Object.freeze(['inputTokens', 'totalInputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'costMicroUsd']);
 const _engineTurnUsageKeysPin = true;
@@ -205,8 +206,7 @@ function terminalOwnerOfStream(ctx, busy, busyHandle, runId) {
     };
 }
 function engineResultOf(result) {
-    const v = doneResultView(result);
-    return v.replay ? (v.engine ?? result) : result;
+    return doneResultView(result).body;
 }
 function engineSessionIdOf(result) {
     const v = result?.sessionId;
@@ -370,7 +370,7 @@ function apiErrorTerminalFromFacts(x, facts) {
             return none();
         if (type === 'failed')
             return { carrier: mintToolHistoryCarrier(nonEmptyStr(ownDataBit(x, 'errorCode')), undefined, nonEmptyStr(ownDataBit(x, 'errorMessage'))), detail: undefined };
-        const result = type === 'done' ? plainObjectOf(engineResultOf(ownDataBit(x, 'result'))) : x;
+        const result = type === 'done' ? plainObjectOf(terminalLayerOf(ownDataBit(x, 'result'))) : x;
         if (result === undefined)
             return none();
         const snap = ownTerminalSnapshot(result);
@@ -578,6 +578,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
             return false;
         }
     };
+    const planLeg = openPlanBodyClaimLeg();
     for await (const rawEv of events) {
         const ev = withStringFailureFields(rawEv);
         const wireSubFlow = wireFrameIsSubFlow(ev);
@@ -591,6 +592,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
             }
             seen.add(seq);
         }
+        stepPlanBodyClaim(planLeg, ev, wireSubFlow);
         if (ev.type === 'tool_start') {
             const callId = ev.toolCallId;
             if (typeof callId === 'string' && callId.length > 0 && !toolInputAmbiguous.has(callId)) {
@@ -853,9 +855,10 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     accepted: ev.type === 'done' && (doneTerminal?.kind === 'completed' || doneTerminal?.kind === 'paused'),
                 }).acceptedSinceMismatch;
             }
+            const planReview = ev.type === 'done' ? planReviewParkFacts(planLeg, engineResultOf(ev.result)) : undefined;
             if (ev.type === 'done' && isReviewPark(doneTerminal) && ctx.emitChrome) {
                 try {
-                    await ctx.emitChrome({ kind: 'plan_review_park', laneProof: mainLane(), result: ev.result });
+                    await ctx.emitChrome({ kind: 'plan_review_park', laneProof: mainLane(), result: ev.result, ...(planReview !== undefined ? { planReview } : {}) });
                 }
                 catch { }
             }

package/dist/approvalReachWire.d.ts

@@ -1,5 +1,6 @@
 import { CORE_APPROVAL_REACH } from './generated/engineFactTables.js';
 export type ApprovalReachWord = (typeof CORE_APPROVAL_REACH)[number];
+export declare function isApprovalReachWord(v: {} | null | undefined): v is ApprovalReachWord;
 export declare function refuseBadApprovalReach(v: unknown, who: string): void;
 export type ApprovalReachWithheldCause = 'not_reported' | 'unsupported' | 'unprobed' | 'unreadable';
 export type ApprovalReachDeclaration = {