agent-relay 1.1.0 → 1.2.3

package/dist/utils/logger.js

@@ -13,7 +13,7 @@ import path from 'node:path';
 const LOG_FILE = process.env.AGENT_RELAY_LOG_FILE;
 const LOG_LEVEL = (process.env.AGENT_RELAY_LOG_LEVEL ?? 'INFO').toUpperCase();
 const LOG_JSON = process.env.AGENT_RELAY_LOG_JSON === '1';
-const DEBUG = process.env.DEBUG === '1' || LOG_LEVEL === 'DEBUG';
+const _DEBUG = process.env.DEBUG === '1' || LOG_LEVEL === 'DEBUG';
 const LEVEL_PRIORITY = {
     DEBUG: 0,
     INFO: 1,

package/dist/utils/project-namespace.d.ts

@@ -43,4 +43,28 @@ export declare function listProjects(): Array<{
     projectRoot: string;
     dataDir: string;
 }>;
+/**
+ * Detect the actual workspace directory for cloud deployments.
+ *
+ * In cloud workspaces, repos are cloned to /workspace/{repo-name}.
+ * This function finds the correct working directory:
+ *
+ * Priority:
+ * 1. WORKSPACE_CWD env var (explicit override)
+ * 2. If baseDir itself is a git repo, use it
+ * 3. Scan baseDir for cloned repos - use the first one found (alphabetically)
+ * 4. Fall back to baseDir
+ *
+ * @param baseDir - The base workspace directory (e.g., /workspace)
+ * @returns The actual workspace path to use
+ */
+export declare function detectWorkspacePath(baseDir: string): string;
+/**
+ * List all git repos in a workspace directory.
+ * Useful for allowing users to select which repo to work in.
+ *
+ * @param baseDir - The base workspace directory
+ * @returns Array of repo paths
+ */
+export declare function listWorkspaceRepos(baseDir: string): string[];
 //# sourceMappingURL=project-namespace.d.ts.map

package/dist/utils/project-namespace.js

@@ -129,4 +129,88 @@ export function listProjects() {
     }
     return projects;
 }
+/**
+ * Detect the actual workspace directory for cloud deployments.
+ *
+ * In cloud workspaces, repos are cloned to /workspace/{repo-name}.
+ * This function finds the correct working directory:
+ *
+ * Priority:
+ * 1. WORKSPACE_CWD env var (explicit override)
+ * 2. If baseDir itself is a git repo, use it
+ * 3. Scan baseDir for cloned repos - use the first one found (alphabetically)
+ * 4. Fall back to baseDir
+ *
+ * @param baseDir - The base workspace directory (e.g., /workspace)
+ * @returns The actual workspace path to use
+ */
+export function detectWorkspacePath(baseDir) {
+    // 1. Explicit override
+    if (process.env.WORKSPACE_CWD) {
+        return process.env.WORKSPACE_CWD;
+    }
+    // 2. Check if baseDir itself is a git repo
+    if (fs.existsSync(path.join(baseDir, '.git'))) {
+        return baseDir;
+    }
+    // 3. Scan for cloned repos (directories with .git)
+    try {
+        const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+        const repos = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const repoPath = path.join(baseDir, entry.name);
+                const gitPath = path.join(repoPath, '.git');
+                if (fs.existsSync(gitPath)) {
+                    repos.push(repoPath);
+                }
+            }
+        }
+        // Sort alphabetically for consistent behavior
+        repos.sort();
+        // Use the first repo found
+        if (repos.length > 0) {
+            if (repos.length > 1) {
+                console.log(`[workspace] Multiple repos found, using first: ${repos[0]} (others: ${repos.slice(1).join(', ')})`);
+            }
+            else {
+                console.log(`[workspace] Detected repo: ${repos[0]}`);
+            }
+            return repos[0];
+        }
+    }
+    catch (err) {
+        // Failed to scan, fall back
+        console.warn(`[workspace] Failed to scan ${baseDir}:`, err);
+    }
+    // 4. Fall back to baseDir
+    return baseDir;
+}
+/**
+ * List all git repos in a workspace directory.
+ * Useful for allowing users to select which repo to work in.
+ *
+ * @param baseDir - The base workspace directory
+ * @returns Array of repo paths
+ */
+export function listWorkspaceRepos(baseDir) {
+    const repos = [];
+    try {
+        const entries = fs.readdirSync(baseDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const repoPath = path.join(baseDir, entry.name);
+                const gitPath = path.join(repoPath, '.git');
+                if (fs.existsSync(gitPath)) {
+                    repos.push(repoPath);
+                }
+            }
+        }
+        repos.sort();
+    }
+    catch {
+        // Failed to scan
+    }
+    return repos;
+}
 //# sourceMappingURL=project-namespace.js.map

package/dist/wrapper/parser.d.ts

@@ -36,6 +36,11 @@ export interface ParserOptions {
     /** Thinking prefix pattern (default: '->thinking:') */
     thinkingPrefix?: string;
 }
+/**
+ * Check if a target name is a placeholder commonly used in documentation/examples.
+ * These should not be treated as real message targets.
+ */
+export declare function isPlaceholderTarget(target: string): boolean;
 export declare class OutputParser {
     private options;
     private inCodeFence;
@@ -106,6 +111,11 @@ export declare class OutputParser {
      * Returns the command (if valid) and any remaining content after [[/RELAY]].
      */
     private finishBlock;
+    /**
+     * Check if the current fenced inline command should be filtered out.
+     * Returns true if the command looks like instructional/example text.
+     */
+    private shouldFilterFencedInline;
     /**
      * Parse while inside a fenced inline block (->relay:Target <<< ... >>>).
      * Accumulates lines until >>> is seen on its own line.

package/dist/wrapper/parser.js

@@ -57,8 +57,8 @@ function isSpawnOrReleaseCommand(line) {
     return SPAWN_COMMAND_PATTERN.test(line) || RELEASE_COMMAND_PATTERN.test(line);
 }
 // Claude extended thinking block markers - skip content inside these
-const THINKING_START = /<antml:thinking>/;
-const THINKING_END = /<\/thinking>/;
+const THINKING_START = new RegExp(String.raw `<` + `thinking>`);
+const THINKING_END = new RegExp(String.raw `</` + `thinking>`);
 /**
  * Patterns that indicate instructional/example text that should NOT be parsed as actual commands.
  * These are common in system prompts, documentation, and injected instructions.
@@ -75,6 +75,21 @@ const INSTRUCTIONAL_MARKERS = [
     /MULTI-LINE:/i, // Multi-line format instruction
     /RECEIVE:/i, // Receive instruction marker
 ];
+/**
+ * Placeholder target names commonly used in documentation and examples.
+ * Messages to these targets should be filtered out as instructional text.
+ */
+const PLACEHOLDER_TARGETS = new Set([
+    'agentname',
+    'target',
+    'recipient',
+    'yourtarget',
+    'targetagent',
+    'someagent',
+    'otheragent',
+    'worker', // Too generic, often used in examples
+    // NOTE: Don't add 'agent', 'name', 'lead', 'developer', etc. - these can be valid agent names!
+]);
 /**
  * Check if a parsed relay command body looks like instructional/example text.
  * These patterns commonly appear in system prompts and documentation.
@@ -82,6 +97,13 @@ const INSTRUCTIONAL_MARKERS = [
 function isInstructionalText(body) {
     return INSTRUCTIONAL_MARKERS.some(pattern => pattern.test(body));
 }
+/**
+ * Check if a target name is a placeholder commonly used in documentation/examples.
+ * These should not be treated as real message targets.
+ */
+export function isPlaceholderTarget(target) {
+    return PLACEHOLDER_TARGETS.has(target.toLowerCase());
+}
 /**
  * Escape special regex characters in a string
  */
@@ -127,7 +149,8 @@ function buildEscapePattern(prefix, thinkingPrefix) {
 const ANSI_PATTERN = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\].*?(?:\x07|\x1b\\)|\r/g;
 // Pattern for orphaned CSI sequences that lost their escape byte
 // These look like [?25h, [?2026l, [0m, etc. at the start of content
-const ORPHANED_CSI_PATTERN = /^\s*(\[\??\d*[A-Za-z])+\s*/g;
+// Requires at least one digit or question mark to avoid stripping legitimate text like [Agent
+const ORPHANED_CSI_PATTERN = /^\s*(\[(?:\?|\d)\d*[A-Za-z])+\s*/g;
 /**
  * Parse a target string that may contain cross-project syntax.
  * Supports: "agent" (local) or "project:agent" (cross-project)
@@ -467,9 +490,21 @@ export class OutputParser {
                 strippedCount++;
                 continue;
             }
+            // Skip spawn/release commands BEFORE checking fenced format
+            // This prevents ->relay:spawn Worker cli <<< from being parsed as a message to "spawn"
+            const strippedForSpawnCheck = stripAnsi(line);
+            if (isSpawnOrReleaseCommand(strippedForSpawnCheck)) {
+                outputLines.push(line);
+                continue;
+            }
             // Check for fenced inline start: ->relay:Target <<<
             const fencedStart = isFencedInlineStart(line);
             if (fencedStart && this.options.enableInline) {
+                // Skip placeholder target names early (common in documentation/examples)
+                if (isPlaceholderTarget(fencedStart.target)) {
+                    outputLines.push(line);
+                    continue;
+                }
                 // Enter fenced inline mode
                 this.inFencedInline = true;
                 this.fencedInlineTarget = fencedStart.target;
@@ -640,6 +675,10 @@ export class OutputParser {
                     return { command: null, output: line };
                 }
                 const { to, project } = parseTarget(target);
+                // Skip placeholder target names (common in documentation/examples)
+                if (isPlaceholderTarget(to)) {
+                    return { command: null, output: line };
+                }
                 return {
                     command: {
                         to,
@@ -661,6 +700,10 @@ export class OutputParser {
                     return { command: null, output: line };
                 }
                 const { to, project } = parseTarget(target);
+                // Skip placeholder target names (common in documentation/examples)
+                if (isPlaceholderTarget(to)) {
+                    return { command: null, output: line };
+                }
                 return {
                     command: {
                         to,
@@ -745,6 +788,21 @@ export class OutputParser {
             }
         }
     }
+    /**
+     * Check if the current fenced inline command should be filtered out.
+     * Returns true if the command looks like instructional/example text.
+     */
+    shouldFilterFencedInline(target, body) {
+        // Check for placeholder target names
+        if (isPlaceholderTarget(target)) {
+            return true;
+        }
+        // Check for instructional body content
+        if (isInstructionalText(body)) {
+            return true;
+        }
+        return false;
+    }
     /**
      * Parse while inside a fenced inline block (->relay:Target <<< ... >>>).
      * Accumulates lines until >>> is seen on its own line.
@@ -769,16 +827,19 @@ export class OutputParser {
             // Only if we have actual content to send
             if (consecutiveBlankLines >= 2 && this.fencedInlineBuffer.trim().length > 0) {
                 const body = unescapeFenceMarkers(stripAnsi(this.fencedInlineBuffer.trim()));
-                const command = {
-                    to: this.fencedInlineTarget,
-                    kind: this.fencedInlineKind,
-                    body,
-                    thread: this.fencedInlineThread,
-                    threadProject: this.fencedInlineThreadProject,
-                    project: this.fencedInlineProject,
-                    raw: this.fencedInlineRaw.join('\n'),
-                };
-                commands.push(command);
+                // Skip instructional/example text (common in system prompts and documentation)
+                if (!this.shouldFilterFencedInline(this.fencedInlineTarget, body)) {
+                    const command = {
+                        to: this.fencedInlineTarget,
+                        kind: this.fencedInlineKind,
+                        body,
+                        thread: this.fencedInlineThread,
+                        threadProject: this.fencedInlineThreadProject,
+                        project: this.fencedInlineProject,
+                        raw: this.fencedInlineRaw.join('\n'),
+                    };
+                    commands.push(command);
+                }
                 // Reset fenced inline state
                 this.inFencedInline = false;
                 this.fencedInlineBuffer = '';
@@ -802,16 +863,19 @@ export class OutputParser {
                 // Auto-close and send the incomplete fenced block (if it has content)
                 if (this.fencedInlineBuffer.trim().length > 0) {
                     const body = unescapeFenceMarkers(stripAnsi(this.fencedInlineBuffer.trim()));
-                    const command = {
-                        to: this.fencedInlineTarget,
-                        kind: this.fencedInlineKind,
-                        body,
-                        thread: this.fencedInlineThread,
-                        threadProject: this.fencedInlineThreadProject,
-                        project: this.fencedInlineProject,
-                        raw: this.fencedInlineRaw.join('\n'),
-                    };
-                    commands.push(command);
+                    // Skip instructional/example text (common in system prompts and documentation)
+                    if (!this.shouldFilterFencedInline(this.fencedInlineTarget, body)) {
+                        const command = {
+                            to: this.fencedInlineTarget,
+                            kind: this.fencedInlineKind,
+                            body,
+                            thread: this.fencedInlineThread,
+                            threadProject: this.fencedInlineThreadProject,
+                            project: this.fencedInlineProject,
+                            raw: this.fencedInlineRaw.join('\n'),
+                        };
+                        commands.push(command);
+                    }
                 }
                 // Reset fenced inline state
                 this.inFencedInline = false;
@@ -848,16 +912,19 @@ export class OutputParser {
                 // Complete the fenced inline command - unescape any \<<< and \>>> in content
                 const body = unescapeFenceMarkers(stripAnsi(this.fencedInlineBuffer.trim()));
                 this.fencedInlineRaw.push(line);
-                const command = {
-                    to: this.fencedInlineTarget,
-                    kind: this.fencedInlineKind,
-                    body,
-                    thread: this.fencedInlineThread,
-                    threadProject: this.fencedInlineThreadProject,
-                    project: this.fencedInlineProject,
-                    raw: this.fencedInlineRaw.join('\n'),
-                };
-                commands.push(command);
+                // Skip instructional/example text (common in system prompts and documentation)
+                if (!this.shouldFilterFencedInline(this.fencedInlineTarget, body)) {
+                    const command = {
+                        to: this.fencedInlineTarget,
+                        kind: this.fencedInlineKind,
+                        body,
+                        thread: this.fencedInlineThread,
+                        threadProject: this.fencedInlineThreadProject,
+                        project: this.fencedInlineProject,
+                        raw: this.fencedInlineRaw.join('\n'),
+                    };
+                    commands.push(command);
+                }
                 // Reset fenced inline state
                 this.inFencedInline = false;
                 this.fencedInlineBuffer = '';

package/dist/wrapper/pty-wrapper.d.ts

@@ -6,7 +6,10 @@
  * Used for spawned workers that don't need direct user interaction.
  */
 import { EventEmitter } from 'node:events';
+import type { ParsedSummary, SessionEndMarker } from './parser.js';
 import type { SpeakOnTrigger } from '../protocol/types.js';
+import { type LifecycleHooks } from '../hooks/index.js';
+import { type InjectionMetrics, type CliType } from './shared.js';
 export interface PtyWrapperConfig {
     name: string;
     command: string;
@@ -16,10 +19,14 @@ export interface PtyWrapperConfig {
     env?: Record<string, string>;
     /** Relay prefix pattern (default: '->relay:') */
     relayPrefix?: string;
+    /** CLI type for special handling (auto-detected from command if not set) */
+    cliType?: CliType;
     /** Directory to write log files (optional) */
     logsDir?: string;
     /** Dashboard port for spawn/release API calls (enables nested spawning from spawned agents) */
     dashboardPort?: number;
+    /** Allow this agent to spawn other agents (default: true for Lead, false for spawned workers) */
+    allowSpawn?: boolean;
     /** Callback for spawn commands (fallback if dashboardPort not set) */
     onSpawn?: (name: string, cli: string, task: string) => Promise<void>;
     /** Callback for release commands (fallback if dashboardPort not set) */
@@ -32,11 +39,47 @@ export interface PtyWrapperConfig {
     shadowSpeakOn?: SpeakOnTrigger[];
     /** Stream output to daemon for dashboard log viewing (default: true) */
     streamLogs?: boolean;
+    /** Task/role description for trajectory tracking */
+    task?: string;
+    /** Custom lifecycle hooks */
+    hooks?: LifecycleHooks;
+    /** Enable trajectory tracking hooks (default: true if task provided) */
+    trajectoryTracking?: boolean;
+    /** Resume from a previous agent ID (for crash recovery) */
+    resumeAgentId?: string;
+    /**
+     * Summary reminder configuration. Set to false to disable.
+     * Default: { intervalMinutes: 15, minOutputs: 50 }
+     */
+    summaryReminder?: {
+        /** Minutes of activity before reminding (default: 15) */
+        intervalMinutes?: number;
+        /** Minimum significant outputs before reminding (default: 50) */
+        minOutputs?: number;
+    } | false;
+}
+export interface InjectionFailedEvent {
+    messageId: string;
+    from: string;
+    attempts: number;
+}
+export interface SummaryEvent {
+    agentName: string;
+    summary: ParsedSummary;
+}
+export interface SessionEndEvent {
+    agentName: string;
+    marker: SessionEndMarker;
 }
 export interface PtyWrapperEvents {
     output: (data: string) => void;
     exit: (code: number) => void;
     error: (error: Error) => void;
+    'injection-failed': (event: InjectionFailedEvent) => void;
+    /** Emitted when agent outputs a [[SUMMARY]] block. Cloud services can persist this. */
+    'summary': (event: SummaryEvent) => void;
+    /** Emitted when agent outputs a [[SESSION_END]] block. Cloud services can handle session closure. */
+    'session-end': (event: SessionEndEvent) => void;
 }
 export declare class PtyWrapper extends EventEmitter {
     private config;
@@ -46,27 +89,99 @@ export declare class PtyWrapper extends EventEmitter {
     private outputBuffer;
     private rawBuffer;
     private relayPrefix;
+    private cliType;
     private sentMessageHashes;
+    private receivedMessageIds;
     private processedSpawnCommands;
     private processedReleaseCommands;
+    private pendingFencedSpawn;
     private messageQueue;
     private isInjecting;
     private readyForMessages;
+    private lastOutputTime;
+    private injectionMetrics;
     private logFilePath?;
     private logStream?;
-    private hasAcceptedPrompt;
+    private acceptedPrompts;
+    private hookRegistry;
+    private sessionStartTime;
+    private continuity?;
+    private agentId?;
+    private processedContinuityCommands;
+    private lastSummaryRawContent;
+    private sessionEndProcessed;
+    private inThinkingBlock;
+    private lastSummaryTime;
+    private outputsSinceSummary;
+    private detectedTask?;
+    private sessionEndData?;
+    private instructionsInjected;
+    private continuityInjected;
+    private recentLogChunks;
+    private static readonly LOG_DEDUP_WINDOW_MS;
+    private static readonly LOG_DEDUP_MAX_SIZE;
+    private lastParsedLength;
+    private lastContinuityParsedLength;
     constructor(config: PtyWrapperConfig);
     /**
      * Start the agent process
      */
     start(): Promise<void>;
+    /**
+     * Initialize agent ID for continuity/resume functionality
+     */
+    private initializeAgentId;
+    /**
+     * Get the current agent ID
+     */
+    getAgentId(): string | undefined;
+    /**
+     * Inject continuity context from previous session.
+     * Called after agent ID initialization to restore state from ledger.
+     */
+    private injectContinuityContext;
+    /**
+     * Parse ->continuity: commands from output and handle them.
+     *
+     * Supported commands:
+     *   ->continuity:save <<<...>>>  - Save session state to ledger
+     *   ->continuity:load            - Request context injection
+     *   ->continuity:search "query"  - Search past handoffs
+     *   ->continuity:uncertain "..."  - Mark item as uncertain
+     *   ->continuity:handoff <<<...>>> - Create explicit handoff
+     */
+    private parseContinuityCommands;
     /**
      * Handle output from the process
      */
     private handleOutput;
     /**
-     * Auto-accept Claude's first-run prompts for --dangerously-skip-permissions
-     * Detects the acceptance prompt and sends "2" to select "Yes, I accept"
+     * Filter Claude's extended thinking blocks from output.
+     * Thinking blocks are wrapped in <thinking>...</thinking> tags and should
+     * not be streamed to the dashboard or stored in output buffers.
+     *
+     * This method tracks state across calls to handle multi-line thinking blocks.
+     */
+    private filterThinkingBlocks;
+    /**
+     * Check if a log chunk is a duplicate (recently streamed).
+     * Prevents terminal redraws from causing duplicate log entries in the dashboard.
+     *
+     * Uses content normalization and time-based deduplication:
+     * - Strips whitespace and normalizes content for comparison
+     * - Considers chunks with same normalized content within LOG_DEDUP_WINDOW_MS as duplicates
+     * - Cleans up old entries to prevent memory growth
+     */
+    private isDuplicateLogChunk;
+    /**
+     * Auto-accept Claude's first-run prompts
+     * Handles multiple prompts in sequence:
+     * 1. --dangerously-skip-permissions acceptance ("Yes, I accept")
+     * 2. Trust directory prompt ("Yes, I trust this folder")
+     * 3. "Ready to code here?" permission prompt ("Yes, continue")
+     *
+     * Uses a Set to track which prompts have been accepted, allowing
+     * multiple different prompts to be handled in sequence.
      */
     private handleAutoAcceptPrompts;
     /**
@@ -84,6 +199,9 @@ export declare class PtyWrapper extends EventEmitter {
      * Parse relay commands from output.
      * Handles both single-line and multi-line (fenced) formats.
      * Deduplication via sentMessageHashes.
+     *
+     * Optimization: Only parses new content since last parse to avoid O(n²) behavior.
+     * Uses lookback buffer for incomplete fenced messages that span output chunks.
      */
     private parseRelayCommands;
     /**
@@ -95,19 +213,30 @@ export declare class PtyWrapper extends EventEmitter {
      * Format: ->relay:Target [thread:xxx] message body
      */
     private parseSingleLineMessages;
-    /**
-     * Strip ANSI escape codes from string.
-     * Converts cursor movements to spaces to preserve visual layout.
-     */
-    private stripAnsi;
     /**
      * Send relay command to daemon
      */
     private sendRelayCommand;
+    /** Valid CLI types for spawn commands */
+    private static readonly VALID_CLI_TYPES;
+    /** Validate agent name format (PascalCase, alphanumeric, 2-30 chars) */
+    private isValidAgentName;
+    /** Validate CLI type */
+    private isValidCliType;
     /**
      * Parse spawn/release commands from output
      * Uses string-based parsing for robustness with PTY output.
+     * Supports two formats:
+     *   Single-line: ->relay:spawn WorkerName cli "task description"
+     *   Multi-line (fenced): ->relay:spawn WorkerName cli <<<
+     *                        task description here
+     *                        can span multiple lines>>>
      * Delegates to dashboard API if dashboardPort is set (for nested spawns).
+     *
+     * STRICT VALIDATION:
+     * - Command must be at start of line (after whitespace)
+     * - Agent name must be PascalCase (e.g., Backend, Frontend, Worker1)
+     * - CLI must be a known type (claude, codex, gemini, etc.)
      */
     private parseSpawnReleaseCommands;
     /**
@@ -124,11 +253,30 @@ export declare class PtyWrapper extends EventEmitter {
      */
     private handleIncomingMessage;
     /**
-     * Process queued messages
+     * Wait for output to stabilize before injection.
+     * Returns true if output has been stable for the required duration.
+     */
+    private waitForOutputStable;
+    /**
+     * Check if the agent process is still alive and responsive.
+     */
+    private isAgentAlive;
+    /**
+     * Process queued messages with reliability improvements:
+     * 1. Wait for output stability before injection
+     * 2. Verify injection appeared in output
+     * 3. Retry with backoff on failure
+     * 4. Fall back to logging on complete failure
+     *
+     * Uses shared injection logic with PTY-specific callbacks.
      */
     private processMessageQueue;
     /**
-     * Inject usage instructions
+     * Queue minimal agent identity notification as the first message.
+     *
+     * Full protocol instructions are in ~/.claude/CLAUDE.md (set up by entrypoint.sh).
+     * We only inject a brief identity message here to let the agent know its name
+     * and that it's connected to the relay.
      */
     private injectInstructions;
     /**
@@ -146,15 +294,11 @@ export declare class PtyWrapper extends EventEmitter {
     /**
      * Stop the agent process
      */
-    stop(): void;
+    stop(): Promise<void>;
     /**
      * Kill the process immediately
      */
-    kill(): void;
-    /**
-     * Sleep helper
-     */
-    private sleep;
+    kill(): Promise<void>;
     /**
      * Close the log file stream
      */
@@ -163,5 +307,42 @@ export declare class PtyWrapper extends EventEmitter {
     get name(): string;
     get pid(): number | undefined;
     get logPath(): string | undefined;
+    /**
+     * Track significant outputs and inject summary reminder if needed.
+     * Works with any CLI (Claude, Gemini, Codex, etc.)
+     */
+    private trackOutputAndRemind;
+    /**
+     * Check for [[SUMMARY]] blocks and emit 'summary' event.
+     * Allows cloud services to persist summaries without hardcoding storage.
+     * Also updates the local continuity ledger for session recovery.
+     */
+    private checkForSummaryAndEmit;
+    /**
+     * Save a parsed summary to the continuity ledger.
+     * Maps summary fields to ledger fields for session recovery.
+     */
+    private saveSummaryToLedger;
+    /**
+     * Check for [[SESSION_END]] blocks and emit 'session-end' event.
+     * Allows cloud services to handle session closure without hardcoding storage.
+     * Also stores the data for use in autoSave to populate handoff.
+     */
+    private checkForSessionEndAndEmit;
+    /**
+     * Reset session-specific state for wrapper reuse.
+     * Call this when starting a new session with the same wrapper instance.
+     */
+    resetSessionState(): void;
+    /**
+     * Get injection reliability metrics
+     */
+    getInjectionMetrics(): InjectionMetrics & {
+        successRate: number;
+    };
+    /**
+     * Get count of pending messages in queue
+     */
+    get pendingMessageCount(): number;
 }
 //# sourceMappingURL=pty-wrapper.d.ts.map