@scotthuang/agent-knock-knock 0.13.2 → 0.13.4

package/dist/src/terminal-submission-retry-reconciliation.d.ts

@@ -0,0 +1,236 @@
+import { type DeferredForegroundTransfer } from "./deferred-foreground-transfer.js";
+import { type Conversation } from "./protocol.js";
+import type { TerminalControlRef } from "./terminal-agent-adapter.js";
+import type { TerminalAgentBridge } from "./terminal-agent-bridge.js";
+import { type TerminalSubmissionRetryRecord } from "./terminal-submission-retry-service.js";
+import type { CanonicalMutationResources, CanonicalMutationScopes, CanonicalStateMutationResources, CanonicalStateMutationScopes } from "./mutation-transaction.js";
+import { type TerminalDispatchLedgerDocument } from "./terminal-dispatch-ledger-codec.js";
+import type { DeferredCodexForegroundBindingBoundary, TerminalDispatchTerminal } from "./terminal-dispatch-composition.js";
+import type { DeferredForegroundApplicationScope } from "./deferred-foreground-boundary.js";
+import { type TerminalDispatchExecutionService } from "./terminal-dispatch-execution.js";
+import type { TerminalCommandCliOptions, TerminalDispatchRecord } from "./terminal-command-cli-ports.js";
+import type { TerminalSubmissionRetryReconciliationPorts } from "./terminal-submission-retry-ports.js";
+export interface TerminalSubmissionRetryDeferredContext {
+    scope: DeferredForegroundApplicationScope;
+    transfer: DeferredForegroundTransfer;
+    boundary: DeferredCodexForegroundBindingBoundary;
+}
+export interface TerminalSubmissionRetryInvocation {
+    options: TerminalCommandCliOptions;
+    exactTurnId: string;
+    statePath: string;
+    logPath: string;
+    storeDir: string;
+    bridge: TerminalAgentBridge;
+    live: TerminalDispatchTerminal;
+    terminalControl: TerminalControlRef;
+}
+export interface TerminalSubmissionRetryLockedAuthority {
+    conversation: Conversation;
+    takeover?: Record<string, unknown>;
+    submission: TerminalDispatchRecord;
+    ledger: TerminalDispatchLedgerDocument;
+    attempt?: TerminalSubmissionRetryRecord;
+    currentMessageId: string;
+    originalMessageId: string;
+    requestText: string;
+    requestHash: string;
+    deferredTransferId?: string;
+    lifecycleSettled: boolean;
+}
+export interface TerminalSubmissionRetryFlowState {
+    conversation: Conversation;
+    submission: TerminalDispatchRecord;
+    ledger: TerminalDispatchLedgerDocument;
+    attempt?: TerminalSubmissionRetryRecord;
+}
+export interface TerminalSubmissionRetryFlowContext {
+    invocation: TerminalSubmissionRetryInvocation;
+    scopes: CanonicalStateMutationScopes;
+    resources: CanonicalStateMutationResources;
+    execution: TerminalDispatchExecutionService;
+    deferred?: TerminalSubmissionRetryDeferredContext;
+    takeover?: Record<string, unknown>;
+    currentMessageId: string;
+    originalMessageId: string;
+    requestText: string;
+    requestHash: string;
+}
+export declare class TerminalSubmissionRetryReconciliation {
+    private readonly ports;
+    constructor(ports: TerminalSubmissionRetryReconciliationPorts);
+    terminalSubmissionRetryBaseRecord(input: {
+        mode: "exact_draft_enter" | "replacement_send";
+        state: TerminalSubmissionRetryRecord["state"];
+        attemptId: string;
+        storeDir: string;
+        statePath: string;
+        conversation: Conversation;
+        originalMessageId: string;
+        activeMessageId: string;
+        requestHash: string;
+        terminalControl: TerminalControlRef;
+        at: string;
+        deferredTransferId?: string;
+    }): TerminalSubmissionRetryRecord;
+    assertTerminalSubmissionRetryAttemptIdentity(input: {
+        attempt?: TerminalSubmissionRetryRecord;
+        conversation: Conversation;
+        storeDir: string;
+        statePath: string;
+        originalMessageId: string;
+        requestHash: string;
+        terminalControl: TerminalControlRef;
+        deferredTransferId?: string;
+    }): void;
+    terminalSubmissionRetryMessageType(submission: TerminalDispatchRecord): "task" | "answer";
+    withDeferredTransferSubmissionAuthority(conversation: Conversation, messageId: string, transferId: string): Conversation;
+    terminalSubmissionRetryUnstalled(conversation: Conversation): Conversation;
+    withTerminalSubmissionRetryMonitorEpoch(conversation: Conversation, at: string): Conversation;
+    terminalSubmissionRetryAccepted(input: {
+        conversation: Conversation;
+        submission: TerminalDispatchRecord;
+        ledger: TerminalDispatchLedgerDocument;
+        evidence: NonNullable<Awaited<ReturnType<TerminalDispatchExecutionService["detectAcceptance"]>>>;
+        requestText: string;
+        at: string;
+        statePath: string;
+        logPath: string;
+        scopes: CanonicalMutationScopes;
+        resources: CanonicalMutationResources;
+        attempt?: TerminalSubmissionRetryRecord;
+        terminalInputSent: boolean;
+    }): {
+        conversation: Conversation;
+        attempt?: TerminalSubmissionRetryRecord;
+    };
+    terminalSubmissionRetryTerminalOutcome(input: {
+        conversation: Conversation;
+        submission: TerminalDispatchRecord;
+        ledger: TerminalDispatchLedgerDocument;
+        requestText: string;
+        reason: string;
+        at: string;
+        statePath: string;
+        logPath: string;
+        scopes: CanonicalMutationScopes;
+        resources: CanonicalMutationResources;
+        attempt: TerminalSubmissionRetryRecord;
+        outcome: "not_accepted" | "uncertain";
+    }): Conversation;
+    finalizeDeferredTerminalSubmissionRetryAccepted(input: {
+        statePath: string;
+        scopes: CanonicalMutationScopes;
+        resources: CanonicalMutationResources;
+        attempt?: TerminalSubmissionRetryRecord;
+    }): {
+        conversation: Conversation;
+        attempt?: TerminalSubmissionRetryRecord;
+    };
+    reconcileTerminalSubmissionRetryPending(input: {
+        conversation: Conversation;
+        submission: TerminalDispatchRecord;
+        ledger: TerminalDispatchLedgerDocument;
+        attempt: TerminalSubmissionRetryRecord;
+        requestText: string;
+        statePath: string;
+        logPath: string;
+        scopes: CanonicalMutationScopes;
+        resources: CanonicalMutationResources;
+        deferred?: TerminalSubmissionRetryDeferredContext;
+    }): Conversation;
+    assertTerminalSubmissionRetryDeferredMirror(input: {
+        attempt: TerminalSubmissionRetryRecord;
+        transfer: DeferredForegroundTransfer;
+        submission: TerminalDispatchRecord;
+    }): void;
+    assertTerminalSubmissionRetryDeferredMirrorCanReconcile(input: {
+        attempt: TerminalSubmissionRetryRecord;
+        transfer: DeferredForegroundTransfer;
+        submission: TerminalDispatchRecord;
+    }): void;
+    terminalSubmissionRetryTransportRank(attempt: TerminalSubmissionRetryRecord): number;
+    reconcileTerminalSubmissionRetryLedgerPrefix(input: {
+        attempt: TerminalSubmissionRetryRecord;
+        ledger: TerminalDispatchLedgerDocument;
+    }): {
+        ledger: TerminalDispatchLedgerDocument;
+        changed: boolean;
+    };
+    terminalSubmissionRetryLedgerStates(attempt: TerminalSubmissionRetryRecord): {
+        previous?: TerminalSubmissionRetryRecord["state"];
+    };
+    terminalSubmissionRetryLedgerFieldsAtState(attempt: TerminalSubmissionRetryRecord, state: TerminalSubmissionRetryRecord["state"], revision: number): Record<string, unknown>;
+    printTerminalSubmissionRetryOutcome(input: {
+        conversation: Conversation;
+        terminalControl: TerminalControlRef;
+        attempt?: TerminalSubmissionRetryRecord;
+        outcome: "agent_accepted" | "enter_dispatched" | "not_accepted" | "refused";
+        terminalInputSent: boolean;
+        reason: string;
+    }): void;
+    loadExactTerminalSubmissionRetryTurn(input: {
+        statePath: string;
+        exactTurnId: string;
+    }): Conversation;
+    assertTerminalSubmissionRetryTurnOpen(input: {
+        statePath: string;
+        exactTurnId: string;
+    }): Conversation;
+    saveTerminalSubmissionRetryForOpenTurn(statePath: string, candidate: TerminalSubmissionRetryRecord, expectedRevision: number | null): TerminalSubmissionRetryRecord;
+    loadTerminalSubmissionRetryLockedAuthority(input: {
+        invocation: TerminalSubmissionRetryInvocation;
+        scopes: CanonicalStateMutationScopes;
+        resources: CanonicalStateMutationResources;
+    }): TerminalSubmissionRetryLockedAuthority;
+    assertTerminalSubmissionRetryLedgerAuthority(input: {
+        ledger?: TerminalDispatchLedgerDocument;
+        conversation: Conversation;
+        exactTurnId: string;
+        currentMessageId: string;
+        messageType: "task" | "answer";
+        messageBodyHash: string;
+        requestHash: string;
+        storeDir: string;
+        statePath: string;
+        terminalControl: TerminalControlRef;
+    }): asserts input is typeof input & {
+        ledger: TerminalDispatchLedgerDocument;
+    };
+    exactTerminalSubmissionRetryDeferredTransferId(input: {
+        takeover?: Record<string, unknown>;
+        submission: TerminalDispatchRecord;
+        ledger: TerminalDispatchLedgerDocument;
+    }): string | undefined;
+    assertTerminalSubmissionRetryGeneration(input: {
+        attempt?: TerminalSubmissionRetryRecord;
+        takeover?: Record<string, unknown>;
+        currentMessageId: string;
+        originalMessageId: string;
+    }): void;
+    reconcileTerminalSubmissionRetryDeferredTransfer(input: {
+        invocation: TerminalSubmissionRetryInvocation;
+        scope: DeferredForegroundApplicationScope;
+        boundary: DeferredCodexForegroundBindingBoundary;
+        transfer: DeferredForegroundTransfer;
+        attempt?: TerminalSubmissionRetryRecord;
+        submission: TerminalDispatchRecord;
+    }): DeferredForegroundTransfer;
+    prepareTerminalSubmissionRetryDeferredContext(input: {
+        invocation: TerminalSubmissionRetryInvocation;
+        authority: TerminalSubmissionRetryLockedAuthority;
+        scopes: CanonicalStateMutationScopes;
+        resources: CanonicalStateMutationResources;
+    }): {
+        deferred?: TerminalSubmissionRetryDeferredContext;
+        ledger: TerminalDispatchLedgerDocument;
+    };
+    assertTerminalSubmissionRetryDeferredTransferAuthority(input: {
+        invocation: TerminalSubmissionRetryInvocation;
+        authority: TerminalSubmissionRetryLockedAuthority;
+        transfer: DeferredForegroundTransfer;
+        attempt?: TerminalSubmissionRetryRecord;
+    }): void;
+    reconcileTerminalSubmissionRetryDeferredPending(context: TerminalSubmissionRetryFlowContext, state: TerminalSubmissionRetryFlowState): boolean;
+    recoverPartialTerminalSubmissionRetryAcceptance(context: TerminalSubmissionRetryFlowContext, state: TerminalSubmissionRetryFlowState): Promise<boolean>;
+}