@sema-agent/client-core 0.84.1 → 0.85.1

package/dist/fileHistoryCaptureCapability.d.ts

@@ -6,13 +6,16 @@ export type FileHistoryCaptureReading = {
     kind: 'present';
     word: string;
 };
-export type FileHistoryCaptureMode = 'off' | 'on-always' | 'unknown';
+export type FileHistoryCaptureMode = 'off' | 'on-always' | 'on-optional' | 'unknown';
 export declare function projectFileHistoryCaptureCapability(caps: unknown): FileHistoryCaptureReading | undefined;
 export declare function noteEngineCapsForFileHistoryCapture(baseUrl: string, caps: unknown, opts?: {
     generation?: number;
 }): void;
 export declare function observedFileHistoryCapture(baseUrl?: string | undefined): FileHistoryCaptureReading;
 export declare function fileHistoryCaptureMode(reading: FileHistoryCaptureReading): FileHistoryCaptureMode;
+export declare function fileHistoryDeclarationField(reading: FileHistoryCaptureReading, captureOff: boolean): {
+    fileHistory: 'disabled';
+} | Record<string, never>;
 export declare function fileHistoryCaptureDoctorDetail(reading: FileHistoryCaptureReading): string;
 export declare function forgetFileHistoryCaptureReading(baseUrl: string | undefined): void;
 export declare function __resetFileHistoryCaptureReadingsForTests(): void;

package/dist/fileHistoryCaptureCapability.js

@@ -1,6 +1,7 @@
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
+import { FILE_HISTORY_DISABLED } from './request/taskRequest.js';
 export function projectFileHistoryCaptureCapability(caps) {
     if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
         return undefined;
@@ -25,29 +26,62 @@ export function observedFileHistoryCapture(baseUrl = engineWireTarget()?.baseUrl
     return reader.observed(baseUrl);
 }
 export function fileHistoryCaptureMode(reading) {
-    if (reading.kind !== 'present')
+    if (typeof reading !== 'object' || reading === null)
         return 'unknown';
-    if (reading.word === 'off')
+    let kind;
+    let word;
+    try {
+        kind = reading.kind;
+        word = kind === 'present' ? reading.word : undefined;
+    }
+    catch {
+        return 'unknown';
+    }
+    if (kind !== 'present')
+        return 'unknown';
+    if (word === 'off')
         return 'off';
-    if (reading.word === 'on-always')
+    if (word === 'on-optional')
+        return 'on-optional';
+    if (word === 'on-always')
         return 'on-always';
     return 'unknown';
 }
+export function fileHistoryDeclarationField(reading, captureOff) {
+    return captureOff === true && fileHistoryCaptureMode(reading) === 'on-optional' ? { fileHistory: FILE_HISTORY_DISABLED } : {};
+}
 const WORD_DETAIL_MAX = 40;
 export function fileHistoryCaptureDoctorDetail(reading) {
-    switch (reading.kind) {
-        case 'unobserved':
-            return 'file history capture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment captures file history is unknown';
+    const unobserved = 'file history capture not observed — the engine reports it on /v1/capabilities; this process has no usable capabilities reading cached for it, so whether this deployment captures file history is unknown';
+    if (typeof reading !== 'object' || reading === null)
+        return unobserved;
+    let kind;
+    let word;
+    try {
+        kind = reading.kind;
+        word = kind === 'present' ? reading.word : undefined;
+    }
+    catch {
+        return unobserved;
+    }
+    switch (kind) {
         case 'not_reported':
             return 'file history capture not reported by this engine — only newer engines advertise it; this does not say whether file history is captured here';
         case 'present':
-            if (reading.word === 'off') {
+            if (typeof word !== 'string' || word.length === 0)
+                return unobserved;
+            if (word === 'off') {
                 return 'file history capture off on this deployment — the engine takes no snapshots of the files it changes; whether code can be rewound here is answered separately by the rewind readings';
             }
-            if (reading.word === 'on-always') {
+            if (word === 'on-optional') {
+                return 'file history capture on — the engine snapshots files before changing them, and a session on this deployment can opt out of capture for its own runs';
+            }
+            if (word === 'on-always') {
                 return 'file history capture always on — the engine snapshots files before changing them in every session, and it cannot be turned off for a single session here';
             }
-            return `file history capture reported as "${capForDisplay(reading.word, WORD_DETAIL_MAX)}" — a mode this client does not know yet, so whether it captures is shown as unknown`;
+            return `file history capture reported as "${capForDisplay(word, WORD_DETAIL_MAX)}" — a mode this client does not know yet, so whether it captures is shown as unknown`;
+        default:
+            return unobserved;
     }
 }
 export function forgetFileHistoryCaptureReading(baseUrl) {

package/dist/gateVocabulary.d.ts

@@ -1,4 +1,5 @@
 import type { DeniedBy } from '@sema-agent/sdk';
+import type { APPROVAL_MANDATE_WORDS } from './hitl/toolApprovalWire.js';
 export declare const CC_TOOL_DENIAL_KINDS: readonly ["user-rejected", "permission-rule", "automode-blocked", "automode-unavailable", "automode-parsing-error", "interrupted", "cancelled"];
 export type CcToolDenialKind = (typeof CC_TOOL_DENIAL_KINDS)[number];
 export declare function isCcToolDenialKind(v: unknown): v is CcToolDenialKind;
@@ -7,14 +8,12 @@ export declare function ccToolDenialKindForSettledBy(settledBy: unknown): CcTool
 export declare const GATE_DENIED_BY_WORDS: readonly DeniedBy[];
 export declare function isGateDeniedByWord(v: unknown): v is DeniedBy;
 export declare function gateDeniedByDetail(deniedBy: unknown): string;
-export declare const ASK_ORIGIN_WORDS: readonly string[];
 export declare function askOriginDetail(origin: unknown, message?: unknown): string;
 export declare const RULE_STORE_UNREADABLE_KINDS: readonly ["store", "call"];
 export type RuleStoreUnreadableKind = (typeof RULE_STORE_UNREADABLE_KINDS)[number];
 export declare function isRuleStoreUnreadableKind(v: unknown): v is RuleStoreUnreadableKind;
 export declare function ruleStoreUnreadableDetail(kind: RuleStoreUnreadableKind): string;
 export declare function mandatedApprovalDetail(): string;
-export declare const APPROVAL_MANDATE_WORDS: readonly ["operator_always", "tool_marks", "probe_mandate", "probe_unanswered", "write_protection", "write_protection_unresolved"];
 export type ApprovalMandateWord = (typeof APPROVAL_MANDATE_WORDS)[number];
 export declare function isApprovalMandateWord(v: unknown): v is ApprovalMandateWord;
 export declare function approvalMandateDetail(word: ApprovalMandateWord): string;

package/dist/gateVocabulary.js

@@ -54,19 +54,6 @@ export function gateDeniedByDetail(deniedBy) {
     const word = typeof deniedBy === 'string' && deniedBy.length > 0 ? deniedBy : '(none)';
     return `denied by a layer this build does not know (${word}) — this build does not know this layer name: a newer engine may have added it, or the record may be damaged; this client cannot tell which`;
 }
-export const ASK_ORIGIN_WORDS = Object.freeze([
-    'content_question',
-    'ancestor_marked',
-    'org_unavailable',
-    'org_rule',
-    'rule_store_unavailable',
-    'hook',
-    'ask_rule',
-    'denial_limit_fallback',
-    'shell_gate_tighten',
-    'safety_tighten',
-    'policy',
-]);
 const ASK_ORIGIN_SENTENCES = Object.freeze({
     content_question: 'the tool itself asked you a question',
     ancestor_marked: 'an ancestor marked this call (an inherited approver-unavailable float, or a durable mandate): it must reach the park with no synchronous decision-maker in between',
@@ -118,17 +105,8 @@ export function ruleStoreUnreadableDetail(kind) {
 export function mandatedApprovalDetail() {
     return 'no saved allow rule and no remembered answer can retire this question; each call is settled on its own — by you here, by a hook, or by an automatic check the deployment runs — and an answer covers only that call';
 }
-export const APPROVAL_MANDATE_WORDS = Object.freeze([
-    'operator_always',
-    'tool_marks',
-    'probe_mandate',
-    'probe_unanswered',
-    'write_protection',
-    'write_protection_unresolved',
-]);
 const _mandateWordsPin = true;
 void _mandateWordsPin;
-const APPROVAL_MANDATE_SET = new Set(APPROVAL_MANDATE_WORDS);
 export function isApprovalMandateWord(v) {
     return APPROVAL_MANDATE_SET.has(v);
 }
@@ -140,6 +118,7 @@ const APPROVAL_MANDATE_SENTENCES = Object.freeze({
     write_protection: "this change lands on a protected location (the agent's own configuration), which is confirmed one change at a time",
     write_protection_unresolved: 'the protected-location check could not tell where this change lands, so whether it touches a protected location is unknown',
 });
+const APPROVAL_MANDATE_SET = new Set(Object.keys(APPROVAL_MANDATE_SENTENCES));
 export function approvalMandateDetail(word) {
     if (typeof word === 'string' && Object.hasOwn(APPROVAL_MANDATE_SENTENCES, word)) {
         return APPROVAL_MANDATE_SENTENCES[word];

package/dist/generated/engineNoticeTables.d.ts

@@ -0,0 +1,3 @@
+export declare const CORE_ENGINE_NOTICE_CODES: readonly string[];
+export declare const CORE_NOTICE_AUDIENCE: Readonly<Record<string, 'user' | 'operator'>>;
+export declare const CORE_MCP_INJECTION_DROP_REASONS: readonly string[];

package/dist/generated/engineNoticeTables.js

@@ -0,0 +1,156 @@
+export const CORE_ENGINE_NOTICE_CODES = Object.freeze([
+    "config.autocompact_window_clamped",
+    "config.env_timeout_discarded",
+    "config.materialize_env_discarded",
+    "config.models_swapped",
+    "config.context_settings_swapped",
+    "config.read_face_swapped",
+    "config.read_face_deployment_clamped",
+    "config.write_face_swapped",
+    "config.write_face_deployment_clamped",
+    "config.tool_model_gate_removed",
+    "config.tool_model_gate_unknown_class",
+    "config.tool_model_gate_env_invalid",
+    "config.artifact_host_invalid",
+    "config.task_root_not_canonical",
+    "config.write_protection_target_view_absent",
+    "config.write_protection_unresolved",
+    "config.execution_env_capability_invalid",
+    "config.tool_card_undeclared",
+    "config.tool_face_undeclared",
+    "config.tool_face_invalid",
+    "config.forward_sink_failed",
+    "config.durable_gate_unavailable",
+    "config.peer_admission_out_of_range",
+    "config.peer_lane_unmounted",
+    "config.secret_env_scrubbed",
+    "peer.inbound_disposition",
+    "peer.held_settled",
+    "peer.idle_subscription",
+    "classifier.denial_limit",
+    "classifier.fallback",
+    "classifier.role_defaulted",
+    "classifier.contract_broken",
+    "checkpoint.execution_outcome_unrecorded",
+    "delegation.transcript_integrity",
+    "delegation.ask_unresolvable",
+    "mcp.injection_dropped",
+    "mcp.revocation_probe_failed",
+    "mcp.server_redialed",
+    "workflow.governance_key_stripped",
+    "workflow.agent_option_ignored",
+    "memory.session_polluted",
+    "memory.harvest_quarantined",
+    "memory.delegation_static_mark_waived",
+    "memory.content_class_declared",
+    "memory.hold_opened",
+    "memory.hold_released",
+    "memory.hold_disposed",
+    "memory.consolidation_recommended",
+    "memory.consolidation_committed",
+    "memory.consolidation_conflict",
+    "memory.consolidation_incomplete",
+    "memory.consolidation_refused",
+    "memory.consolidation_withheld",
+    "memory.restore_withheld",
+    "memory.project_scope_absent",
+    "route.fallback_to_primary",
+    "route.classifier_unroutable",
+    "route.base_url_changed_key_unchanged",
+    "route.response_model_mismatch",
+    "task.user_steer_undrained",
+    "task.user_followup_undrained",
+    "steering.parked_input_blocked",
+    "task.turn_interrupted",
+    "task.halt_unconsumed",
+    "task.late_approval",
+    "task.interrupt_unconsumed",
+    "approval.read_root_granted",
+    "approval.read_root_grant_rejected",
+    "memory.capture_opted_out",
+    "memory.capture_optout_unpersisted",
+    "skills.listing_truncated",
+    "agents.listing_truncated",
+    "tool_result.offload_put_failed",
+]);
+export const CORE_NOTICE_AUDIENCE = Object.freeze({
+    "config.autocompact_window_clamped": "operator",
+    "config.env_timeout_discarded": "operator",
+    "config.materialize_env_discarded": "operator",
+    "config.models_swapped": "operator",
+    "config.context_settings_swapped": "operator",
+    "config.read_face_swapped": "operator",
+    "config.read_face_deployment_clamped": "operator",
+    "config.write_face_swapped": "operator",
+    "config.write_face_deployment_clamped": "operator",
+    "config.tool_model_gate_removed": "operator",
+    "config.tool_model_gate_unknown_class": "operator",
+    "config.tool_model_gate_env_invalid": "operator",
+    "config.artifact_host_invalid": "operator",
+    "config.task_root_not_canonical": "operator",
+    "config.write_protection_target_view_absent": "operator",
+    "config.write_protection_unresolved": "operator",
+    "config.execution_env_capability_invalid": "operator",
+    "config.tool_card_undeclared": "operator",
+    "config.tool_face_undeclared": "operator",
+    "config.tool_face_invalid": "operator",
+    "config.forward_sink_failed": "operator",
+    "config.durable_gate_unavailable": "user",
+    "config.peer_admission_out_of_range": "operator",
+    "config.peer_lane_unmounted": "operator",
+    "config.secret_env_scrubbed": "operator",
+    "peer.inbound_disposition": "user",
+    "peer.held_settled": "user",
+    "peer.idle_subscription": "user",
+    "classifier.denial_limit": "user",
+    "classifier.fallback": "operator",
+    "classifier.role_defaulted": "operator",
+    "classifier.contract_broken": "operator",
+    "checkpoint.execution_outcome_unrecorded": "operator",
+    "delegation.transcript_integrity": "operator",
+    "delegation.ask_unresolvable": "user",
+    "mcp.injection_dropped": "user",
+    "mcp.revocation_probe_failed": "operator",
+    "mcp.server_redialed": "operator",
+    "workflow.governance_key_stripped": "operator",
+    "workflow.agent_option_ignored": "operator",
+    "memory.session_polluted": "user",
+    "memory.harvest_quarantined": "user",
+    "memory.delegation_static_mark_waived": "user",
+    "memory.content_class_declared": "operator",
+    "memory.hold_opened": "user",
+    "memory.hold_released": "user",
+    "memory.hold_disposed": "user",
+    "memory.consolidation_recommended": "operator",
+    "memory.consolidation_committed": "operator",
+    "memory.consolidation_conflict": "operator",
+    "memory.consolidation_incomplete": "operator",
+    "memory.consolidation_refused": "operator",
+    "memory.consolidation_withheld": "operator",
+    "memory.restore_withheld": "operator",
+    "memory.project_scope_absent": "operator",
+    "route.fallback_to_primary": "operator",
+    "route.classifier_unroutable": "operator",
+    "route.base_url_changed_key_unchanged": "operator",
+    "route.response_model_mismatch": "operator",
+    "task.user_steer_undrained": "user",
+    "task.user_followup_undrained": "user",
+    "steering.parked_input_blocked": "user",
+    "task.turn_interrupted": "user",
+    "task.halt_unconsumed": "user",
+    "task.late_approval": "user",
+    "task.interrupt_unconsumed": "user",
+    "approval.read_root_granted": "user",
+    "approval.read_root_grant_rejected": "user",
+    "memory.capture_opted_out": "user",
+    "memory.capture_optout_unpersisted": "user",
+    "skills.listing_truncated": "operator",
+    "agents.listing_truncated": "operator",
+    "tool_result.offload_put_failed": "operator",
+});
+export const CORE_MCP_INJECTION_DROP_REASONS = Object.freeze([
+    "malformed_entry",
+    "name_reserved_by_deployment",
+    "gate_closed",
+    "over_cap",
+]);

package/dist/generated/toolNameTables.d.ts

@@ -0,0 +1,2 @@
+export declare const CORE_PROTOCOL_PREFIXES: readonly ["mcp__", "a2a__"];
+export declare const CORE_RETIRED_TOOL_CURRENT_NAMES: ReadonlyMap<string, string | null>;

package/dist/generated/toolNameTables.js

@@ -0,0 +1,43 @@
+export const CORE_PROTOCOL_PREFIXES = ["mcp__", "a2a__"];
+export const CORE_RETIRED_TOOL_CURRENT_NAMES = new Map([
+    ["read_file", "Read"],
+    ["edit_file", "Edit"],
+    ["write_file", "Write"],
+    ["bash", "Bash"],
+    ["bash_readonly", null],
+    ["glob", "Glob"],
+    ["grep", "Grep"],
+    ["web_fetch", "WebFetch"],
+    ["tool_search", "ToolSearch"],
+    ["skill", "Skill"],
+    ["present_plan", "ExitPlanMode"],
+    ["enter_plan_mode", "EnterPlanMode"],
+    ["spawn_subagent", "Agent"],
+    ["CronCancel", "CronDelete"],
+    ["lsp", "LSP"],
+    ["submit_output", "StructuredOutput"],
+    ["repo_map", "RepoMap"],
+    ["read_tool_result", "ReadToolResult"],
+    ["report_blocked", "ReportBlocked"],
+    ["declare_done", "DeclareDone"],
+    ["run_workflow", "Workflow"],
+    ["RunWorkflow", "Workflow"],
+    ["Task", "Agent"],
+    ["BashOutput", "TaskOutput"],
+    ["AgentOutputTool", "TaskOutput"],
+    ["BashOutputTool", "TaskOutput"],
+    ["AgentOutput", "TaskOutput"],
+    ["WorkflowStatus", null],
+    ["KillShell", "TaskStop"],
+    ["KillBash", "TaskStop"],
+    ["ListMcpResources", "ListMcpResourcesTool"],
+    ["ReadMcpResource", "ReadMcpResourceTool"],
+    ["ReadMcpResourceDir", "ReadMcpResourceDirTool"],
+    ["MultiEdit", null],
+    ["Fork", null],
+    ["Sleep", null],
+    ["Remember", null],
+    ["remember", null],
+    ["Recall", null],
+    ["recall", null],
+]);

package/dist/headlessPermissionModeWire.js

@@ -1,11 +1,9 @@
 import { permissionModeField } from './permissionWireCaps.js';
 import { hostEnv } from './hostEnv.js';
 import { lastFlagValue } from './argvFlagValue.js';
+import { PERMISSION_MODE_WORDS } from './taskRequestWords.js';
 export const HEADLESS_PERMISSION_MODE_ENV = 'SEMA_HEADLESS_PERMISSION_MODE';
-const HEADLESS_PERMISSION_WIRE_MODE_TUPLE = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto'];
-const _headlessPermissionModePins = [true, true];
-void _headlessPermissionModePins;
-export const HEADLESS_PERMISSION_WIRE_MODES = HEADLESS_PERMISSION_WIRE_MODE_TUPLE;
+export const HEADLESS_PERMISSION_WIRE_MODES = [...PERMISSION_MODE_WORDS];
 const SHELL_INTERNAL_MODE_TO_WIRE = new Map([
     ['manual', 'default'],
     ['dontAsk', 'default'],

package/dist/hitl/armedGateRegistry.d.ts

@@ -9,6 +9,7 @@ export declare function gateArmedWaitMs(): number;
 export declare function waitForGateArmed(keys: readonly string[], timeoutMs: number): Promise<boolean>;
 export declare function waitForGateArmedFor(sessionKey: string, keys: readonly string[], timeoutMs: number): Promise<boolean>;
 export declare function registerArmedGateFromQuestionId(questionId: unknown): void;
+export declare function registerArmedGateFromQuestionIdFor(sessionKey: string, questionId: unknown): void;
 export declare function planReviewArmedKey(taskId: string): string;
 export declare function planReviewArmedKeyFor(sessionKey: string, taskId: string): string;
 export declare function notePlanReviewAnswered(questionId: unknown): void;

package/dist/hitl/armedGateRegistry.js

@@ -120,7 +120,7 @@ function armedKeyForQuestionIdFor(sessionKey, questionId) {
 export function registerArmedGateFromQuestionId(questionId) {
     registerArmedGateFromQuestionIdFor(DEFAULT_SESSION_KEY, questionId);
 }
-function registerArmedGateFromQuestionIdFor(sessionKey, questionId) {
+export function registerArmedGateFromQuestionIdFor(sessionKey, questionId) {
     if (typeof questionId !== 'string' || questionId.length === 0)
         return;
     if (questionId.startsWith(PLAN_REVIEW_QUESTION_ID_PREFIX) && !questionId.includes(REOPEN_ID_TAIL)) {

package/dist/hitl/frameRouter.js

@@ -6,7 +6,9 @@ import { readRunTerminal, runTerminalCode, runTerminalGateKind, runTerminalGateT
 import { surfaceForCurrentSession } from './hitlHostSurface.js';
 import { SEMA_DENIAL_KIND_KEY } from './gateLedger.js';
 import { ccToolDenialKindForSettledBy } from '../gateVocabulary.js';
-export const HITL_REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+import { REJECT_MESSAGE } from '../adapt/wireShapes.js';
+import { RUN_CANCELLED_CODE } from '../runCancelContext.js';
+export const HITL_REJECT_MESSAGE = REJECT_MESSAGE;
 export const HITL_POLICY_DENY_MESSAGE = 'Permission for this tool use was denied: it requires interactive approval, and permission prompts are ' +
     'not available in this session. The action was NOT performed. Do not claim it succeeded, and do not retry ' +
     'it in this session \u2014 report the limitation to the user, or suggest an alternative.';
@@ -31,7 +33,7 @@ function denyStampedEnd(ev, attribution) {
     };
 }
 export const HITL_INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool use]';
-const RUN_CANCELLED_ERROR_CODE = 'cancelled';
+const RUN_CANCELLED_ERROR_CODE = RUN_CANCELLED_CODE;
 export const ENGINE_ABORT_TOOL_RESULT = 'Operation aborted';
 export function toolEndOutputText(output) {
     if (typeof output === 'string')

package/dist/hitl/parkResolver.js

@@ -1,6 +1,6 @@
 import { putOwnKey } from '../ownKey.js';
 import { DecideTransportRetryExhaustedError, HitlBridge, HitlSafetyError, findPendingForTask, readDecideCurrentPending, readWireErrorCode, } from './hitlBridge.js';
-import { PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE } from '../engineErrorCodes.js';
+import { PARKED_RESUME_STARTUP_FAILED, RESUME_POLICY_FOLD_CODE, isDecideParkMovedCode } from '../engineErrorCodes.js';
 import { publishQuestionFrame, registerLocalQuestionResponder, hasQuestionOverlay, } from '../liveQuestionStore.js';
 import { hostLog } from '../host.js';
 import { surfaceFsApprovalAndDecide } from './toolApprovalWire.js';
@@ -46,6 +46,8 @@ function isAlreadyResolvedFailure(outcome) {
         return code === 'no_pending';
     if ('errorCode' in outcome && isCodeClassifiedGateFailure(outcome.errorCode))
         return false;
+    if ('errorCode' in outcome && isDecideParkMovedCode(outcome.errorCode))
+        return true;
     return isAlreadyResolvedGateReason(outcome.reason);
 }
 export function isGateStandingErrorCode(code) {

package/dist/hitl/planReviewWire.d.ts

@@ -65,6 +65,16 @@ export interface PlanReviewDeliveryOptions {
 export interface DecidePlanReviewOptions extends PlanReviewDeliveryOptions {
     reason?: string;
 }
+export interface PlanReviewDecisionHandle {
+    settle(): void;
+    revoke(): void;
+}
+export declare function notePlanReviewDecisionHandedOver(taskId: string): PlanReviewDecisionHandle | null;
+export declare function planReviewPendingReadMark(): number;
+export declare function planReviewDecisionInFlight(taskId: string, pendingReadStartedAt?: number): boolean;
+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 interface ReopenPlanReviewOpts {
@@ -77,6 +87,7 @@ export interface ReopenPlanReviewOpts {
     trigger?: PlanReviewReopenTrigger;
     readGateInstanceKeys?: PlanReviewGateInstanceReader;
     decisionHandedOver?: (taskId: string) => boolean;
+    pendingReadStartedAt?: number;
 }
 export declare function _resetActiveReopenRespondersForTest(): void;
 export declare function reopenPlanReviewCard(taskId: string, opts: ReopenPlanReviewOpts & {