@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.0

package/dist/types/session/session-memory.d.ts

@@ -0,0 +1,56 @@
+/** Session memory backend lifecycle and transcript resets. */
+import type { Agent, AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { ModelRegistry } from "../config/model-registry.js";
+import type { Settings } from "../config/settings.js";
+import type { HindsightSessionState } from "../hindsight/state.js";
+import type { MemoryBackendStartOptions } from "../memory-backend/types.js";
+import type { MnemopiSessionState } from "../mnemopi/state.js";
+/** Capabilities borrowed from the owning AgentSession. */
+export interface SessionMemoryHost {
+    agent: Agent;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    isDisposed(): boolean;
+    memoryBackendSession(): MemoryBackendStartOptions["session"];
+    getHindsightSessionState(): HindsightSessionState | undefined;
+    setHindsightSessionState(state: HindsightSessionState | undefined): void;
+    getMnemopiSessionState(): MnemopiSessionState | undefined;
+    takeMnemopiSessionState(): MnemopiSessionState | undefined;
+    setBaseSystemPrompt(prompt: string[]): void;
+    refreshBaseSystemPrompt(): Promise<void>;
+    replaceMemoryTools(tools: AgentTool[]): Promise<void>;
+}
+/** Owns memory backend transitions and transcript-scoped memory state. */
+export declare class SessionMemory {
+    #private;
+    constructor(host: SessionMemoryHost, options: {
+        memoryAgentDir?: string;
+        memoryTaskDepth?: number;
+        createMemoryTools?: () => Promise<AgentTool[]>;
+    });
+    /** Current serialized backend transition, used by prompt and disposal drains. */
+    get transition(): Promise<void>;
+    /** Base prompt captured before a per-turn memory promotion. */
+    get promotionSnapshot(): string[] | undefined;
+    /** Clears the per-turn memory promotion after a canonical prompt rebuild. */
+    clearPromotionSnapshot(): void;
+    /** Captures the canonical prompt before the first per-turn memory promotion. */
+    capturePromotionSnapshot(prompt: string[]): void;
+    /** Restores a promotion snapshot while rolling back a failed session switch. */
+    restorePromotionSnapshot(prompt: string[] | undefined): void;
+    /** Rekeys every active memory backend to the current provider session. */
+    rekeyForCurrentSessionId(): void;
+    /** Resets transcript-scoped memory counters and removes a promoted prompt. */
+    resetContextForNewTranscript(): Promise<void>;
+    /** Cancel the local rollout-memory startup owned by this session. */
+    cancelLocalMemoryStartup(): void;
+    /** Start a new local rollout-memory generation and cancel its predecessor. */
+    beginLocalMemoryStartup(): AbortSignal;
+    /** Release the local startup slot if `signal` still owns it. */
+    endLocalMemoryStartup(signal: AbortSignal): void;
+    /**
+     * Apply the selected memory backend to runtime state, tools, and prompt.
+     * Concurrent settings changes run in order and settle before the next turn.
+     */
+    applyMemoryBackend(): Promise<void>;
+}

package/dist/types/session/session-provider-boundary.d.ts

@@ -0,0 +1,62 @@
+/** Provider-facing message, image, secret, and stream normalization for a session. */
+import type { Agent, AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { CompactionPreparation } from "@oh-my-pi/pi-agent-core/compaction";
+import type { ImageContent, Message, Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
+import type { ModelRegistry } from "../config/model-registry.js";
+import type { Settings } from "../config/settings.js";
+import type { LocalProtocolOptions } from "../internal-urls/index.js";
+import { type SecretObfuscator } from "../secrets/obfuscator.js";
+import { type CustomMessage } from "./messages.js";
+import type { BuildSessionContextOptions, SessionContext } from "./session-context.js";
+import type { SessionManager } from "./session-manager.js";
+/** Capabilities borrowed from the owning AgentSession. */
+export interface SessionProviderBoundaryHost {
+    agent: Agent;
+    sessionManager: SessionManager;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    model(): Model | undefined;
+    sessionId(): string;
+    localProtocolOptions(): LocalProtocolOptions;
+    transformContext(messages: AgentMessage[], signal?: AbortSignal): AgentMessage[] | Promise<AgentMessage[]>;
+    convertToLlm(messages: AgentMessage[]): Message[] | Promise<Message[]>;
+    onPayload: SimpleStreamOptions["onPayload"] | undefined;
+    onResponse: SimpleStreamOptions["onResponse"] | undefined;
+    onSseEvent: SimpleStreamOptions["onSseEvent"] | undefined;
+    obfuscator: SecretObfuscator | undefined;
+}
+/** Owns the transformations at the session/provider boundary. */
+export declare class SessionProviderBoundary {
+    #private;
+    constructor(host: SessionProviderBoundaryHost);
+    /** Latest image attachments addressable by tools as `Image #N` or `attachment://N`. */
+    getImageAttachments(): {
+        label: string;
+        uri: string;
+        image: ImageContent;
+    }[];
+    /** Builds the current deobfuscated context for agent display and replay. */
+    buildDisplaySessionContext(): SessionContext;
+    /** Builds the full display-only transcript context. */
+    buildTranscriptSessionContext(options?: Pick<BuildSessionContextOptions, "collapseCompactedHistory" | "keepDanglingToolCalls">): SessionContext;
+    /** Obfuscates optional plaintext before a provider request. */
+    obfuscateText(text: string | undefined): string | undefined;
+    /** Obfuscates summaries and snapcompact plaintext carried into compaction. */
+    obfuscateCompactionPreparation(preparation: CompactionPreparation): CompactionPreparation;
+    /** Deobfuscates provider text before exposing it to the session. */
+    deobfuscateText(text: string): string;
+    /** Deobfuscates a streamed delta and removes an incomplete secret placeholder suffix. */
+    deobfuscateDelta(text: string): string;
+    /** Converts side-request messages through the session's secret boundary. */
+    convertToLlmForSideRequest(messages: AgentMessage[]): Message[];
+    /** Converts session messages using the configured pre-LLM pipeline. */
+    convertMessagesToLlm(messages: AgentMessage[], signal?: AbortSignal): Promise<Message[]>;
+    /** Applies session-level stream hooks and provider defaults to a side request. */
+    prepareSimpleStreamOptions(options: SimpleStreamOptions, provider?: string): SimpleStreamOptions;
+    /** Normalizes image payloads for the active model. */
+    normalizeImagesForModel(images: ImageContent[] | undefined): Promise<ImageContent[] | undefined>;
+    /** Builds a hidden vision-model description for attachments sent to a text-only model. */
+    buildImageDescriptionNotice(normalizedImages: ImageContent[], signal?: AbortSignal): Promise<CustomMessage | undefined>;
+    /** Normalizes every image embedded in an agent message. */
+    normalizeAgentMessageImages<T extends AgentMessage>(message: T): Promise<T>;
+}

package/dist/types/session/session-stats.d.ts

@@ -0,0 +1,48 @@
+import type { Agent, AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { Model, ProviderResponseMetadata } from "@oh-my-pi/pi-ai";
+import type { ModelRegistry } from "../config/model-registry.js";
+import type { ContextUsage } from "../extensibility/extensions/types.js";
+import { type NonMessageTokenSource } from "../modes/utils/context-usage.js";
+import type { ContextUsageBreakdown, SessionStats } from "./agent-session-types.js";
+import type { SessionManager } from "./session-manager.js";
+interface PendingContextSnapshot {
+    promptTokens: number;
+    nonMessageTokens: number;
+    cutoffCount: number;
+}
+/** Capabilities the stats tracker borrows from its owning session. */
+export interface SessionStatsTrackerHost {
+    session: NonMessageTokenSource;
+    agent: Agent;
+    sessionManager: SessionManager;
+    modelRegistry: ModelRegistry;
+    model(): Model | undefined;
+    sessionId(): string;
+}
+/** Computes session totals and tracks the in-flight context estimate. */
+export declare class SessionStatsTracker {
+    #private;
+    constructor(host: SessionStatsTrackerHost);
+    /** Returns aggregate message, token, and cost statistics for the session. */
+    getSessionStats(): SessionStats;
+    /** Returns the current provider-context token breakdown. */
+    getContextBreakdown(options?: {
+        contextWindow?: number;
+        pendingMessages?: AgentMessage[];
+    }): ContextUsageBreakdown | undefined;
+    /** Returns current context tokens, capacity, and percentage. */
+    getContextUsage(options?: {
+        contextWindow?: number;
+    }): ContextUsage | undefined;
+    /** Monotonic revision for in-flight context snapshot changes. */
+    get revision(): number;
+    /** Non-message token count captured for the active provider request. */
+    get pendingNonMessageTokens(): number | undefined;
+    /** Sets or clears the in-flight context snapshot. */
+    setPendingSnapshot(snapshot: PendingContextSnapshot | undefined): void;
+    /** Recomputes an in-flight snapshot after history is compacted or rewritten. */
+    rebaseAfterCompaction(): void;
+    /** Records provider usage headers against the active session account. */
+    ingestProviderUsageHeaders(response: ProviderResponseMetadata, model?: Model): void;
+}
+export {};

package/dist/types/session/session-tools.d.ts

@@ -0,0 +1,143 @@
+import type { Agent, AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { ModelRegistry } from "../config/model-registry.js";
+import type { Settings, SkillsSettings } from "../config/settings.js";
+import type { CustomTool } from "../extensibility/custom-tools/types.js";
+import type { ExtensionRunner } from "../extensibility/extensions/index.js";
+import { type Skill, type SkillWarning } from "../extensibility/skills.js";
+import type { LocalProtocolOptions } from "../internal-urls/index.js";
+import type { MemoryBackendStartOptions } from "../memory-backend/types.js";
+import { type XdevRegistry } from "../tools/xdev.js";
+import { type EditMode } from "../utils/edit-mode.js";
+import type { ClientBridge } from "./client-bridge.js";
+import type { CustomMessage } from "./messages.js";
+import type { SessionManager } from "./session-manager.js";
+/** Capabilities borrowed from the owning AgentSession. */
+export interface SessionToolsHost {
+    agent: Agent;
+    sessionManager: SessionManager;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    extensionRunner(): ExtensionRunner | undefined;
+    clientBridge(): ClientBridge | undefined;
+    agentKind(): "main" | "sub";
+    isDisposed(): boolean;
+    isStreaming(): boolean;
+    queuedMessageCount(): number;
+    planModeEnabled(): boolean;
+    model(): Model | undefined;
+    memoryBackendSession(): MemoryBackendStartOptions["session"];
+    clearInheritedProviderPromptCacheKey(): void;
+    clearMemoryPromotionSnapshot(): void;
+    captureMemoryPromotionSnapshot(prompt: string[]): void;
+    emitNotice(level: "info" | "warning" | "error", message: string, source?: string): void;
+    notifyCommandMetadataChanged(): void;
+    localProtocolOptions(): LocalProtocolOptions;
+}
+interface SessionToolsOptions {
+    autoApprove?: boolean;
+    toolRegistry?: Map<string, AgentTool>;
+    createVibeTools?: () => AgentTool[];
+    builtInToolNames?: Iterable<string>;
+    presentationPinnedToolNames?: ReadonlySet<string>;
+    ensureWriteRegistered?: () => Promise<boolean>;
+    rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{
+        systemPrompt: string[];
+    }>;
+    getLocalCalendarDate?: () => string;
+    getMcpServerInstructions?: () => Map<string, string> | undefined;
+    xdevRegistry?: XdevRegistry;
+    initialMountedXdevToolNames?: string[];
+    setActiveToolNames?: (names: Iterable<string>) => void;
+    baseSystemPrompt: string[];
+    skills?: Skill[];
+    skillWarnings?: SkillWarning[];
+    skillsSettings?: SkillsSettings;
+    skillsReloadable?: boolean;
+}
+/** Owns tool registration, presentation, prompt rebuilding, skills, and permissions. */
+export declare class SessionTools {
+    #private;
+    constructor(host: SessionToolsHost, options: SessionToolsOptions);
+    /** Mutable registry shared with controller hosts that inspect available tools. */
+    get registry(): Map<string, AgentTool>;
+    /** Current stable base system prompt. */
+    get baseSystemPrompt(): string[];
+    /** Replaces the controller-owned base prompt without applying it to the agent. */
+    setBaseSystemPrompt(prompt: string[]): void;
+    /** Skills currently rendered into the system prompt. */
+    get skills(): Skill[];
+    /** Diagnostics produced while loading the current skills. */
+    get skillWarnings(): SkillWarning[];
+    /** Settings snapshot used for the current skill discovery. */
+    get skillsSettings(): SkillsSettings | undefined;
+    /** Drops cached per-session ACP `allow_always`/`reject_always` decisions. */
+    clearAcpPermissionDecisions(): void;
+    /** Re-wraps active and mounted tools after the ACP client changes. */
+    refreshAcpPermissionGates(): void;
+    /** Names of tools currently exposed at the top level. */
+    getActiveToolNames(): string[];
+    /** Enabled top-level and discoverable tool names. */
+    getEnabledToolNames(): string[];
+    /** Names of dynamic tools mounted under `xd://`. */
+    getMountedXdevToolNames(): string[];
+    /** Whether the edit tool is registered. */
+    get hasEditTool(): boolean;
+    /** Looks up a registered tool by name. */
+    getToolByName(name: string): AgentTool | undefined;
+    /** Whether a registry entry came from a built-in factory. */
+    hasBuiltInTool(name: string): boolean;
+    /** Names of every registered tool. */
+    getAllToolNames(): string[];
+    /** Installs and activates the ephemeral vibe tool set. */
+    activateVibeTools(baseToolNames: string[]): Promise<void>;
+    /** Uninstalls vibe tools and activates the replacement set. */
+    deactivateVibeTools(nextToolNames: string[]): Promise<void>;
+    /** Removes vibe tools without restoring a source-session snapshot. */
+    removeVibeToolsPreservingActive(): Promise<void>;
+    /** Resolves the edit mode for the active model and settings. */
+    resolveActiveEditMode(): EditMode;
+    /** Rebuilds model-dependent tool prompts after a model change. */
+    syncAfterModelChange(previousEditMode: EditMode): Promise<void>;
+    /** Enabled MCP tools in their current presentation partition. */
+    getSelectedMCPToolNames(): string[];
+    /** Applies an enabled tool set and reconciles its `xd://` partition. */
+    applyActiveToolsByName(toolNames: string[]): Promise<void>;
+    /** Consumes the hidden notice for unannounced `xd://` mount changes. */
+    takePendingXdevMountNotice(): CustomMessage | undefined;
+    /** Rediscovers reloadable skills and refreshes prompt metadata. */
+    refreshSkills(): Promise<void>;
+    /** Selects enabled tools, ignoring names absent from the registry. */
+    setActiveToolsByName(toolNames: string[]): Promise<void>;
+    /**
+     * Restore an enabled tool set with its exact top-level versus `xd://` partition.
+     *
+     * Both inputs are required because {@link setActiveToolsByName} only receives the
+     * enabled name list and classifies mounts from the current `#mountedXdevToolNames`.
+     * Rollback/restore callers must pass the snapshotted mounted subset so names that
+     * were top-level stay pinned (`#runtimeSelectedToolNames`) and names that were under
+     * `xd://` remain mount-eligible, even when the live mount set has drifted.
+     *
+     * Names outside `mountedToolNames` are pinned top-level for this application;
+     * names in the mounted subset remain eligible for xdev mounting. Delegates the
+     * actual apply through {@link applyActiveToolsByName} and restores the prior runtime
+     * selection if that apply throws.
+     */
+    setActiveToolPresentation(toolNames: string[], mountedToolNames: string[]): Promise<void>;
+    /** Replaces memory-backend tools while preserving unrelated selections. */
+    replaceMemoryTools(tools: AgentTool[]): Promise<void>;
+    /** Rebuilds the stable base prompt for the current tools and model. */
+    refreshBaseSystemPrompt(): Promise<void>;
+    /** Applies one-turn memory prompt injection before an agent run. */
+    buildSystemPromptForAgentStart(promptText: string): Promise<string[]>;
+    /**
+     * Replace MCP tools in the registry and enable them immediately. Every
+     * connected MCP tool becomes available (mounted under `xd://` when that
+     * transport is active, else top-level). Lets `/mcp add/remove/reauth` take
+     * effect without restarting the session.
+     */
+    refreshMCPTools(mcpTools: CustomTool[]): Promise<void>;
+    /** Replaces RPC host-owned tools and refreshes the active set before the next model call. */
+    refreshRpcHostTools(rpcTools: AgentTool[]): Promise<void>;
+}
+export {};

package/dist/types/session/session-workspace.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Filesystem workspace of a session: one current/default directory plus a
+ * non-empty ordered list of workspace directories.
+ *
+ * `cwd` remains the default directory for relative-path resolution and
+ * backward compatibility. `directories` always contains `cwd` first, followed
+ * by any additional directories in their supplied order (deduplicated).
+ * Directory order is stable but carries no semantic hierarchy.
+ *
+ * Workspace directories come from the platform (ACP/editor), CLI, or config —
+ * never from filesystem walk-up discovery.
+ */
+export interface SessionWorkspace {
+    /** Current/default directory for compatibility and relative path resolution. */
+    cwd: string;
+    /** Non-empty ordered list of absolute normalized directories; `cwd` is always first. */
+    directories: string[];
+}
+/** Expand a leading `~`/`~/` and resolve to an absolute path (relative input resolves against `base`). */
+export declare function normalizeWorkspaceDirectory(directory: string, base?: string): string;
+/**
+ * Build a normalized {@link SessionWorkspace} from a cwd and optional
+ * additional directories. Additional entries are normalized (relative entries
+ * resolve against the normalized cwd), deduplicated, and appended after `cwd`
+ * preserving their supplied order.
+ */
+export declare function normalizeSessionWorkspace(args: {
+    cwd: string;
+    directories?: string[];
+}): SessionWorkspace;
+/** The workspace directories beyond `cwd`, in order (ACP `additionalDirectories` shape). */
+export declare function additionalWorkspaceDirectories(workspace: SessionWorkspace): string[];

package/dist/types/session/stream-guards.d.ts

@@ -0,0 +1,44 @@
+import type { Agent, AgentEvent, AgentMessage, AgentTurnEndContext } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage, AssistantMessageEvent, Model } from "@oh-my-pi/pi-ai";
+import type { Settings } from "../config/settings.js";
+import { type LocalProtocolOptions } from "../internal-urls/index.js";
+import type { SecretObfuscator } from "../secrets/obfuscator.js";
+import type { SessionManager } from "./session-manager.js";
+/** Capabilities borrowed by the session's streaming and loop guards. */
+export interface StreamGuardsHost {
+    agent: Agent;
+    settings: Settings;
+    sessionManager: SessionManager;
+    obfuscator: SecretObfuscator | undefined;
+    model(): Model | undefined;
+    isDisposed(): boolean;
+    promptGeneration(): number;
+    localProtocolOptions(): LocalProtocolOptions;
+    emitNotice(level: "info" | "warning" | "error", message: string, source?: string): void;
+    schedulePostPromptTask(task: (signal: AbortSignal) => Promise<void>): void;
+    discardAssistantTurn(message: AssistantMessage): void;
+}
+/** Guards streamed edit calls against generated files and invalid patch previews. */
+export declare class StreamingEditGuard {
+    #private;
+    constructor(host: StreamGuardsHost);
+    /** Whether the current turn was aborted by streaming edit validation. */
+    get abortTriggered(): boolean;
+    /** Clears all turn-scoped streaming edit state. */
+    reset(): void;
+    /** Pre-caches and validates a streamed edit as its arguments arrive. */
+    preCache(event: AgentEvent): void;
+    /** Invalidates cached source text after an edit tool result lands. */
+    invalidate(filePath: string): void;
+    /** Aborts a streamed edit whose completed patch preview cannot apply. */
+    maybeAbort(event: AgentEvent): void;
+}
+/** Detects cross-turn tool loops and Gemini reasoning-header runaways. */
+export declare class LoopGuards {
+    #private;
+    constructor(host: StreamGuardsHost);
+    /** Records a completed turn and injects a redirect when calls repeat. */
+    recordTurn(messages: AgentMessage[], context: AgentTurnEndContext | undefined): void;
+    /** Feeds a streamed assistant event to the Gemini header-runaway detector. */
+    onAssistantEvent(message: AssistantMessage, event: AssistantMessageEvent): void;
+}

package/dist/types/session/todo-tracker.d.ts

@@ -0,0 +1,56 @@
+import type { Agent, AgentMessage, AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage, Model, ToolChoice } from "@oh-my-pi/pi-ai";
+import type { Settings } from "../config/settings.js";
+import { type TodoPhase } from "../tools/todo.js";
+import type { AgentSessionEvent } from "./agent-session-events.js";
+import type { SessionManager } from "./session-manager.js";
+/** Capabilities the todo tracker borrows from its owning session. */
+export interface TodoTrackerHost {
+    agent: Agent;
+    sessionManager: SessionManager;
+    settings: Settings;
+    model(): Model | undefined;
+    agentKind(): "main" | "sub";
+    emitSessionEvent(event: AgentSessionEvent): Promise<void>;
+    scheduleAgentContinue(options: {
+        generation?: number;
+    }): void;
+    promptGeneration(): number;
+    hasPendingAsyncWake(): boolean;
+    getActiveToolNames(): string[];
+    toolRegistry(): Map<string, AgentTool>;
+    planModeEnabled(): boolean;
+    consumeLastServedToolChoiceLabel(): string | undefined;
+}
+/** Owns canonical todo state, eager preludes, and completion reminders. */
+export declare class TodoTracker {
+    #private;
+    constructor(host: TodoTrackerHost);
+    /** Returns a defensive clone of the current todo phases. */
+    get phases(): TodoPhase[];
+    /** Replaces todo phases with a defensive clone. */
+    setPhases(phases: TodoPhase[]): void;
+    /** Rehydrates todo phases from the current transcript branch. */
+    syncFromBranch(): void;
+    /** Returns a defensive clone suitable for snapshots and branch state. */
+    clonePhases(phases: TodoPhase[]): TodoPhase[];
+    /** Resets per-prompt reminder and mutation budgets. */
+    resetCycle(): void;
+    /** Records a completed tool result before asynchronous event processing begins. */
+    onToolResult(toolName: string, isError: boolean): void;
+    /** Detects whether a successful todo result came from an init operation. */
+    onTodoResultDetails(details: Record<string, unknown>, toolCallId: string | undefined): boolean;
+    /** Builds the first-turn eager todo prelude and optional forced tool choice. */
+    createEagerTodoPrelude(promptText: string | undefined): {
+        message: AgentMessage;
+        toolChoice?: ToolChoice;
+    } | undefined;
+    /** Builds the first-turn eager task-delegation prelude. */
+    createEagerTaskPrelude(promptText: string | undefined): AgentMessage | undefined;
+    /** Builds reminder-only eager preludes after compaction. */
+    buildPostCompactionEagerNudges(): AgentMessage[];
+    /** Checks a terminal assistant turn and schedules continuation for incomplete todos. */
+    checkCompletion(message: AssistantMessage): Promise<boolean>;
+    /** Takes the next hidden mid-run reconciliation nudge, if its budget and guards allow. */
+    takeMidRunNudge(): AgentMessage | null;
+}

package/dist/types/session/ttsr-coordinator.d.ts

@@ -0,0 +1,51 @@
+import { type AfterToolCallContext, type AfterToolCallResult, type Agent, type AgentEvent } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import type { Settings } from "../config/settings.js";
+import type { TtsrManager } from "../export/ttsr.js";
+import type { AgentSessionEvent } from "./agent-session-events.js";
+import type { SessionManager } from "./session-manager.js";
+interface TtsrContinueOptions {
+    delayMs?: number;
+    generation?: number;
+    shouldContinue?: () => boolean;
+    onSkip?: () => void;
+    onError?: () => void;
+}
+/** Capabilities the TTSR coordinator borrows from its owning session. */
+export interface TtsrCoordinatorHost {
+    agent: Agent;
+    sessionManager: SessionManager;
+    settings: Settings;
+    emitSessionEvent(event: AgentSessionEvent): Promise<void>;
+    schedulePostPromptTask(task: (signal: AbortSignal) => Promise<void>, options?: {
+        delayMs?: number;
+    }): void;
+    scheduleAgentContinue(options: TtsrContinueOptions): void;
+    promptGeneration(): number;
+}
+/** Coordinates TTSR stream matching, interruption, injection, and resume gates. */
+export declare class TtsrCoordinator {
+    #private;
+    constructor(host: TtsrCoordinatorHost, manager: TtsrManager | undefined);
+    /** Configured TTSR manager, when stream rules are enabled. */
+    get manager(): TtsrManager | undefined;
+    /** Whether a TTSR-triggered stream abort is awaiting its continuation. */
+    get abortPending(): boolean;
+    /** Current resume gate awaited by post-prompt recovery. */
+    get resumeGate(): Promise<void> | undefined;
+    /** Resets stream buffers at turn start. */
+    onTurnStart(): void;
+    /** Advances repeat-after-gap tracking at turn end. */
+    onTurnEnd(): void;
+    /** Checks one streamed message update and reports whether TTSR consumed it by aborting. */
+    checkMessageUpdate(event: AgentEvent): Promise<boolean>;
+    /** Settles the previous resume gate and queues any deferred injection. */
+    onAssistantMessageEnd(message: AssistantMessage): void;
+    /** Marks names persisted with a delivered TTSR injection as injected. */
+    markInjectedFromDetails(details: unknown): void;
+    /** Folds per-tool reminders into the matched tool's result. */
+    afterToolCall(ctx: AfterToolCallContext): AfterToolCallResult | undefined;
+    /** Resolves and clears the current resume gate. */
+    resolveResume(): void;
+}
+export {};