agent-afk 5.92.0 → 5.93.0

package/dist/agent/providers/{anthropic-direct/loop → shared}/turn-trace.d.ts

@@ -1,9 +1,10 @@
-import type { TraceWriter } from '../../../trace/index.js';
+import type { TraceWriter } from '../../trace/index.js';
 export declare class TurnTrace {
     private readonly signal;
     private readonly traceWriter;
+    private readonly provider;
     private interruptedAt;
-    constructor(signal: AbortSignal, traceWriter: TraceWriter | undefined);
+    constructor(signal: AbortSignal, traceWriter: TraceWriter | undefined, provider: 'anthropic-direct' | 'openai-compatible');
     private readonly onInterrupt;
     finish(turnElapsedMs: number): void;
 }

package/dist/agent/tools/dispatcher.d.ts

@@ -84,6 +84,7 @@ export declare class SessionToolDispatcher implements ToolDispatcher {
     private recordForkReadDenial;
     private resetDenialBreaker;
     private runCanUseTool;
+    private runPreDispatchGates;
     execute(call: ToolCall): Promise<ToolResult>;
     executeBatch(calls: ToolCall[]): Promise<ToolResult[]>;
     private executeCore;

package/dist/cli/_lib/capture-mode.d.ts

@@ -3,6 +3,7 @@ export declare function detectBell(env?: NodeJS.ProcessEnv): boolean;
 export declare function detectReducedMotion(env?: NodeJS.ProcessEnv): boolean;
 export declare function detectCaretBlink(env?: NodeJS.ProcessEnv): boolean;
 export declare function detectGoblinSpinner(env?: NodeJS.ProcessEnv): boolean;
+export declare function detectGoblinMascot(env?: NodeJS.ProcessEnv): boolean;
 export declare function ringBellIfEnabled(stream: {
     write(s: string): unknown;
     isTTY?: boolean;

package/dist/cli/_lib/stream-renderer.d.ts

@@ -22,7 +22,7 @@ export interface StreamRendererOptions {
     captureMode?: boolean;
     reducedMotion?: boolean;
     compositor?: TerminalCompositor;
-    onStageChange?: (stage: import('../commands/interactive/loop-stage.js').LoopStage) => void;
+    onStageChange?: (stage: import('../commands/interactive/loop-stage.js').LoopStage, signals?: import('../commands/interactive/loop-stage.js').StageSignals) => void;
 }
 export declare class StreamRenderer {
     private readonly out;

package/dist/cli/commands/interactive/footer-subsystems.d.ts

@@ -3,6 +3,8 @@ import { createContextPane } from './context-pane.js';
 import { createVerdictLedger } from './verdict-ledger.js';
 import { BackgroundStatusBar } from '../../background-status-bar.js';
 import { LoopStageBar } from './loop-stage.js';
+import { LiveMascot } from './mascot-live.js';
+import { MascotBand } from './mascot-band.js';
 import { ShellPassthrough } from './shell-passthrough.js';
 import { BgResultNotifier } from './bg-result-notifier.js';
 import type { TurnState } from './repl-loop-shared.js';
@@ -10,6 +12,8 @@ export interface FooterSubsystems {
     contextPane: ReturnType<typeof createContextPane>;
     bgStatusBar: BackgroundStatusBar;
     loopStageBar: LoopStageBar;
+    liveMascot: LiveMascot;
+    mascotBand: MascotBand;
     verdictLedger: ReturnType<typeof createVerdictLedger>;
     shellPassthrough: ShellPassthrough;
     bgResultNotifier: BgResultNotifier;

package/dist/cli/commands/interactive/loop-stage.d.ts

@@ -1,5 +1,8 @@
 import type { OutputEvent } from '../../../agent/types.js';
 export type LoopStage = 'observing' | 'modeling' | 'choosing' | 'acting' | 'updating';
+export interface StageSignals {
+    toolErrored?: boolean;
+}
 export declare const LOOP_STAGES: readonly LoopStage[];
 export declare const STAGE_LABEL: Record<LoopStage, string>;
 export interface StageTrackerState {

package/dist/cli/commands/interactive/mascot-band.d.ts

@@ -0,0 +1,26 @@
+export declare const MASCOT_BAND_ROWS = 3;
+export declare const MASCOT_BAND_MIN_CONTENT_ROWS = 8;
+export declare class MascotBand {
+    private readonly stream;
+    private readonly getLines;
+    private readonly getAdjacentRows;
+    private started;
+    private rowCount;
+    private lastStartRow;
+    private lastRowCount;
+    private resizeUnsub;
+    private onRowCountChange?;
+    constructor(opts: {
+        getLines: () => readonly string[];
+        getAdjacentRows: () => number;
+        stream?: NodeJS.WriteStream;
+    });
+    setRowCountChangeHandler(handler: (rows: number) => void): void;
+    stop(): void;
+    start(): void;
+    redraw(): void;
+    getRowCount(): number;
+    private clearBand;
+    private repaint;
+    private visibleRows;
+}

package/dist/cli/commands/interactive/mascot-live.d.ts

@@ -0,0 +1,28 @@
+import { type MascotState } from '../../mascot.js';
+import type { LoopStage } from './loop-stage.js';
+export type MascotFrame = readonly string[];
+export declare class LiveMascot {
+    private readonly requestRepaint;
+    private readonly frameMs;
+    private started;
+    private state;
+    private frame;
+    private timer;
+    private stageState;
+    private alertTimer;
+    constructor(opts: {
+        requestRepaint: () => void;
+        frameMs?: number;
+    });
+    stop(): void;
+    start(): void;
+    lines(): MascotFrame;
+    setState(state: MascotState): void;
+    onStage(stage: LoopStage, signals?: {
+        toolErrored?: boolean;
+    }): void;
+    private clearAlertTimer;
+    private flashAlert;
+    private stopTimer;
+    private startTimer;
+}

package/dist/cli/commands/interactive/shared.d.ts

@@ -103,7 +103,7 @@ export interface TurnHandles {
     setPausedState?(paused: boolean): void;
     setPauseInterruptHandler?(handler: (() => void) | null): void;
     onContextProgress?(): void | Promise<void>;
-    onStageChange?(stage: import('./loop-stage.js').LoopStage): void;
+    onStageChange?(stage: import('./loop-stage.js').LoopStage, signals?: import('./loop-stage.js').StageSignals): void;
 }
 export declare const REPL_SPINNER_OPTIONS: {
     readonly stream: NodeJS.WriteStream & {

package/dist/cli/commands/interactive/surface-setup.d.ts

@@ -2,9 +2,11 @@ import type { InputSurface } from '../../input/input-surface.js';
 import type { InteractiveCtx } from './shared.js';
 import type { TranscriptHandle } from './transcript.js';
 import type { LoopStageBar } from './loop-stage.js';
+import type { LiveMascot } from './mascot-live.js';
 import { type TurnState } from './repl-loop-shared.js';
 export interface SurfaceSetupDeps {
     getLoopStageBar: () => LoopStageBar | undefined;
+    getLiveMascot: () => LiveMascot | undefined;
 }
 export interface SurfaceSetupResult {
     installSoftStop: (handler: (() => void) | null) => void;

package/dist/cli/mascot-mini.d.ts

@@ -0,0 +1,6 @@
+import { type MascotState } from './mascot.js';
+export declare const MINI_MASCOT_WIDTH = 13;
+export declare const MINI_MASCOT_HEIGHT = 3;
+export declare function miniMascotFrameCount(state: MascotState): number;
+export declare function renderMiniMascotLines(state?: MascotState, frame?: number): string[];
+export declare const __MINI_MASCOT_FRAMES_FOR_TESTS: Record<MascotState, readonly (readonly string[])[]>;

package/dist/cli/mascot.d.ts

@@ -1,6 +1,12 @@
 export type MascotState = 'idle' | 'working' | 'alert';
 export declare const MASCOT_WIDTH = 27;
 export declare const MASCOT_HEIGHT = 13;
+export type GlyphOverlay = Readonly<Record<string, {
+    char: string;
+    fg: string;
+    bg: string;
+}>>;
+export declare function renderHalfBlockGrid(grid: readonly string[], overlays?: GlyphOverlay): string[];
 export declare function renderMascotLines(state?: MascotState): string[];
 export declare function mascotSuppressed(): boolean;
 export declare const __GOBLIN_GRID_FOR_TESTS: readonly string[];

package/dist/cli/slash/types.d.ts

@@ -78,7 +78,7 @@ export interface SlashContext {
     mcpManager?: import('../../agent/mcp/index.js').McpManager;
     getCompositor?: () => import('../terminal-compositor.js').TerminalCompositor | null;
     setSoftStopHandler?: (handler: (() => void) | null) => void;
-    onStageChange?: (stage: import('../commands/interactive/loop-stage.js').LoopStage) => void;
+    onStageChange?: (stage: import('../commands/interactive/loop-stage.js').LoopStage, signals?: import('../commands/interactive/loop-stage.js').StageSignals) => void;
     onContextProgress?: () => void | Promise<void>;
     transcript?: {
         appendTurn(userInput: string, assistantText: string): Promise<void>;