reasonix 0.25.0 → 0.26.0

package/dist/index.d.ts

@@ -218,6 +218,111 @@ declare function aggregateBranchUsage(samples: readonly BranchSample[]): {
     promptCacheMissTokens: number;
 };
 
+/** Generic pause gate — bridges tool functions and the App's modals via Promises. */
+type ConfirmationChoice = {
+    type: "deny";
+    denyContext?: string;
+} | {
+    type: "run_once";
+} | {
+    type: "always_allow";
+    prefix: string;
+};
+type PlanVerdict = {
+    type: "approve";
+} | {
+    type: "refine";
+} | {
+    type: "cancel";
+};
+type CheckpointVerdict = {
+    type: "continue";
+} | {
+    type: "revise";
+    feedback?: string;
+} | {
+    type: "stop";
+};
+type RevisionVerdict = {
+    type: "accepted";
+} | {
+    type: "rejected";
+} | {
+    type: "cancelled";
+};
+type ChoiceVerdict = {
+    type: "pick";
+    optionId: string;
+} | {
+    type: "text";
+    text: string;
+} | {
+    type: "cancel";
+};
+interface PauseResponseMap {
+    run_command: ConfirmationChoice;
+    run_background: ConfirmationChoice;
+    plan_proposed: PlanVerdict;
+    plan_checkpoint: CheckpointVerdict;
+    plan_revision: RevisionVerdict;
+    choice: ChoiceVerdict;
+}
+type PauseKind = keyof PauseResponseMap;
+interface PausePayloadMap {
+    run_command: {
+        command: string;
+    };
+    run_background: {
+        command: string;
+    };
+    plan_proposed: {
+        plan: string;
+        steps?: unknown[];
+        summary?: string;
+    };
+    plan_checkpoint: {
+        stepId: string;
+        title?: string;
+        result: string;
+        notes?: string;
+    };
+    plan_revision: {
+        reason: string;
+        remainingSteps: unknown[];
+        summary?: string;
+    };
+    choice: {
+        question: string;
+        options: unknown[];
+        allowCustom: boolean;
+    };
+}
+type PauseRequest = {
+    id: number;
+    kind: PauseKind;
+    payload: unknown;
+};
+type GateListener = (request: PauseRequest) => void;
+/** Named options for PauseGate.ask() — makes it obvious which field is kind vs payload. */
+interface PauseAskOpts<K extends PauseKind = PauseKind> {
+    kind: K;
+    payload: PausePayloadMap[K];
+}
+declare class PauseGate {
+    private _nextId;
+    private _pending;
+    private _listeners;
+    /** Block until the user responds. Takes a named options object so the
+     *  kind and payload fields don't get confused at the call site. */
+    ask<K extends PauseKind>(opts: PauseAskOpts<K>): Promise<PauseResponseMap[K]>;
+    /** Resolve a pending request. Called by the App's modal callback. */
+    resolve(id: number, data: unknown): void;
+    /** Subscribe to new pause requests. Returns an unsubscribe function. */
+    on(fn: GateListener): () => void;
+    /** Current pending request, if any (polling fallback). */
+    get current(): PauseRequest | null;
+}
+
 /** Shell-command hooks; project scope first, then global. Exit 0=pass, 2=block on Pre*, other=warn. */
 type HookEvent = "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop";
 /** All four events as a const array — drives slash listing + validation. */
@@ -482,6 +587,8 @@ declare class SessionStats {
 
 interface ToolCallContext {
     signal?: AbortSignal;
+    /** Inject a mock PauseGate for tests. When absent, tools use the singleton. */
+    confirmationGate?: PauseGate;
 }
 interface ToolDefinition<A = any, R = any> {
     name: string;
@@ -522,6 +629,8 @@ declare class ToolRegistry {
         signal?: AbortSignal;
         maxResultChars?: number;
         maxResultTokens?: number;
+        /** Inject a mock PauseGate for tests. */
+        confirmationGate?: PauseGate;
     }): Promise<string>;
 }
 
@@ -587,6 +696,8 @@ interface CacheFirstLoopOptions {
     hooks?: ResolvedHook[];
     /** `cwd` reported to hooks; `reasonix code` sets this to the sandbox root, not shell home. */
     hookCwd?: string;
+    /** PauseGate bridge — defaults to singleton, injectable for tests. */
+    confirmationGate?: PauseGate;
 }
 interface ReconfigurableOptions {
     model?: string;
@@ -621,6 +732,8 @@ declare class CacheFirstLoop {
     sessionName: string | null;
     hooks: ResolvedHook[];
     hookCwd: string;
+    /** PauseGate bridge — defaults to singleton, injectable for tests. */
+    readonly confirmationGate: PauseGate;
     /** Number of messages that were pre-loaded from the session file. */
     readonly resumedMessageCount: number;
     private _turn;
@@ -632,16 +745,18 @@ declare class CacheFirstLoop {
     private _turnFailureCount;
     private _turnFailureTypes;
     private _turnSelfCorrected;
+    private _foldedThisTurn;
+    private context;
     constructor(opts: CacheFirstLoopOptions);
-    /** Shrink huge edit_file/write_file args post-dispatch — tool result already explains. */
-    private compactToolCallArgsAfterResponse;
-    /** Preventive end-of-turn shrink — trim big results before they ride into the next prompt. */
-    private autoCompactToolResultsOnTurnEnd;
-    compact(maxTokens?: number): {
-        healedCount: number;
-        tokensSaved: number;
-        charsSaved: number;
-    };
+    /** Replace older turns with one summary message; keep tail within keepRecentTokens budget. */
+    compactHistory(opts?: {
+        keepRecentTokens?: number;
+    }): Promise<{
+        folded: boolean;
+        beforeMessages: number;
+        afterMessages: number;
+        summaryChars: number;
+    }>;
     appendAndPersist(message: ChatMessage): void;
     /** Swap the just-appended assistant entry — used by self-correction to restore the original tool_calls without dropping reasoning_content. */
     private replaceTailAssistantMessage;