@gajae-code/coding-agent 0.13.3 → 0.14.0

package/dist/types/sdk/bus/index.d.ts

@@ -29,13 +29,30 @@ import type { AskAnswerSource, AskAnswerSourceResult, AskRemoteControl } from ".
 import { type SessionHostRuntimePublication } from "../broker/lifecycle";
 import { type SessionSdkHost } from "../host";
 import { CursorRegistry, RevisionStore } from "../host/query";
+import type { SdkFrame } from "../host/types";
 import { type SdkPromptTerminalOutcome } from "../prompt-status";
 import { type SdkStartupFailure } from "../startup-capability";
 import { type NotificationConfig } from "./config";
 import { NotificationSessionController } from "./session-control";
-import { type EnsureDaemonResult, type RegisterNotificationRootResult } from "./telegram-daemon";
+import { type EnsureDaemonResult } from "./telegram-daemon";
 export type { IdentityControlSuccessPathInput, IdentityControlTerminalPathInput, TerminalSendOutcome, } from "./control-drain-lease";
 export { isNativeControlDrainAvailable, runIdentityControlSuccessPath, runIdentityControlTerminalPath, } from "./control-drain-lease";
+export type NotificationInboundAdmission = {
+    outcome: "accept";
+} | {
+    outcome: "drop";
+    reason: "inbound_fenced" | "policy_suspended";
+} | {
+    outcome: "defer";
+    reason: "policy_suspended";
+};
+/** Exact production admission decision for daemon-originated session inbound. */
+export declare function notificationInboundAdmission(input: {
+    inboundFenced: boolean;
+    policySuspended: boolean;
+    notificationOrigin: boolean;
+    controlCommand: boolean;
+}): NotificationInboundAdmission;
 type PromptTerminalDiagnostic = {
     reason?: unknown;
     loopStopReason?: string;
@@ -70,10 +87,6 @@ export type SessionCreateTarget = {
 /** Identifies the session a `session_close` targets. */
 export interface SessionCloseTarget {
     sessionId: string;
-    /** Expected GJC-managed tmux session name (defense-in-depth match). */
-    tmuxSession?: string;
-    /** Expected `@gjc-session-state-file` tag (defense-in-depth match). */
-    sessionStateFile?: string;
 }
 /** Identifies the session a `session_resume` targets. */
 export interface SessionResumeTarget {
@@ -81,107 +94,34 @@ export interface SessionResumeTarget {
     /** Optional repo/working-dir hint to disambiguate matches. */
     path?: string;
 }
-/** Create a new session. */
-export interface SessionCreateFrame {
-    type: "session_create";
-    requestId: string;
-    /** Deterministic lifecycle marker preallocated by the daemon before spawn. */
-    lifecycleRequestId: string;
-    /** Session id the daemon preallocated and propagates to the child. */
-    intendedSessionId: string;
-    /** Telegram update id (idempotency key on the daemon side). */
-    updateId: number;
-    chatId: string;
-    /** Control-endpoint token authorizing this frame. */
-    token: string;
-    target: SessionCreateTarget;
-    /** Reserved for a future capability transport; any supplied value is rejected before lifecycle acceptance. */
-    startupPromptRef?: string;
-    /** Model profile preset to activate for the spawned session (--mpreset). */
-    modelPreset?: string;
-}
-/** Close (hard-kill, history preserved) a session. */
-export interface SessionCloseFrame {
-    type: "session_close";
-    requestId: string;
-    updateId: number;
-    chatId: string;
-    token: string;
-    target: SessionCloseTarget;
-    /** Required force-only close flag; false/omitted is rejected by daemon policy. */
-    force?: boolean;
-}
-/** Resume a session (reattach if alive, else cold-restart from history). */
-export interface SessionResumeFrame {
-    type: "session_resume";
-    requestId: string;
-    updateId: number;
-    chatId: string;
-    token: string;
-    target: SessionResumeTarget;
-    /** Reserved for a future capability transport; any supplied value is rejected before lifecycle acceptance. */
-    startupPromptRef?: string;
-}
-/** Any client -> ingress lifecycle request frame. */
-export type SessionLifecycleRequest = SessionCreateFrame | SessionCloseFrame | SessionResumeFrame;
-/** Terminal status of a lifecycle request. */
 export type LifecycleStatus = "ok" | "error";
-/** A connected session's per-session endpoint, returned to the control client. */
-export interface LifecycleEndpoint {
-    url: string;
-    token: string;
-}
-/** The Telegram topic/thread a session is surfaced in. */
-export interface LifecycleTopic {
-    chatId: string;
-    threadId: string;
-}
-/** How a create request was correlated to its spawned session. */
-export type MatchedBy = "spawn_marker" | "session_ready";
-/** Response to a successful `session_create`. */
 export interface SessionCreateResponseFrame {
     type: "session_create_response";
     requestId: string;
     status: LifecycleStatus;
-    lifecycleRequestId: string;
     sessionId: string;
-    matchedBy: MatchedBy;
-    endpoint: LifecycleEndpoint;
-    topic: LifecycleTopic;
     target: SessionCreateTarget;
 }
-/** Response to a successful `session_close`. */
 export interface SessionCloseResponseFrame {
     type: "session_close_response";
     requestId: string;
     status: LifecycleStatus;
     sessionId: string;
-    processGone: boolean;
-    historyPreserved: boolean;
-    endpointStale: boolean;
 }
-/** Whether a resume reattached to a live session or cold-restarted a dead one. */
 export type ResumeMode = "reattached" | "cold_restarted";
-/** Response to a successful `session_resume`. */
 export interface SessionResumeResponseFrame {
     type: "session_resume_response";
     requestId: string;
     status: LifecycleStatus;
     sessionId: string;
     mode: ResumeMode;
-    endpoint: LifecycleEndpoint;
-    topic: LifecycleTopic;
 }
-/** Machine-readable reason a lifecycle request failed. */
 export type LifecycleErrorReason = "unauthorized" | "rate_limited" | "duplicate_conflict" | "invalid_target" | "ambiguous_target" | "spawn_failed" | "discovery_timeout" | "readiness_timeout" | "close_refused" | "not_found" | "terminal_uncertain" | "unsupported_platform";
-/** A candidate returned with an `ambiguous_target` resume error. */
 export interface ResumeCandidate {
     sessionId: string;
     path?: string;
-    /** Last-activity epoch-millis (session history file mtime), if known. */
     mtimeMs?: number;
 }
-/** A structured lifecycle error frame. */
 export interface SessionLifecycleErrorFrame {
     type: "session_lifecycle_error";
     requestId: string;
@@ -190,7 +130,6 @@ export interface SessionLifecycleErrorFrame {
     message: string;
     candidates?: ResumeCandidate[];
 }
-/** Any ingress -> client lifecycle response frame. */
 export type SessionLifecycleResponse = SessionCreateResponseFrame | SessionCloseResponseFrame | SessionResumeResponseFrame | SessionLifecycleErrorFrame;
 /**
  * Replayable per-session readiness signal (mirror of the Rust `session_ready`
@@ -327,6 +266,9 @@ export declare class PresentationArbiter {
 interface SessionRuntime {
     server: NotificationServer;
     host: SessionSdkHost;
+    /** Delivers one ring-positioned event envelope to every attached subscriber
+     *  connection, applying the same capability gate as event replay. */
+    broadcastEventFrame: (event: SdkFrame) => void;
     /** Owns stateRoot-backed revisions and removes their spills on terminal shutdown. */
     revisions: RevisionStore;
     /** Releases all snapshot pins before the revision store is closed. */
@@ -336,6 +278,8 @@ interface SessionRuntime {
     /** Discovery scope is fixed before publication; a live default endpoint is never rotated in place. */
     endpointScope: "default" | "chat";
     idleSeq: number;
+    /** Stops delayed session-name observation when this runtime loses authority. */
+    stopSessionNameObserver: () => void;
     /** Interactive asks awaiting a remote answer, by action id. */
     pendingInteractive: Map<string, PendingInteractiveAsk>;
     /** Deregisters this session's ask answer source. */
@@ -348,6 +292,12 @@ interface SessionRuntime {
     notificationsActive: boolean;
     /** Provider ownership state is independent from the already-published core SDK runtime. */
     notificationOwnerState: "ready" | "retry" | "blocked";
+    /**
+     * Ownership-relevant configuration identity this runtime's owner state was
+     * proved under. A settled outcome may only be applied while it still matches,
+     * so a credential/destination/enablement change forces a re-proof.
+     */
+    notificationOwnerKey?: string;
     /** Rejects new SDK frames while a leased terminal response drains. */
     inboundFenced: boolean;
     /** Set as soon as terminal teardown is requested, before startup settles. */
@@ -381,12 +331,6 @@ interface SessionRuntime {
     /** This runtime's own host-liveness publication; only its teardown may retract it. */
     evidencePublication?: SessionHostRuntimePublication;
     brokerRegistrationReleased: boolean;
-    /** Managed Telegram root registration released during terminal teardown. */
-    notificationRootRegistration?: {
-        settings: Settings;
-        cwd: string;
-        registrationToken: string;
-    };
     verbosity: "lean" | "verbose";
     sessionTag: string;
     /** Whether the agent loop is currently running (drives the typing indicator). */
@@ -396,6 +340,11 @@ interface SessionRuntime {
         commandId: string;
         turnId: string;
     }>;
+    /** SDK run tokens bind an accepted queued follow-up to only its matching agent_start. */
+    pendingPromptCorrelationsBySdkRunToken: Map<string, {
+        commandId: string;
+        turnId: string;
+    }>;
     /** Identity bound to the agent lifecycle currently in flight. */
     activePromptCorrelation?: {
         commandId: string;
@@ -425,7 +374,7 @@ interface SessionRuntime {
     } | {
         type: "agent_failed";
         error: unknown;
-    }) => void;
+    }) => void | Promise<void>;
     /** Settles and emits one sanitized correlated prompt failure. */
     emitPromptFailure: (correlation: {
         commandId: string;
@@ -473,17 +422,33 @@ interface SessionRuntime {
     turnClosed?: boolean;
     /** Finalized while provisional policy was held; flush exactly once on stable activation. */
     pendingFinal?: {
-        text?: string;
-        messageRef?: string;
+        window: number;
+        receipts: Array<{
+            text: string;
+            messageRef?: string;
+            origin: "user" | "autonomous" | "continuation";
+        }>;
     };
+    /** Monotonic user-request boundary for deferred lean delivery. */
+    settlementWindow: number;
+    /** Provenance of the currently executing assistant turn. */
+    currentTurnSettlementOrigin?: "user" | "autonomous" | "continuation";
+    /** Immutable settlement boundary captured when the current turn begins. */
+    currentTurnSettlementWindow?: number;
     /**
-     * Lean-mode deferred final answer: latest assistant text observed at `turn_end`,
-     * emitted once at `agent_end` so intermediate tool-turn narration does not flood
-     * remote clients. Cleared after flush or when replaced by a newer turn.
+     * Lean-mode deferred receipts for the current user-request settlement window.
+     * Ordinary tool-loop turns retain latest-turn-wins behaviour. An autonomous
+     * continuation has no new user request, so it appends instead of erasing the
+     * prior receipt. The small fixed receipt bound prevents an unbounded idle wait
+     * from retaining the full transcript.
      */
     pendingSettled?: {
-        text: string;
-        messageRef?: string;
+        window: number;
+        receipts: Array<{
+            text: string;
+            messageRef?: string;
+            origin: "user" | "autonomous" | "continuation";
+        }>;
     };
     /** SDK control frames received during provisional ownership; replayed only after stable activation. */
     deferredInboundControls: Array<() => void>;
@@ -594,9 +559,13 @@ export declare class EphemeralTurnHost {
     evictTerminalEvents(): void;
 }
 /**
- * Ensures every configured chat-provider daemon is ready before the SDK
- * publishes session identity. A rejected ensure is startup-fatal: presenting
- * an identity for a transport that never became available is false success.
+ * Ensures every configured chat-provider daemon is ready.
+ *
+ * This runs strictly AFTER the SDK publishes session identity and its core
+ * endpoint, through the detached ownership coordinator: chat providers are
+ * optional notification adapters, never session authority. A rejected ensure
+ * therefore degrades notification delivery only — the coordinator records it
+ * as `failed`, adapters stay withheld, and a later reconcile re-attempts.
  */
 export declare function ensureConfiguredProviderDaemons(settings: Settings, cfg: NotificationConfig, ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<unknown>): Promise<void>;
 /**
@@ -614,9 +583,6 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     settings?: Settings;
     ensureTelegramDaemon?: (input: {
         settings: Settings;
-        cwd: string;
-        sessionId: string;
-        onRegistered?: (registration: RegisterNotificationRootResult) => void;
     }) => Promise<EnsureDaemonResult>;
     ensureProviderDaemon?: (provider: "discord" | "slack", settings: Settings) => Promise<unknown>;
     /** Suppress auto-delivery for a GJC-spawned child under `sessionScope=primary`. */
@@ -635,4 +601,24 @@ export declare function createNotificationsExtension(api: ExtensionAPI, options?
     }) => void;
     readNotificationFile?: (path: string) => Promise<Buffer>;
     readNotificationDiffStat?: (cwd: string) => Promise<string | undefined>;
+    /**
+     * INTERNAL terminal-abort session seams, threaded directly from the owning
+     * session — deliberately NOT on the public ExtensionContext so third-party
+     * extensions cannot observe attempt epochs or cancel the session-global
+     * preflight outside the durable admission path (review thread P2).
+     */
+    terminalAbortSeams?: {
+        getTerminalTurnEpoch: () => number | undefined;
+        cancelPendingPreflightForTerminalAbort: () => void;
+        captureTerminalAbortSteeringSnapshot?: () => void;
+        discardTerminalAbortSteeringSnapshot?: (token: number) => void;
+        rebindTerminalAbortSteeringSnapshot?: (token: number) => void;
+        abortPromptAndWaitWithTerminal: (handle: string, options: {
+            graceMs: number;
+            terminal?: {
+                scope: "turn" | "owned";
+                expectedEpoch?: number;
+            };
+        }) => Promise<RunSettlementProof>;
+    };
 }): void;

package/dist/types/sdk/bus/kind-aware-reconciliation.d.ts

@@ -1,8 +1,5 @@
-/**
- * Kind-aware invocation reconciliation (prompt | skill) with optional durable store.
- * Preserves Q26 admit/first-terminal/capacity/TTL semantics; indexes and caps are per-kind.
- */
 import type { PromptReconciliationStatus, SdkPromptTerminalOutcome, TurnPromptReconciliation } from "../prompt-status";
+import type { ReceiptState } from "../receipt-state";
 import { type TurnResultContent, type TurnResultPage } from "../turn-result";
 import { type PromptCorrelation } from "./prompt-reconciliation";
 import type { ReconciliationKind, ReconciliationStore } from "./reconciliation-store";
@@ -11,6 +8,18 @@ export interface KindCorrelation extends PromptCorrelation {
     kind: ReconciliationKind;
     content?: TurnResultContent;
 }
+export interface SteerReconciliationResult {
+    commandId: string;
+    turnId: string;
+    clientRef: string;
+    status: "accepted" | "rejected" | "uncertain";
+    acceptedAt: number;
+    terminalAt?: number;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
 export interface KindAwareReconciliation {
     admit(kind: ReconciliationKind, clientRef?: string): void;
     releaseAdmission(kind: ReconciliationKind, clientRef?: string): void;
@@ -25,12 +34,12 @@ export interface KindAwareReconciliation {
         error: unknown;
         content?: TurnResultContent;
     }): Promise<void>;
-    claimPendingOutcome(correlation: PromptCorrelation, outcome: SdkPromptTerminalOutcome): Promise<SdkPromptTerminalOutcome>;
-    finalizePromptOutcome(correlation: PromptCorrelation, outcome?: SdkPromptTerminalOutcome, recordError?: {
+    claimPendingOutcome(kind: ReconciliationKind, correlation: PromptCorrelation, outcome: SdkPromptTerminalOutcome, receiptState?: Extract<ReceiptState, "present" | "missing">): Promise<SdkPromptTerminalOutcome>;
+    finalizeOutcome(kind: ReconciliationKind, correlation: PromptCorrelation, outcome?: SdkPromptTerminalOutcome, recordError?: {
         code: string;
         message: string;
     }, content?: unknown): Promise<void>;
-    peekPendingOutcome(correlation: PromptCorrelation): SdkPromptTerminalOutcome | undefined;
+    peekPendingOutcome(kind: ReconciliationKind, correlation: PromptCorrelation): SdkPromptTerminalOutcome | undefined;
     lookup(kind: ReconciliationKind, selector: {
         commandId?: string;
         turnId?: string;
@@ -41,6 +50,19 @@ export interface KindAwareReconciliation {
         turnId?: string;
         clientRef?: string;
     }): TurnResultPage;
+    reserveSteer(clientRef: string, text: string): Promise<{
+        replay: boolean;
+        result: SteerReconciliationResult;
+    }>;
+    settleSteer(clientRef: string, status: "accepted" | "rejected" | "uncertain", error?: unknown): Promise<SteerReconciliationResult>;
+    lookupSteer(selector: string | {
+        commandId?: string;
+        turnId?: string;
+        clientRef?: string;
+    }): SteerReconciliationResult | {
+        clientRef?: string;
+        status: "unknown";
+    };
     cleanup(): void;
     activeCount(kind: ReconciliationKind): number;
     /** Hydrate from durable store (call once at session host start). */

package/dist/types/sdk/bus/managed-daemon.d.ts

@@ -1,48 +1,18 @@
-import type { Settings } from "../../config/settings";
 import { RateLimitPool } from "./rate-limit-pool";
 import { type ThreadedSend } from "./threaded-render";
-export interface ManagedNotificationDaemonFs {
-    readdir(path: string): Promise<string[]>;
-}
-export interface ManagedSessionSocket {
-    sessionId: string;
-    token: string;
-    ws: WebSocket;
-    pending: Map<string, {
-        sessionId: string;
-        actionId: string;
-    }>;
-    capable: boolean;
-    lastPongAt: number;
-    awaitingNonce: string | undefined;
-    pingTimer: ReturnType<typeof setInterval> | undefined;
-}
+/** Shared presentation engine for managed notification providers. */
 export interface ManagedNotificationDaemonOptions {
-    settings: Settings;
-    fs: ManagedNotificationDaemonFs;
-    WebSocketImpl?: typeof WebSocket;
     now?: () => number;
-    setIntervalImpl?: typeof setInterval;
-    clearIntervalImpl?: typeof clearInterval;
     rateLimitPool?: RateLimitPool<{
         send: ThreadedSend;
         topicId?: string;
     }>;
 }
 export declare abstract class ManagedNotificationDaemon {
-    protected readonly opts: ManagedNotificationDaemonOptions;
-    readonly sessions: Map<string, ManagedSessionSocket>;
     readonly pool: RateLimitPool<{
         send: ThreadedSend;
         topicId?: string;
     }>;
-    protected constructor(opts: ManagedNotificationDaemonOptions);
-    scanRoots(): Promise<void>;
-    connectSession(sessionId: string, url: string, token: string): ManagedSessionSocket;
-    protected handleSessionMessage(session: ManagedSessionSocket, msg: Record<string, unknown>): Promise<boolean>;
+    protected constructor(opts?: ManagedNotificationDaemonOptions);
     protected renderFrame(frame: Record<string, unknown>): ThreadedSend | undefined;
-    protected dropSession(session: ManagedSessionSocket): void;
-    protected abstract readRoots(): Promise<string[]>;
-    private sendHello;
-    private startLiveness;
 }

package/dist/types/sdk/bus/notification-service.d.ts

@@ -251,6 +251,14 @@ export interface NotificationRecoveryReport {
     endpointsRetainedPlaceholders?: string[];
     /** Cleanup entries retained with unverified or mismatching identity. */
     endpointsRetainedUnknown?: string[];
+    /** Stale quarantine/staging debris removed from the endpoint and daemon dirs. */
+    debrisRemoved?: string[];
+    /** Debris candidates retained by policy (young, live writer). */
+    debrisKept?: number;
+    /** Debris removals attempted without conclusive success (identity/unlink). */
+    debrisFailures?: number;
+    /** At least one debris directory listing failed; the sweep was not exhaustive. */
+    debrisScanFailed?: boolean;
     daemon: {
         action: DaemonRecoveryAction;
         detail: string;
@@ -317,6 +325,50 @@ export declare function acquireDaemonTransitionLock(input: {
     retryDelayMs?: number;
     randomToken?: () => string;
 }): Promise<DaemonTransitionLock | undefined>;
+/**
+ * Minimum age before age-based debris removal. Quarantine artifacts are inert
+ * the moment they are detached, but the age bound keeps the sweep clear of any
+ * recovery pass still holding a `detachedPath` reference in its report.
+ */
+export declare const NOTIFICATION_DEBRIS_MIN_AGE_MS: number;
+export interface NotificationDebrisSweepReport {
+    /** Basenames removed from the swept directory. */
+    removed: string[];
+    /** Debris candidates retained (young, live writer, or identity/unlink refusal). */
+    kept: number;
+    /**
+     * Candidates whose removal was ATTEMPTED and did not conclusively succeed
+     * (identity mismatch, unreadable candidate, unlink error). Distinct from
+     * `kept`-by-policy so a caller can see that a sweep was not fully effective.
+     */
+    failures: number;
+    /** The directory listing itself failed; nothing could be inspected. */
+    scanFailed?: boolean;
+}
+/**
+ * Remove inert filesystem debris from a notification/state directory:
+ * quarantine targets of already-detached markers and endpoints, exact-unlink
+ * exchange placeholders, and leaked atomic-write staging files.
+ *
+ * Removal requires positive staleness proof — a dead recorded writer pid for
+ * staging files, or an mtime older than {@link NOTIFICATION_DEBRIS_MIN_AGE_MS}
+ * for everything else. Canonical files can never match the debris patterns, and
+ * a young staging file with a live writer is kept.
+ *
+ * Age, terminal-scrub proof, and the delete identity all come from ONE
+ * no-follow snapshot of the candidate. Judging age from a separate `stat` would
+ * prove one pathname stale and then bind the delete to whatever occupied that
+ * pathname afterwards, so a live successor could be removed on a predecessor's
+ * staleness. A candidate replaced after the snapshot fails the identity match
+ * and is retained; a symlinked, non-regular, or unreadable candidate is refused
+ * outright. Every inconclusive attempt is counted in `failures` rather than
+ * silently folded into `kept`.
+ */
+export declare function sweepNotificationDebris(input: {
+    dir: string;
+    deps?: NotificationServiceDeps;
+    minAgeMs?: number;
+}): Promise<NotificationDebrisSweepReport>;
 /**
  * Ownership-protected cleanup. Removes only DEAD-owner artifacts:
  * per-session endpoint files with positive proof of death (a stale tombstone or

package/dist/types/sdk/bus/operator-runtime.d.ts

@@ -1,6 +1,6 @@
 export interface NotificationOperatorTimerDeps {
     now?: () => number;
-    setTimeoutImpl?: typeof setTimeout;
+    setTimeoutImpl?: (callback: () => void, ms?: number) => Timer | NodeJS.Timeout;
     clearTimeoutImpl?: typeof clearTimeout;
     setIntervalImpl?: typeof setInterval;
     clearIntervalImpl?: typeof clearInterval;

package/dist/types/sdk/bus/prompt-reconciliation.d.ts

@@ -1,5 +1,6 @@
 /**
- * Bounded authoritative reconciliation state for Q26 `turn.prompt_status`.
+ * Bounded prompt reconciliation state for canonical Q26 `turn.result` with
+ * `kind: "prompt"`, plus the legacy `turn.prompt_status` alias.
  *
  * Separate from the lifecycle delivery buffers (promptSubmissions /
  * promptTerminalTombstones), which exist to deliver frames and intentionally
@@ -9,8 +10,8 @@
  *
  * Semantics (public contract, mirrored in sdk/prompt-status.ts):
  * - Active records are NEVER converted to terminal by age or capacity.
- * - Terminal records are retained for TERMINAL_TTL_MS and bounded to
- *   TERMINAL_CAPACITY, evicted oldest-terminal-first by terminalAt; only then
+ * - Terminal records are bounded to TERMINAL_CAPACITY and evicted
+ *   oldest-terminal-first by terminalAt; only then
  *   does a lookup honestly report `unknown`.
  * - Process-local durability floor is the live session process: restart means `unknown`.
  *   Session-scoped durable retention (kind-aware store) is provided by reconciliation-store.ts (#3032).
@@ -21,10 +22,10 @@
  *   record that has none, but never changes status, terminalAt, or retention.
  */
 import { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure } from "../prompt-failure";
+import type { ReceiptState } from "../receipt-state";
 export { PROMPT_FAILURE_CODE_MAX, sanitizePromptFailure };
 export declare const PROMPT_RECONCILIATION_ACTIVE_CAPACITY = 128;
 export declare const PROMPT_RECONCILIATION_TERMINAL_CAPACITY = 256;
-export declare const PROMPT_RECONCILIATION_TERMINAL_TTL_MS: number;
 export type PromptReconciliationStatus = "accepted" | "in_flight" | "terminal_ok" | "failed";
 export interface PromptCorrelation {
     commandId: string;
@@ -40,15 +41,18 @@ export interface PromptReconciliationRecord extends PromptCorrelation {
     acceptedAt: number;
     startedAt?: number;
     terminalAt?: number;
+    receiptState?: Exclude<ReceiptState, "absent">;
 }
 export type TurnPromptReconciliation = {
     status: "accepted";
+    receiptState: "absent";
     commandId: string;
     turnId: string;
     clientRef?: string;
     acceptedAt: number;
 } | {
     status: "in_flight";
+    receiptState: "absent";
     commandId: string;
     turnId: string;
     clientRef?: string;
@@ -56,6 +60,7 @@ export type TurnPromptReconciliation = {
     startedAt: number;
 } | {
     status: "terminal_ok";
+    receiptState: Exclude<ReceiptState, "absent">;
     commandId: string;
     turnId: string;
     clientRef?: string;
@@ -69,6 +74,7 @@ export type TurnPromptReconciliation = {
     };
 } | {
     status: "failed";
+    receiptState: Exclude<ReceiptState, "absent">;
     commandId: string;
     turnId: string;
     clientRef?: string;
@@ -81,6 +87,7 @@ export type TurnPromptReconciliation = {
     };
 } | {
     status: "unknown";
+    receiptState: "unknown";
 };
 export interface PromptReconciliation {
     /** Fail-closed admission BEFORE any execution; holds an identity-bound reservation. */
@@ -91,10 +98,14 @@ export interface PromptReconciliation {
     noteAccepted(correlation: PromptCorrelation, clientRef?: string): void;
     /** Lifecycle transition; terminal outcomes settle exactly once. */
     noteTransition(correlation: PromptCorrelation | undefined, frame: {
-        type: "agent_start" | "agent_end";
+        type: "agent_start";
+    } | {
+        type: "agent_end";
+        finalText?: string;
     } | {
         type: "agent_failed";
         error: unknown;
+        finalText?: string;
     }): void;
     lookup(selector: {
         commandId?: string;