@doingdev/opencode-claude-manager-plugin 0.1.65 → 0.1.66

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { Plugin } from '@opencode-ai/plugin';
 import { ClaudeManagerPlugin } from './plugin/claude-manager.plugin.js';
-export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, ContextWarningLevel, SessionMode, EngineerName, EngineerWorkMode, EngineerFailureKind, EngineerFailureResult, WrapperHistoryEntry, TeamEngineerRecord, TeamRecord, EngineerTaskResult, PlanDraft, SynthesizedPlanResult, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
+export type { ClaudeCapabilitySnapshot, ClaudeSessionRunResult, ClaudeSessionSummary, ClaudeSessionTranscriptMessage, ManagerPromptRegistry, RunClaudeSessionInput, SessionContextSnapshot, GitDiffResult, GitOperationResult, ContextWarningLevel, SessionMode, EngineerName, EngineerWorkMode, EngineerFailureKind, EngineerFailureResult, WrapperHistoryEntry, AgentMessageStatus, AgentMessage, TeamEngineerRecord, TeamRecord, EngineerTaskResult, PlanDraft, SynthesizedPlanResult, ToolApprovalRule, ToolApprovalPolicy, ToolApprovalDecision, } from './types/contracts.js';
 export { ClaudeManagerPlugin };
 export declare const plugin: Plugin;

package/dist/manager/team-orchestrator.js

@@ -223,7 +223,7 @@ export class TeamOrchestrator {
     }
     static classifyError(error) {
         const message = error instanceof Error ? error.message : String(error);
-        let failureKind = 'unknown';
+        let failureKind;
         if (message.includes('already working on another assignment')) {
             failureKind = 'engineerBusy';
         }

package/dist/plugin/agents/common.d.ts

@@ -11,8 +11,8 @@ export declare const ENGINEER_AGENT_IDS: {
 };
 /** General named engineers only (Tom/John/Maya/Sara/Alex). BrowserQA is a specialist registered separately. */
 export declare const ENGINEER_AGENT_NAMES: readonly ["Tom", "John", "Maya", "Sara", "Alex"];
-export declare const CTO_ONLY_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update"];
-export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "claude"];
+export declare const CTO_ONLY_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "inspect_team_inbox"];
+export declare const ALL_RESTRICTED_TOOL_IDS: readonly ["team_status", "reset_engineer", "list_transcripts", "list_history", "git_diff", "git_commit", "git_reset", "git_status", "git_log", "approval_policy", "approval_decisions", "approval_update", "inspect_team_inbox", "claude"];
 export type ToolPermission = 'allow' | 'ask' | 'deny';
 export type AgentPermission = {
     '*'?: ToolPermission;

package/dist/plugin/agents/common.js

@@ -25,6 +25,7 @@ export const CTO_ONLY_TOOL_IDS = [
     'approval_policy',
     'approval_decisions',
     'approval_update',
+    'inspect_team_inbox',
 ];
 const ENGINEER_TOOL_IDS = ['claude'];
 export const ALL_RESTRICTED_TOOL_IDS = [...CTO_ONLY_TOOL_IDS, ...ENGINEER_TOOL_IDS];
@@ -50,6 +51,10 @@ export function buildEngineerPermissions() {
         '*': 'deny',
         ...denied,
         claude: 'allow',
+        send_message: 'allow',
+        list_inbox: 'allow',
+        get_message: 'allow',
+        ack_message: 'allow',
     };
 }
 export function denyRestrictedToolsGlobally(permissions) {

package/dist/plugin/claude-manager.plugin.js

@@ -4,6 +4,7 @@ import { appendDebugLog } from '../util/fs-helpers.js';
 import { isEngineerName } from '../team/roster.js';
 import { TeamOrchestrator, createActionableError, getFailureGuidanceText, } from '../manager/team-orchestrator.js';
 import { AGENT_BROWSER_QA, AGENT_CTO, AGENT_TEAM_PLANNER, buildBrowserQaAgentConfig, buildCtoAgentConfig, buildEngineerAgentConfig, buildTeamPlannerAgentConfig, denyRestrictedToolsGlobally, ENGINEER_AGENT_IDS, ENGINEER_AGENT_NAMES, } from './agents/index.js';
+import { ackMessage, buildInboxNotice, getMessage, getUnreadCount, listAllInboxes, listInbox, sendMessage, } from './inbox-ops.js';
 import { clearLatestRevertProcessed, clearRevertProcessed, getOrCreatePluginServices, getParentSessionId, getSessionTeam, getWrapperSessionMapping, isRevertAlreadyProcessed, markRevertProcessed, registerParentSession, registerSessionTeam, setWrapperSessionMapping, } from './service-factory.js';
 const MODEL_ENUM = ['claude-opus-4-6', 'claude-sonnet-4-6'];
 const MODE_ENUM = ['explore', 'implement', 'verify'];
@@ -314,6 +315,14 @@ export const ClaudeManagerPlugin = async ({ worktree, client }) => {
             if (wrapperContext) {
                 output.system.push(wrapperContext);
             }
+            // Inject inbox notice if the engineer has unread peer messages.
+            const team = await services.teamStore.getTeam(worktree, mapping.teamId);
+            if (team) {
+                const unreadCount = getUnreadCount(team, mapping.workerName);
+                if (unreadCount > 0) {
+                    output.system.push(buildInboxNotice(unreadCount));
+                }
+            }
         },
         tool: {
             claude: tool({
@@ -436,6 +445,101 @@ export const ClaudeManagerPlugin = async ({ worktree, client }) => {
                     return JSON.stringify({ reset: true, engineer: engineer ?? args.engineer }, null, 2);
                 },
             }),
+            send_message: tool({
+                description: 'Send a peer message to another engineer on your team. Use this for requests, questions, and recommendations — not to assign work (only CTO assigns work). Reference files by path using the filePaths arg — never paste file contents. Supply replyToId when replying to keep thread context (reply chains are capped at 5 deep; loop in the CTO if deeper coordination is needed). If you receive conflicting guidance from multiple peers, stop and ask the CTO for direction.',
+                args: {
+                    to: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex', 'BrowserQA']),
+                    subject: tool.schema.string().min(1),
+                    body: tool.schema.string().min(1),
+                    filePaths: tool.schema.string().array().optional(),
+                    replyToId: tool.schema.string().optional(),
+                },
+                async execute(args, context) {
+                    const engineer = engineerFromAgent(context.agent);
+                    const existing = getWrapperSessionMapping(context.worktree, context.sessionID);
+                    const persisted = existing ??
+                        (await services.orchestrator.findTeamByWrapperSession(context.worktree, context.sessionID));
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.sessionID));
+                    annotateToolRun(context, `${engineer} → send_message to ${args.to}`, { teamId });
+                    const result = await sendMessage(services.teamStore, context.worktree, teamId, engineer, args.to, args.subject, args.body, { filePaths: args.filePaths, replyToId: args.replyToId });
+                    return JSON.stringify(result, null, 2);
+                },
+            }),
+            list_inbox: tool({
+                description: 'List your unread peer messages (ID, sender, subject, timestamp). Use get_message to read a full message body.',
+                args: {},
+                async execute(_args, context) {
+                    const engineer = engineerFromAgent(context.agent);
+                    const existing = getWrapperSessionMapping(context.worktree, context.sessionID);
+                    const persisted = existing ??
+                        (await services.orchestrator.findTeamByWrapperSession(context.worktree, context.sessionID));
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.sessionID));
+                    annotateToolRun(context, `${engineer} → list_inbox`, { teamId });
+                    const messages = await listInbox(services.teamStore, context.worktree, teamId, engineer);
+                    const summaries = messages.map(({ id, fromEngineer, subject, createdAt, depth, replyToId, filePaths }) => ({
+                        id,
+                        from: fromEngineer,
+                        subject,
+                        createdAt,
+                        depth,
+                        ...(replyToId !== undefined && { replyToId }),
+                        ...(filePaths !== undefined && filePaths.length > 0 && { filePaths }),
+                    }));
+                    return JSON.stringify({ count: summaries.length, messages: summaries }, null, 2);
+                },
+            }),
+            get_message: tool({
+                description: 'Read the full body of a peer message by its ID.',
+                args: {
+                    messageId: tool.schema.string().min(1),
+                },
+                async execute(args, context) {
+                    const engineer = engineerFromAgent(context.agent);
+                    const existing = getWrapperSessionMapping(context.worktree, context.sessionID);
+                    const persisted = existing ??
+                        (await services.orchestrator.findTeamByWrapperSession(context.worktree, context.sessionID));
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.sessionID));
+                    annotateToolRun(context, `${engineer} → get_message`, { teamId, messageId: args.messageId });
+                    const message = await getMessage(services.teamStore, context.worktree, teamId, engineer, args.messageId);
+                    if (!message) {
+                        return JSON.stringify({ error: 'Message not found.' });
+                    }
+                    return JSON.stringify(message, null, 2);
+                },
+            }),
+            ack_message: tool({
+                description: 'Acknowledge a peer message to hide it from your inbox. The message is retained for CTO inspection but will not appear in future list_inbox results.',
+                args: {
+                    messageId: tool.schema.string().min(1),
+                },
+                async execute(args, context) {
+                    const engineer = engineerFromAgent(context.agent);
+                    const existing = getWrapperSessionMapping(context.worktree, context.sessionID);
+                    const persisted = existing ??
+                        (await services.orchestrator.findTeamByWrapperSession(context.worktree, context.sessionID));
+                    const teamId = persisted?.teamId ?? (await resolveTeamId(context.sessionID));
+                    annotateToolRun(context, `${engineer} → ack_message`, { teamId, messageId: args.messageId });
+                    const ok = await ackMessage(services.teamStore, context.worktree, teamId, engineer, args.messageId);
+                    return JSON.stringify({ acked: ok }, null, 2);
+                },
+            }),
+            inspect_team_inbox: tool({
+                description: 'Read all peer messages across all engineers on the team, including acked messages. Optionally filter by engineer.',
+                args: {
+                    teamId: tool.schema.string().optional(),
+                    engineer: tool.schema.enum(['Tom', 'John', 'Maya', 'Sara', 'Alex', 'BrowserQA']).optional(),
+                },
+                async execute(args, context) {
+                    const teamId = args.teamId ?? context.sessionID;
+                    annotateToolRun(context, 'Inspecting team inbox', { teamId, engineer: args.engineer });
+                    const team = await services.orchestrator.getOrCreateTeam(context.worktree, teamId);
+                    const allInboxes = listAllInboxes(team);
+                    if (args.engineer) {
+                        return JSON.stringify({ [args.engineer]: allInboxes[args.engineer] ?? [] }, null, 2);
+                    }
+                    return JSON.stringify(allInboxes, null, 2);
+                },
+            }),
             git_diff: tool({
                 description: 'Show diff of uncommitted changes. Use paths to filter to specific files or use ref to compare against another branch, tag, or commit.',
                 args: {

package/dist/plugin/inbox-ops.d.ts

@@ -0,0 +1,50 @@
+import type { AgentMessage, EngineerName, TeamRecord } from '../types/contracts.js';
+import type { TeamStateStore } from '../state/team-state-store.js';
+export declare const MAX_INBOX_SIZE = 50;
+export declare const MAX_MESSAGE_BODY_LENGTH = 4000;
+export declare const MAX_MESSAGE_SUBJECT_LENGTH = 200;
+/**
+ * Maximum reply-chain depth. A top-level message has depth 0; each reply
+ * increments by 1. Attempts to exceed this cap are rejected with a message
+ * directing the agent to loop in the CTO.
+ */
+export declare const MAX_THREAD_DEPTH = 5;
+export type SendMessageResult = {
+    ok: true;
+    message: AgentMessage;
+} | {
+    ok: false;
+    error: string;
+};
+export interface SendMessageOptions {
+    /** File paths referenced in the message. Paths only — contents are never embedded. */
+    filePaths?: string[];
+    /**
+     * ID of the message being replied to. Must be a message in the sender's own inbox.
+     * Providing this increments the thread depth and enforces the MAX_THREAD_DEPTH cap.
+     */
+    replyToId?: string;
+}
+/**
+ * Deliver a peer message from one engineer to another on the same team.
+ * All validation and persistence happen atomically via the write queue.
+ */
+export declare function sendMessage(store: TeamStateStore, cwd: string, teamId: string, fromEngineer: EngineerName, toEngineer: EngineerName, subject: string, body: string, options?: SendMessageOptions): Promise<SendMessageResult>;
+/**
+ * Return all unread messages for an engineer, in FIFO order.
+ * Acked messages are excluded.
+ */
+export declare function listInbox(store: TeamStateStore, cwd: string, teamId: string, engineerName: EngineerName): Promise<AgentMessage[]>;
+/** Fetch a single message by ID. Returns null if not found or if it belongs to a different engineer. */
+export declare function getMessage(store: TeamStateStore, cwd: string, teamId: string, engineerName: EngineerName, messageId: string): Promise<AgentMessage | null>;
+/**
+ * Mark a message as acked (hidden from list_inbox).
+ * Returns true if the ack was applied, false if the message was not found or already acked.
+ */
+export declare function ackMessage(store: TeamStateStore, cwd: string, teamId: string, engineerName: EngineerName, messageId: string): Promise<boolean>;
+/** Count unread messages for one engineer without hitting the store. */
+export declare function getUnreadCount(team: TeamRecord, engineerName: EngineerName): number;
+/** Build a concise notice to inject into the engineer's system prompt. */
+export declare function buildInboxNotice(unreadCount: number): string;
+/** Return all inboxes on a team (including acked messages) for CTO inspection. */
+export declare function listAllInboxes(team: TeamRecord): Record<string, AgentMessage[]>;

package/dist/plugin/inbox-ops.js

@@ -0,0 +1,166 @@
+import { randomUUID } from 'node:crypto';
+export const MAX_INBOX_SIZE = 50;
+export const MAX_MESSAGE_BODY_LENGTH = 4000;
+export const MAX_MESSAGE_SUBJECT_LENGTH = 200;
+/**
+ * Maximum reply-chain depth. A top-level message has depth 0; each reply
+ * increments by 1. Attempts to exceed this cap are rejected with a message
+ * directing the agent to loop in the CTO.
+ */
+export const MAX_THREAD_DEPTH = 5;
+/**
+ * Deliver a peer message from one engineer to another on the same team.
+ * All validation and persistence happen atomically via the write queue.
+ */
+export async function sendMessage(store, cwd, teamId, fromEngineer, toEngineer, subject, body, options = {}) {
+    if (fromEngineer === toEngineer) {
+        return { ok: false, error: 'Cannot send a message to yourself.' };
+    }
+    if (subject.length > MAX_MESSAGE_SUBJECT_LENGTH) {
+        return { ok: false, error: `Subject exceeds ${MAX_MESSAGE_SUBJECT_LENGTH} characters.` };
+    }
+    if (body.length > MAX_MESSAGE_BODY_LENGTH) {
+        return { ok: false, error: `Body exceeds ${MAX_MESSAGE_BODY_LENGTH} characters.` };
+    }
+    const { filePaths, replyToId } = options;
+    if (filePaths?.some((p) => !p.trim())) {
+        return { ok: false, error: 'File paths must not be empty strings.' };
+    }
+    let sent = null;
+    let updateError = null;
+    try {
+        await store.updateTeam(cwd, teamId, (team) => {
+            const recipient = team.engineers.find((e) => e.name === toEngineer);
+            if (!recipient) {
+                throw new Error(`Engineer ${toEngineer} is not on team ${teamId}.`);
+            }
+            const inbox = recipient.inbox ?? [];
+            const unreadCount = inbox.filter((m) => m.status === 'unread').length;
+            if (unreadCount >= MAX_INBOX_SIZE) {
+                throw new Error(`${toEngineer}'s inbox is full (${MAX_INBOX_SIZE} unread messages).`);
+            }
+            // Thread-depth guard: resolve depth from the replied-to message.
+            let depth = 0;
+            if (replyToId !== undefined) {
+                const senderRecord = team.engineers.find((e) => e.name === fromEngineer);
+                const original = (senderRecord?.inbox ?? []).find((m) => m.id === replyToId);
+                if (!original) {
+                    throw new Error(`Reply-to message ${replyToId} not found in ${fromEngineer}'s inbox.`);
+                }
+                if (original.toEngineer !== fromEngineer) {
+                    throw new Error('replyToId must reference a message addressed to you.');
+                }
+                depth = original.depth + 1;
+                if (depth > MAX_THREAD_DEPTH) {
+                    throw new Error(`Thread depth limit reached (max ${MAX_THREAD_DEPTH}). Loop in the CTO to coordinate further.`);
+                }
+            }
+            const msg = {
+                id: randomUUID(),
+                fromEngineer,
+                toEngineer,
+                teamId,
+                createdAt: new Date().toISOString(),
+                status: 'unread',
+                subject: subject.trim(),
+                body,
+                depth,
+                ...(replyToId !== undefined && { replyToId }),
+                ...(filePaths !== undefined && filePaths.length > 0 && { filePaths }),
+            };
+            sent = msg;
+            return {
+                ...team,
+                updatedAt: new Date().toISOString(),
+                engineers: team.engineers.map((e) => e.name === toEngineer ? { ...e, inbox: [...inbox, msg] } : e),
+            };
+        });
+    }
+    catch (error) {
+        updateError = error instanceof Error ? error.message : String(error);
+    }
+    if (updateError !== null) {
+        return { ok: false, error: updateError };
+    }
+    if (!sent) {
+        return { ok: false, error: 'Failed to persist message.' };
+    }
+    return { ok: true, message: sent };
+}
+/**
+ * Return all unread messages for an engineer, in FIFO order.
+ * Acked messages are excluded.
+ */
+export async function listInbox(store, cwd, teamId, engineerName) {
+    const team = await store.getTeam(cwd, teamId);
+    if (!team)
+        return [];
+    const engineer = team.engineers.find((e) => e.name === engineerName);
+    if (!engineer)
+        return [];
+    return (engineer.inbox ?? []).filter((m) => m.status === 'unread');
+}
+/** Fetch a single message by ID. Returns null if not found or if it belongs to a different engineer. */
+export async function getMessage(store, cwd, teamId, engineerName, messageId) {
+    const team = await store.getTeam(cwd, teamId);
+    if (!team)
+        return null;
+    const engineer = team.engineers.find((e) => e.name === engineerName);
+    if (!engineer)
+        return null;
+    return (engineer.inbox ?? []).find((m) => m.id === messageId) ?? null;
+}
+/**
+ * Mark a message as acked (hidden from list_inbox).
+ * Returns true if the ack was applied, false if the message was not found or already acked.
+ */
+export async function ackMessage(store, cwd, teamId, engineerName, messageId) {
+    let acked = false;
+    try {
+        await store.updateTeam(cwd, teamId, (team) => {
+            const engineer = team.engineers.find((e) => e.name === engineerName);
+            if (!engineer)
+                return team;
+            const inbox = engineer.inbox ?? [];
+            const msg = inbox.find((m) => m.id === messageId);
+            if (!msg || msg.status === 'acked')
+                return team;
+            acked = true;
+            return {
+                ...team,
+                updatedAt: new Date().toISOString(),
+                engineers: team.engineers.map((e) => e.name === engineerName
+                    ? {
+                        ...e,
+                        inbox: inbox.map((m) => m.id === messageId ? { ...m, status: 'acked' } : m),
+                    }
+                    : e),
+            };
+        });
+    }
+    catch {
+        return false;
+    }
+    return acked;
+}
+/** Count unread messages for one engineer without hitting the store. */
+export function getUnreadCount(team, engineerName) {
+    const engineer = team.engineers.find((e) => e.name === engineerName);
+    return (engineer?.inbox ?? []).filter((m) => m.status === 'unread').length;
+}
+/** Build a concise notice to inject into the engineer's system prompt. */
+export function buildInboxNotice(unreadCount) {
+    const plural = unreadCount === 1 ? '' : 's';
+    return `You have ${unreadCount} unread peer message${plural}. Use list_inbox to view them, get_message to read a message body, and ack_message to hide a message from your inbox.`;
+}
+/** Return all inboxes on a team (including acked messages) for CTO inspection. */
+export function listAllInboxes(team) {
+    const result = {};
+    for (const engineer of team.engineers) {
+        const inbox = engineer.inbox ?? [];
+        if (inbox.length > 0) {
+            result[engineer.name] = inbox;
+        }
+    }
+    return result;
+}

package/dist/types/contracts.d.ts

@@ -27,6 +27,23 @@ export interface WrapperHistoryEntry {
     mode?: EngineerWorkMode;
     text: string;
 }
+export type AgentMessageStatus = 'unread' | 'acked';
+export interface AgentMessage {
+    id: string;
+    fromEngineer: EngineerName;
+    toEngineer: EngineerName;
+    teamId: string;
+    createdAt: string;
+    status: AgentMessageStatus;
+    subject: string;
+    body: string;
+    /** 0-based chain depth. Top-level messages are 0; each reply increments by 1. */
+    depth: number;
+    /** ID of the message being replied to, if this is a reply. */
+    replyToId?: string;
+    /** File paths referenced in this message. Contents are not embedded — paths only. */
+    filePaths?: string[];
+}
 interface ClaudeCommandMetadata {
     name: string;
     description: string;
@@ -145,6 +162,7 @@ export interface TeamEngineerRecord {
     lastUsedAt: string | null;
     wrapperHistory: WrapperHistoryEntry[];
     context: SessionContextSnapshot;
+    inbox?: AgentMessage[];
 }
 export type EngineerFailureKind = 'sdkError' | 'contextExhausted' | 'toolDenied' | 'modeNotSupported' | 'aborted' | 'engineerBusy' | 'unknown';
 export interface EngineerFailureResult {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doingdev/opencode-claude-manager-plugin",
-  "version": "0.1.65",
+  "version": "0.1.66",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",

package/dist/claude/session-live-tailer.d.ts

@@ -1,51 +0,0 @@
-import type { LiveTailEvent, ToolOutputPreview } from '../types/contracts.js';
-/**
- * Tails Claude Code session JSONL files for live tool output.
- *
- * The SDK streams high-level events (assistant text, tool_call summaries, results)
- * but does not expose the raw tool output that Claude Code writes to the JSONL
- * transcript on disk.  This service fills that gap by polling the file for new
- * lines, parsing each one, and forwarding parsed events to a caller-supplied
- * callback.
- */
-export declare class SessionLiveTailer {
-    private activeTails;
-    /**
-     * Locate the JSONL file for a session.
-     *
-     * Claude Code stores transcripts at:
-     *   ~/.claude/projects/<sanitized-cwd>/sessions/<session-id>.jsonl
-     *
-     * The `<sanitized-cwd>` folder name is an internal implementation detail that
-     * can change across Claude Code versions, so we search all project directories
-     * for the session file rather than attempting to replicate the sanitisation.
-     */
-    findSessionFile(sessionId: string, cwd?: string): string | null;
-    /**
-     * Check whether we can locate a JSONL file for the given session.
-     */
-    sessionFileExists(sessionId: string, cwd?: string): boolean;
-    /**
-     * Poll a session's JSONL file for new lines and emit parsed events.
-     *
-     * Returns a stop function.  The caller **must** invoke it when tailing is no
-     * longer needed (e.g. when the session completes or the tool is interrupted).
-     */
-    startTailing(sessionId: string, cwd: string | undefined, onEvent: (event: LiveTailEvent) => void, pollIntervalMs?: number): () => void;
-    /**
-     * Stop tailing a specific session.
-     */
-    stopTailing(sessionId: string): void;
-    /**
-     * Stop all active tails (cleanup on shutdown).
-     */
-    stopAll(): void;
-    /**
-     * Read the last N lines from a session JSONL file.
-     */
-    getLastLines(sessionId: string, cwd: string | undefined, lineCount?: number): Promise<string[]>;
-    /**
-     * Extract a preview of recent tool output from the tail of a session file.
-     */
-    getToolOutputPreview(sessionId: string, cwd: string | undefined, maxEntries?: number): Promise<ToolOutputPreview[]>;
-}