@sema-agent/client-core 0.104.1 → 0.106.0

package/dist/hitl/hitlBridge.js

@@ -10,6 +10,7 @@ import { APPROVAL_BINDING_MISMATCH, CHECKPOINT_INVALID_OUTCOME, RESUME_POLICY_FO
 import { suspendedReopenOf } from './suspendedReopen.js';
 import { closeDecisionOp, decisionLedgerKeysOf, openDecisionOp } from './decisionLedger.js';
 import { askParkBlockGeneration, noteAskParkDecideSettled } from './askParkAutoReopenBlock.js';
+import { checkpointQueueRowSortOf, QUEUE_ROW_FAMILY_UNREADABLE_GATE } from './approvalQueueRow.js';
 export const DEFAULT_DENY_REASON = 'The user rejected this tool use';
 export const MAX_DENY_REASON_CHARS = 4096;
 export function denyReasonForWire(reason, tag) {
@@ -28,6 +29,15 @@ export function denyReasonForWire(reason, tag) {
         `(server caps approval reason at ${MAX_DENY_REASON_CHARS}; over-cap is a 413 reason_too_large that would drop the DECISION, not just the reason)`);
     return cut;
 }
+function resumeTakesRestatementBody(client) {
+    if (typeof Reflect.get(client.approvals, 'decidePeerInbound') === 'function')
+        return true;
+    return client.assistant.resume.length >= 3;
+}
+const _realClientFitsHitlSlice = true;
+void _realClientFitsHitlSlice;
+const _bindingKeysEchoed = true;
+void _bindingKeysEchoed;
 export const PLAN_REVIEW_MODE_AFTER_WORDS = Object.freeze(['default', 'acceptEdits']);
 export function isPlanReviewModeAfter(v) {
     return v !== undefined && PLAN_REVIEW_MODE_AFTER_WORDS.includes(v);
@@ -258,7 +268,13 @@ export async function findPendingForTask(client, taskId, matches, opts, callId,
         hostLog('debug', `hitlBridge: approvals.list failed: ${t.log}`);
         return { ok: false, reason: `approvals.list failed: ${t.reason}` };
     }
-    const readings = rows.map((r) => ({ r, foreign: askParkForeignGateKind(r) }));
+    const readings = rows.flatMap((r) => {
+        const sort = checkpointQueueRowSortOf(r);
+        if (sort === 'excluded')
+            return [];
+        const cp = r;
+        return [{ r: cp, foreign: sort === 'unreadable' ? QUEUE_ROW_FAMILY_UNREADABLE_GATE : askParkForeignGateKind(cp) }];
+    });
     const decidable = readings.filter((x) => x.foreign === null).map((x) => x.r);
     const identityRow = callId !== undefined
         ? decidable.find((r) => r.taskId === taskId && (r.boundCallId === callId || r.toolCallId === callId))
@@ -328,12 +344,14 @@ export class HitlBridge {
         throw new Error(found.reason);
     }
     bindingOf(p) {
-        if (p.boundCallId === undefined || p.boundInputHash === undefined) {
+        const boundCallId = readOwnDataValue(p, 'boundCallId');
+        const boundInputHash = readOwnDataValue(p, 'boundInputHash');
+        if (typeof boundCallId !== 'string' || boundCallId.length === 0 || typeof boundInputHash !== 'string' || boundInputHash.length === 0) {
             throw new HitlSafetyError(`pending checkpoint ${p.id ?? '<no-id>'} is missing D-1 binding fields ` +
-                `(boundCallId=${String(p.boundCallId)}, boundInputHash=${String(p.boundInputHash)}) — ` +
+                `(boundCallId=${String(boundCallId)}, boundInputHash=${String(boundInputHash)}) — ` +
                 'pre-D-1 workers are no longer supported (server 5.x requires the verbatim two-tuple echo)', 'binding_missing');
         }
-        return { boundCallId: p.boundCallId, boundInputHash: p.boundInputHash };
+        return { boundCallId, boundInputHash };
     }
     async decideTool(outcome, toolUseID, opts, preResolvedPending) {
         const pending = preResolvedPending ?? (await this.pendingForDecide(toolUseID, wireOptsOf(opts)));
@@ -406,7 +424,10 @@ export class HitlBridge {
         if (kind && kind !== 'resource_limit') {
             throw new HitlSafetyError(`cannot resume a "${kind}" gate — "continue" must never bypass a human approval; use decide`, 'wrong_gate');
         }
-        return this.client.assistant.resume(this.taskId, opts);
+        const assistant = this.client.assistant;
+        if (resumeTakesRestatementBody(this.client))
+            return assistant.resume(this.taskId, undefined, opts);
+        return Reflect.apply(assistant.resume, assistant, [this.taskId, opts]);
     }
     async decideRaw(sessionId, decision, optsIn) {
         const opts = wireOptsOf(optsIn);

package/dist/hitl/livePendingAsk.d.ts

@@ -1,6 +1,7 @@
 import { type ApprovalRequestFrame } from '@sema-agent/sdk';
 import type { ApprovalResolution } from './approvalResolution.js';
 import type { ApprovalsFeedEmission } from './approvalsFeed.js';
+import type { ApprovalMandateWord } from '../gateVocabulary.js';
 import { type RespondToolApprovalFn, type ToolApprovalFrame, type ToolApprovalFrameLaneOpts } from './toolApprovalWire.js';
 export interface LivePendingAskView {
     approvalId: string;
@@ -13,6 +14,10 @@ export interface LivePendingAskView {
     fromSubagent?: true;
     originTaskId?: string;
     frame?: ToolApprovalFrame | ApprovalRequestFrame;
+    mandated?: true;
+    mandate?: ApprovalMandateWord;
+    origin?: string;
+    liveFactsUnknown?: true;
 }
 export type LivePendingReading = {
     kind: 'not_reported';

package/dist/hitl/livePendingAsk.js

@@ -1,6 +1,7 @@
 import { isApprovalRequestFrameV1 } from '@sema-agent/sdk';
 import { appendOwnElement } from '../ownKey.js';
 import { readRequiresRealApproval } from './approvalCardReading.js';
+import { approvalLiveFaceOf, liveFaceCarried } from './approvalLiveFace.js';
 import { THROWN_SLOT_UNREADABLE, readThrownSlot } from '../wireFailureShape.js';
 import { isToolApprovalFrame, surfaceToolApprovalFrameAndRespond, } from './toolApprovalWire.js';
 function nonEmptyString(v) {
@@ -61,6 +62,8 @@ export function readLivePendingRows(body) {
             continue;
         }
         seen.add(o.approvalId);
+        const opening = openingFrameOf(o.frame);
+        const frame = opening !== undefined && opening.approvalId === o.approvalId ? opening : undefined;
         rows.push({
             approvalId: o.approvalId,
             toolName: o.toolName,
@@ -71,7 +74,8 @@ export function readLivePendingRows(body) {
             ...(o.governanceForced === true ? { governanceForced: true } : {}),
             ...(o.fromSubagent === true ? { fromSubagent: true } : {}),
             ...(nonEmptyString(o.originTaskId) ? { originTaskId: o.originTaskId } : {}),
-            ...((f) => (f !== undefined && f.approvalId === o.approvalId ? { frame: f } : {}))(openingFrameOf(o.frame)),
+            ...(frame !== undefined ? { frame } : {}),
+            ...(frame === undefined ? liveFaceCarried(approvalLiveFaceOf(o)) : {}),
         });
     }
     if (members.length > 0 && rows.length === 0)
@@ -137,6 +141,7 @@ export function livePendingRowToApprovalFrame(row) {
         ...(row.originTaskId !== undefined ? { sourceTaskId: row.originTaskId } : {}),
         ...(row.governanceForced === true ? { governanceForced: true } : {}),
         ...(readRequiresRealApproval(row) ? { requiresRealApproval: true } : {}),
+        ...liveFaceCarried(approvalLiveFaceOf(row)),
     };
 }
 export function surfaceSuspendedAskAndRespond(row, respond, signal, lane) {

package/dist/hitl/planReviewCard.d.ts

@@ -0,0 +1,23 @@
+import { type PlanReviewCardFacts, type PlanReviewFactsTaken } from '../planReviewCardFacts.js';
+import { type MessageRef } from '../i18n/translate.js';
+import type { MessageKey } from '../i18n/messages.en.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
+export declare function planReviewCardNoteRef(facts: PlanReviewCardFacts): MessageRef | undefined;
+export declare function planReviewUnreadableNoteRef(): MessageRef;
+export declare function planReviewCardNote(facts: PlanReviewCardFacts, lang?: UiLanguage): string | undefined;
+export declare function planReviewAskAgainKey(facts: PlanReviewCardFacts | undefined): MessageKey;
+export type PlanReviewDecisionReason = 'card_missing' | 'card_withholds' | 'gate_moved' | 'gate_untrusted';
+export declare function planReviewDecisionReasonRef(reason: PlanReviewDecisionReason, card?: PlanReviewCardFacts): MessageRef;
+export interface PlanReviewLedgerSource {
+    readonly runRow: (taskId: string, signal: AbortSignal) => Promise<object>;
+    readonly frames: (taskId: string, signal: AbortSignal) => AsyncIterable<object>;
+}
+export type PlanReviewFactsTaking = {
+    readonly kind: 'now';
+    readonly taken: PlanReviewFactsTaken;
+} | {
+    readonly kind: 'ledger';
+    readonly pending: Promise<PlanReviewFactsTaken | undefined>;
+};
+export declare function _resetPlanReviewFactsFlightsForTest(): void;
+export declare function takePlanReviewFacts(sessionKey: string, taskId: string, checkpointId: string | undefined, source: () => PlanReviewLedgerSource | undefined, signal?: AbortSignal): PlanReviewFactsTaking;

package/dist/hitl/planReviewCard.js

@@ -0,0 +1,250 @@
+import { currentPlanReviewGateOf, isPlanReviewClaimFrame, mintPlanReviewCardFacts, openPlanReviewLedgerFold, planGateRowReadOf, planReviewBodyOf, planReviewCardFactsFrom, planReviewLedgerClaimOf, planReviewRunGeneration, beginPlanReviewFactsRead, commitPlanReviewFacts, samePlanClaim, stepPlanReviewLedgerFold, unknownBody, } from '../planReviewCardFacts.js';
+import { msg, renderMessage } from '../i18n/translate.js';
+import { readRunLedgerSnapshot } from '../runLedgerSnapshot.js';
+import { snapshotIsSubFlow, snapshotSegmentIdentity } from '../adapter/types.js';
+import { settleWithinDeadline } from '../abortableSleep.js';
+import { hostLog } from '../host.js';
+export function planReviewCardNoteRef(facts) {
+    const body = facts.body;
+    switch (body.kind) {
+        case 'shown':
+            return body.markdown.trim() === '' ? msg('approval.planReview.note.empty') : undefined;
+        case 'marked':
+            return msg('approval.planReview.note.marked');
+        case 'too_large':
+            return msg('approval.planReview.note.tooLarge', { length: body.length });
+        case 'unknown':
+            return msg(body.cause === 'not_carried' ? 'approval.planReview.note.notCarried' : 'approval.planReview.note.unknown');
+    }
+}
+export function planReviewUnreadableNoteRef() {
+    return msg('approval.planReview.note.unknown');
+}
+export function planReviewCardNote(facts, lang) {
+    let ref;
+    try {
+        const read = planReviewCardFactsFrom(facts);
+        ref = read === undefined ? planReviewUnreadableNoteRef() : planReviewCardNoteRef(read);
+    }
+    catch {
+        ref = planReviewUnreadableNoteRef();
+    }
+    return ref === undefined ? undefined : renderMessage(ref, lang);
+}
+export function planReviewAskAgainKey(facts) {
+    const body = facts?.body;
+    if (body === undefined)
+        return 'approval.planReview.askAgain.unknown';
+    switch (body.kind) {
+        case 'shown':
+            return 'approval.planReview.askAgain.shown';
+        case 'marked':
+            return 'approval.planReview.askAgain.marked';
+        case 'too_large':
+            return 'approval.planReview.askAgain.tooLarge';
+        case 'unknown':
+            return body.cause === 'not_carried' ? 'approval.planReview.askAgain.notCarried' : 'approval.planReview.askAgain.unknown';
+    }
+}
+export function planReviewDecisionReasonRef(reason, card) {
+    switch (reason) {
+        case 'card_missing':
+            return msg('approval.planReview.decision.cardMissing');
+        case 'card_withholds': {
+            let ref;
+            try {
+                const read = card === undefined ? undefined : planReviewCardFactsFrom(card);
+                ref = read === undefined ? undefined : planReviewCardNoteRef(read);
+            }
+            catch {
+                ref = undefined;
+            }
+            return ref ?? planReviewUnreadableNoteRef();
+        }
+        case 'gate_moved':
+            return msg('approval.planReview.decision.gateMoved');
+        case 'gate_untrusted':
+            return msg('approval.planReview.decision.gateUntrusted');
+    }
+}
+const PLAN_REVIEW_LEDGER_BUDGET_MS = 3_000;
+const planReviewFactsFlights = new Map();
+export function _resetPlanReviewFactsFlightsForTest() {
+    planReviewFactsFlights.clear();
+}
+export function takePlanReviewFacts(sessionKey, taskId, checkpointId, source, signal) {
+    const now = (facts, generation) => ({ kind: 'now', taken: { sessionKey, taskId, facts, generation } });
+    try {
+        const g0 = planReviewRunGeneration(sessionKey, taskId);
+        const gate = currentPlanReviewGateOf(sessionKey, taskId);
+        if (checkpointId !== undefined && gate !== undefined && gate.checkpointId === checkpointId)
+            return now(gate.facts, gate.generation);
+        const flightKey = `${sessionKey}\u0000${taskId}\u0000${checkpointId ?? ''}`;
+        const inFlight = planReviewFactsFlights.get(flightKey);
+        if (inFlight !== undefined)
+            return { kind: 'ledger', pending: inFlight };
+        let src;
+        try {
+            src = source();
+        }
+        catch {
+            src = undefined;
+        }
+        if (src === undefined)
+            return now(mintPlanReviewCardFacts(taskId, checkpointId, unknownBody('not_observed')), g0);
+        const reader = src;
+        const started = Date.now();
+        const ledger = (budgetMs) => readPlanReviewFactsFromLedger(beginPlanReviewFactsRead(sessionKey, taskId), checkpointId, reader, signal, budgetMs);
+        const viaRow = checkpointId === undefined && gate !== undefined
+            ? readPlanGateRowWithin(reader, taskId, signal, PLAN_REVIEW_LEDGER_BUDGET_MS).then((row) => {
+                const cur = currentPlanReviewGateOf(sessionKey, taskId);
+                if (row.ok && row.atPlanGate && row.checkpointId !== undefined && cur !== undefined && cur.checkpointId === row.checkpointId) {
+                    return { sessionKey, taskId, facts: cur.facts, generation: cur.generation };
+                }
+                if (!row.ok)
+                    return { sessionKey, taskId, facts: mintPlanReviewCardFacts(taskId, undefined, unknownBody('unreadable')), generation: g0 };
+                return ledger(Math.max(0, PLAN_REVIEW_LEDGER_BUDGET_MS - (Date.now() - started)));
+            })
+            : undefined;
+        const pending = (viaRow ?? ledger(PLAN_REVIEW_LEDGER_BUDGET_MS)).then((taken) => {
+            if (planReviewFactsFlights.get(flightKey) === pending)
+                planReviewFactsFlights.delete(flightKey);
+            return taken;
+        }, () => {
+            if (planReviewFactsFlights.get(flightKey) === pending)
+                planReviewFactsFlights.delete(flightKey);
+            return undefined;
+        });
+        planReviewFactsFlights.set(flightKey, pending);
+        return { kind: 'ledger', pending };
+    }
+    catch {
+        return now(mintPlanReviewCardFacts(taskId, checkpointId, unknownBody('unreadable')), Number.NaN);
+    }
+}
+const rowUnread = () => ({ ok: false, atPlanGate: false });
+async function readPlanGateRow(source, taskId, signal) {
+    try {
+        return planGateRowReadOf(await source.runRow(taskId, signal));
+    }
+    catch {
+        return rowUnread();
+    }
+}
+async function readPlanGateRowWithin(source, taskId, outer, budgetMs) {
+    if (outer?.aborted === true)
+        return rowUnread();
+    let onOuterAbort;
+    try {
+        const aborted = new Promise((resolve) => {
+            onOuterAbort = () => resolve(rowUnread());
+            outer?.addEventListener('abort', onOuterAbort, { once: true });
+        });
+        const read = settleWithinDeadline(budgetMs, (deadline) => {
+            const ac = new AbortController();
+            const stop = () => ac.abort();
+            deadline.addEventListener('abort', stop, { once: true });
+            outer?.addEventListener('abort', stop, { once: true });
+            return readPlanGateRow(source, taskId, ac.signal).finally(() => {
+                deadline.removeEventListener('abort', stop);
+                outer?.removeEventListener('abort', stop);
+            });
+        }).then((settled) => (settled.kind === 'value' ? settled.value : rowUnread()));
+        return await Promise.race([read, aborted]);
+    }
+    catch {
+        return rowUnread();
+    }
+    finally {
+        if (onOuterAbort !== undefined)
+            outer?.removeEventListener('abort', onOuterAbort);
+    }
+}
+function foldLedgerFrame(fold, ev) {
+    if (typeof ev !== 'object' || ev === null)
+        return fold;
+    const snap = snapshotSegmentIdentity(ev);
+    return stepPlanReviewLedgerFold(fold, ev, snap === null || snapshotIsSubFlow(snap));
+}
+async function readPlanReviewFactsFromLedger(ticket, given, source, signal, budgetMs) {
+    const { sessionKey, taskId } = ticket;
+    const reads = [];
+    let claim;
+    let highWater;
+    try {
+        const snap = await readRunLedgerSnapshot(taskId, undefined, {
+            isParked: async (id, s) => {
+                const r = await readPlanGateRow(source, id, s);
+                reads.push(r);
+                const first = reads[0];
+                if (!r.ok || !r.atPlanGate || r.checkpointId === undefined)
+                    return false;
+                if (given !== undefined && r.checkpointId !== given)
+                    return false;
+                return reads.length === 1 || (first !== undefined && first.ok && first.checkpointId === r.checkpointId);
+            },
+            frames: (id, s) => source.frames(id, s),
+            budgetMs,
+            log: (msg) => {
+                hostLog('debug', `planReviewCard: ${msg}`);
+            },
+            fold: {
+                init: openPlanReviewLedgerFold,
+                step: foldLedgerFrame,
+                strictOrder: true,
+                substantive: isPlanReviewClaimFrame,
+                agree: (a, b) => {
+                    const x = planReviewLedgerClaimOf(a);
+                    const y = planReviewLedgerClaimOf(b);
+                    return x === undefined || y === undefined ? x === y : samePlanClaim(x, y);
+                },
+            },
+        }, signal);
+        if (snap !== null && snap.folded !== undefined) {
+            claim = planReviewLedgerClaimOf(snap.folded);
+            if (claim !== undefined)
+                highWater = snap.highWater;
+        }
+    }
+    catch {
+        claim = undefined;
+    }
+    const first = reads[0];
+    const firstGate = first !== undefined && first.ok && first.atPlanGate ? first.checkpointId : undefined;
+    let facts;
+    if (claim !== undefined && firstGate !== undefined) {
+        facts = mintPlanReviewCardFacts(taskId, firstGate, claim.kind === 'text' ? planReviewBodyOf(claim.text) : unknownBody(claim.cause));
+    }
+    else {
+        const missed = ledgerMissOf(reads, given);
+        claim = { kind: 'cause', cause: missed.cause };
+        highWater = undefined;
+        facts = mintPlanReviewCardFacts(taskId, missed.checkpointId, unknownBody(missed.cause));
+    }
+    const out = commitPlanReviewFacts(ticket, facts, claim, highWater);
+    if (out === undefined) {
+        hostLog('debug', `planReviewCard: ledger-read-superseded task=${taskId}`);
+        return undefined;
+    }
+    return { sessionKey, taskId, facts: out, generation: ticket.generation };
+}
+function ledgerMissOf(reads, given) {
+    const first = reads[0];
+    if (first === undefined || !first.ok)
+        return { cause: 'unreadable', ...(given !== undefined ? { checkpointId: given } : {}) };
+    if (!first.atPlanGate || first.checkpointId === undefined)
+        return { cause: 'gate_unidentified' };
+    const asked = given ?? first.checkpointId;
+    if (given !== undefined && first.checkpointId !== given)
+        return { cause: 'gate_moved', checkpointId: asked };
+    const second = reads[1];
+    if (second !== undefined) {
+        if (!second.ok)
+            return { cause: 'unreadable', checkpointId: asked };
+        if (!second.atPlanGate || second.checkpointId === undefined)
+            return { cause: 'gate_unidentified' };
+        if (second.checkpointId !== first.checkpointId)
+            return { cause: 'gate_moved', checkpointId: asked };
+    }
+    return { cause: 'unreadable', checkpointId: asked };
+}

package/dist/hitl/planReviewWire.d.ts

@@ -2,34 +2,52 @@ import { type QuestionAnswer } from '../liveQuestionStore.js';
 import type { EngineWireInjection } from '../engineWireSdk.js';
 import { type PlanReviewModeAfter } from './hitlBridge.js';
 import type { AgentClient } from '@sema-agent/sdk';
+import { isPlanReviewPark, type PlanReviewCardFacts } from '../planReviewCardFacts.js';
+import type { UiLanguage } from '../env/uiLanguage.js';
 import type { ReopenCardVerdict } from '../adapter/activeRunSelfHeal.js';
 export declare const PLAN_REVIEW_APPROVE_LABEL = "Yes, approve and run the plan";
 export declare const PLAN_REVIEW_REJECT_LABEL = "No, reject it (keep planning)";
 export declare const PLAN_REVIEW_APPROVE_AUTO_LABEL = "Yes, and auto-accept edits";
 export declare const PLAN_REVIEW_APPROVE_MANUAL_LABEL = "Yes, and manually approve edits";
-export declare function planReviewDecisionFromAnswer(answer: QuestionAnswer | null | undefined, shownLabels?: readonly string[]): 'approve' | 'reject' | 'dismissed';
+export type PlanReviewOptionChoice = 'approve' | 'approve_accept_edits' | 'approve_manual' | 'reject' | 'ask_again';
+export interface PlanReviewOption {
+    readonly label: string;
+    readonly description: string;
+    readonly choice: PlanReviewOptionChoice;
+}
+type PlanReviewNonDecision = 'dismissed' | 'inadmissible';
+export declare function planReviewDecisionFromAnswer(answer: QuestionAnswer | null | undefined, shownLabels?: readonly string[]): 'approve' | 'reject' | 'ask_again' | PlanReviewNonDecision;
 export type PlanReviewChoice = {
     decision: 'approve';
     permissionModeAfter?: PlanReviewModeAfter;
 } | {
     decision: 'reject';
     reason?: string;
+} | {
+    decision: 'ask_again';
+    reason?: string;
 };
-export declare function planReviewChoiceFromAnswer(answer: QuestionAnswer | null | undefined, shownLabels?: readonly string[]): PlanReviewChoice | 'dismissed';
+export declare function planReviewChoiceFromAnswer(answer: QuestionAnswer | null | undefined, shownLabels?: readonly string[]): PlanReviewChoice | PlanReviewNonDecision;
 export declare function planReviewCardOptions(offerModeAfter: boolean): Array<{
     label: string;
     description: string;
 }>;
+export declare function planReviewOptionsOf(facts: PlanReviewCardFacts, opts?: {
+    readonly submittedInPlanMode?: boolean;
+}): readonly PlanReviewOption[];
+export interface PlanReviewCardView {
+    readonly facts?: PlanReviewCardFacts;
+    readonly options: readonly PlanReviewOption[];
+    readonly note?: string;
+}
+export declare function planReviewCardViewOf(frame: object | null | undefined, lang?: UiLanguage): PlanReviewCardView | undefined;
 export declare function notePlanReviewAnsweredIfDecisive(questionId: unknown, answer: QuestionAnswer | null | undefined): void;
-export declare function isPlanReviewPark(result: unknown): result is {
-    taskId: string;
-    sessionId?: string;
-};
+export { isPlanReviewPark };
 export declare function _resetArmedPlanReviewsForTest(): void;
 export type PlanReviewReopenTrigger = 'user' | 'automatic';
 export type PlanReviewGateInstanceReader = (taskId: string) => Promise<ReadonlySet<string> | null>;
 export declare function clearPlanReviewUserDismissals(sessionKey?: string): void;
-export type PlanReviewOfferedMode = 'three_choice' | 'two_choice' | 'unknown';
+export type PlanReviewOfferedMode = 'three_choice' | 'two_choice' | 'withheld' | 'unknown';
 export interface PlanReviewCardLike {
     readonly questionId?: string;
     readonly questions?: ReadonlyArray<{
@@ -45,8 +63,8 @@ export interface PlanReviewQuestionIdReading {
 export declare function planReviewTaskIdFromQuestionId(questionId: {} | null | undefined): PlanReviewQuestionIdReading | undefined;
 export declare function planReviewOfferedModeOf(card: string | PlanReviewCardLike): PlanReviewOfferedMode;
 export declare function planReviewShownLabelsOf(questionId: {} | null | undefined): readonly string[] | undefined;
-export declare function planReviewAnswerChoiceOf(questionId: {} | null | undefined, answer: QuestionAnswer | null | undefined): PlanReviewChoice | 'dismissed';
-export declare function planReviewAnswerDecisionOf(questionId: {} | null | undefined, answer: QuestionAnswer | null | undefined): 'approve' | 'reject' | 'dismissed';
+export declare function planReviewAnswerChoiceOf(questionId: {} | null | undefined, answer: QuestionAnswer | null | undefined): PlanReviewChoice | PlanReviewNonDecision;
+export declare function planReviewAnswerDecisionOf(questionId: {} | null | undefined, answer: QuestionAnswer | null | undefined): 'approve' | 'reject' | 'ask_again' | PlanReviewNonDecision;
 export interface ArmPlanReviewOptions {
     submittedInPlanMode?: boolean;
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
@@ -58,14 +76,14 @@ export type PlanReviewDecisionEffect = 'took_effect' | 'advanced' | 'still_parke
 export interface PlanReviewOutcomeMeta {
     taskId: string;
     dispatchNo: number;
-    decision: 'approve' | 'reject';
+    decision: 'approve' | 'reject' | 'ask_again';
     effect: PlanReviewDecisionEffect;
     cause?: 'stored_form_unsupported';
 }
 export declare function planReviewOutcomeTail(taskId: string, decision: 'approve' | 'reject', effect: PlanReviewDecisionEffect, cause?: 'stored_form_unsupported'): string;
 export type PlanReviewWireClient = {
     assistant: Pick<AgentClient['assistant'], 'planReview'>;
-    runs: Pick<AgentClient['runs'], 'get'>;
+    runs: Pick<AgentClient['runs'], 'get'> & Partial<Pick<AgentClient['runs'], 'events'>>;
 };
 export interface PlanReviewWire extends EngineWireInjection<PlanReviewWireClient> {
     client: PlanReviewWireClient;
@@ -82,7 +100,7 @@ export interface PlanReviewDeliveryOptions {
 }
 export interface DecidePlanReviewOptions extends PlanReviewDeliveryOptions {
     reason?: string;
-    parkedResult?: unknown;
+    card?: PlanReviewCardFacts;
 }
 export interface PlanReviewDecisionHandle {
     settle(): void;
@@ -95,17 +113,18 @@ export declare function notePlanReviewDecisionNotApplied(taskId: string): void;
 export declare function notePlanReviewGateLeft(taskId: string): void;
 export declare function latestPlanReviewDecisionMark(taskId: string): number | null;
 export declare function __resetPlanReviewDecisionLatchForTests(): void;
-export declare function decidePlanReview(taskId: string, decision: 'approve' | 'reject', permissionModeAfter?: string, opts?: DecidePlanReviewOptions): Promise<void>;
+export declare function decidePlanReview(taskId: string, decision: 'approve' | 'reject' | 'ask_again', permissionModeAfter?: string, opts?: DecidePlanReviewOptions): Promise<void>;
 export interface ReopenPlanReviewSharedOpts {
     sessionKey?: string;
     presentationReceiptMs: number;
     trigger?: PlanReviewReopenTrigger;
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
     pendingReadStartedAt?: number;
+    checkpointId?: string;
 }
 export interface ReopenPlanReviewFreshOpts extends ReopenPlanReviewSharedOpts {
     mintFreshQuestionId?: true;
-    deliverDecision?: (taskId: string, decision: 'approve' | 'reject', reason?: string) => void | Promise<void>;
+    deliverDecision?: (taskId: string, decision: Parameters<typeof decidePlanReview>[1], reason: string | undefined, card: PlanReviewCardFacts) => void | Promise<void>;
     wire?: PlanReviewWire;
     onOutcome?: PlanReviewDeliveryOptions['onOutcome'];
 }
@@ -118,3 +137,9 @@ export interface ReopenPlanReviewReuseOpts extends ReopenPlanReviewSharedOpts {
 export type ReopenPlanReviewOpts = ReopenPlanReviewFreshOpts | ReopenPlanReviewReuseOpts;
 export declare function _resetActiveReopenRespondersForTest(): void;
 export declare function reopenPlanReviewCard(taskId: string, opts: ReopenPlanReviewOpts): Promise<ReopenCardVerdict>;
+export interface ReadPlanReviewCardFactsOptions {
+    readonly checkpointId?: string;
+    readonly wire?: PlanReviewWire;
+    readonly signal?: AbortSignal;
+}
+export declare function readPlanReviewCardFacts(taskId: string, opts?: ReadPlanReviewCardFactsOptions): Promise<PlanReviewCardFacts>;