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

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.64",
+  "version": "0.1.66",
   "description": "OpenCode plugin that orchestrates Claude Code sessions.",
   "keywords": [
     "opencode",
@@ -29,21 +29,21 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.81",
-    "@opencode-ai/plugin": "^1.2.27",
-    "zod": "^4.1.8"
+    "@anthropic-ai/claude-agent-sdk": "^0.2.89",
+    "@opencode-ai/plugin": "^1.3.13",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@eslint/js": "^9.22.0",
-    "@types/node": "^24.5.2",
-    "@vitest/coverage-v8": "^4.1.0",
-    "eslint": "^9.22.0",
-    "globals": "^15.15.0",
-    "knip": "^6.0.2",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.5.0",
+    "@vitest/coverage-v8": "^4.1.2",
+    "eslint": "^10.1.0",
+    "globals": "^17.4.0",
+    "knip": "^6.1.1",
     "prettier": "^3.8.1",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.57.1",
-    "vitest": "^4.1.0"
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.0",
+    "vitest": "^4.1.2"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",

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[]>;
-}

package/dist/claude/session-live-tailer.js

@@ -1,269 +0,0 @@
-import { createReadStream, existsSync, readdirSync, statSync } from 'node:fs';
-import { createInterface } from 'node:readline';
-import path from 'node:path';
-import os from 'node:os';
-/**
- * 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 class SessionLiveTailer {
-    activeTails = new Map();
-    // ── Path discovery ──────────────────────────────────────────────────
-    /**
-     * 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, cwd) {
-        const projectsDir = path.join(os.homedir(), '.claude', 'projects');
-        if (!existsSync(projectsDir)) {
-            return null;
-        }
-        // If cwd is provided, try the sanitised form first (best-effort fast path).
-        if (cwd) {
-            const sanitised = cwd.replace(/\//g, '-');
-            const candidate = path.join(projectsDir, sanitised, 'sessions', `${sessionId}.jsonl`);
-            if (existsSync(candidate)) {
-                return candidate;
-            }
-        }
-        // Fall back to scanning all project directories.
-        try {
-            for (const entry of readdirSync(projectsDir, { withFileTypes: true })) {
-                if (!entry.isDirectory())
-                    continue;
-                const candidate = path.join(projectsDir, entry.name, 'sessions', `${sessionId}.jsonl`);
-                if (existsSync(candidate)) {
-                    return candidate;
-                }
-            }
-        }
-        catch {
-            // Permission denied or similar — nothing we can do.
-        }
-        return null;
-    }
-    /**
-     * Check whether we can locate a JSONL file for the given session.
-     */
-    sessionFileExists(sessionId, cwd) {
-        return this.findSessionFile(sessionId, cwd) !== null;
-    }
-    // ── Live tailing ────────────────────────────────────────────────────
-    /**
-     * 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, cwd, onEvent, pollIntervalMs = 150) {
-        const filePath = this.findSessionFile(sessionId, cwd);
-        if (!filePath) {
-            onEvent({
-                type: 'error',
-                sessionId,
-                error: `Session JSONL not found for ${sessionId}`,
-            });
-            return () => { };
-        }
-        let offset = statSync(filePath).size;
-        let buffer = '';
-        let reading = false; // guard against overlapping reads
-        const interval = setInterval(() => {
-            if (reading)
-                return;
-            try {
-                const currentSize = statSync(filePath).size;
-                if (currentSize < offset) {
-                    // File was truncated (rotation / compaction) — reset.
-                    offset = 0;
-                    buffer = '';
-                }
-                if (currentSize <= offset)
-                    return;
-                reading = true;
-                const stream = createReadStream(filePath, {
-                    start: offset,
-                    end: currentSize - 1,
-                    encoding: 'utf8',
-                });
-                let chunk = '';
-                stream.on('data', (data) => {
-                    chunk += typeof data === 'string' ? data : data.toString('utf8');
-                });
-                stream.on('end', () => {
-                    reading = false;
-                    offset = currentSize;
-                    buffer += chunk;
-                    const lines = buffer.split('\n');
-                    // Keep the last (possibly incomplete) segment in the buffer.
-                    buffer = lines.pop() ?? '';
-                    for (const line of lines) {
-                        const trimmed = line.trim();
-                        if (!trimmed)
-                            continue;
-                        try {
-                            const parsed = JSON.parse(trimmed);
-                            onEvent({
-                                type: 'line',
-                                sessionId,
-                                data: parsed,
-                                rawLine: trimmed,
-                            });
-                        }
-                        catch {
-                            onEvent({
-                                type: 'line',
-                                sessionId,
-                                data: null,
-                                rawLine: trimmed,
-                            });
-                        }
-                    }
-                });
-                stream.on('error', (err) => {
-                    reading = false;
-                    onEvent({
-                        type: 'error',
-                        sessionId,
-                        error: err.message,
-                    });
-                });
-            }
-            catch (err) {
-                reading = false;
-                onEvent({
-                    type: 'error',
-                    sessionId,
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }, pollIntervalMs);
-        this.activeTails.set(sessionId, interval);
-        return () => this.stopTailing(sessionId);
-    }
-    /**
-     * Stop tailing a specific session.
-     */
-    stopTailing(sessionId) {
-        const interval = this.activeTails.get(sessionId);
-        if (interval) {
-            clearInterval(interval);
-            this.activeTails.delete(sessionId);
-        }
-    }
-    /**
-     * Stop all active tails (cleanup on shutdown).
-     */
-    stopAll() {
-        for (const [, interval] of this.activeTails) {
-            clearInterval(interval);
-        }
-        this.activeTails.clear();
-    }
-    // ── Snapshot helpers ────────────────────────────────────────────────
-    /**
-     * Read the last N lines from a session JSONL file.
-     */
-    async getLastLines(sessionId, cwd, lineCount = 20) {
-        const filePath = this.findSessionFile(sessionId, cwd);
-        if (!filePath)
-            return [];
-        const lines = [];
-        const rl = createInterface({
-            input: createReadStream(filePath, { encoding: 'utf8' }),
-        });
-        for await (const line of rl) {
-            lines.push(line);
-            if (lines.length > lineCount) {
-                lines.shift();
-            }
-        }
-        return lines;
-    }
-    /**
-     * Extract a preview of recent tool output from the tail of a session file.
-     */
-    async getToolOutputPreview(sessionId, cwd, maxEntries = 5) {
-        const lastLines = await this.getLastLines(sessionId, cwd, 100);
-        const previews = [];
-        for (const line of lastLines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const parsed = JSON.parse(trimmed);
-                const preview = extractToolOutput(parsed);
-                if (preview) {
-                    previews.push(preview);
-                }
-            }
-            catch {
-                // skip unparseable lines
-            }
-        }
-        return previews.slice(-maxEntries);
-    }
-}
-// ── Internal helpers ────────────────────────────────────────────────────
-/**
- * Attempt to extract tool output information from a JSONL record.
- *
- * Claude Code JSONL records with tool results can appear as:
- *   1. A top-level `{ type: "user", message: { content: [{ type: "tool_result", ... }] } }`
- *   2. Direct `tool_result` entries (less common).
- */
-function extractToolOutput(record) {
-    // Pattern 1: user message wrapping tool_result content blocks
-    if (record.type === 'user') {
-        const message = record.message;
-        if (!message)
-            return null;
-        const content = message.content;
-        if (!Array.isArray(content))
-            return null;
-        for (const block of content) {
-            if (block &&
-                typeof block === 'object' &&
-                block.type === 'tool_result') {
-                const b = block;
-                return {
-                    toolUseId: typeof b.tool_use_id === 'string' ? b.tool_use_id : '',
-                    content: stringifyContent(b.content),
-                    isError: b.is_error === true,
-                };
-            }
-        }
-    }
-    // Pattern 2: direct tool_result record (varies by Claude Code version)
-    if (record.type === 'tool_result') {
-        return {
-            toolUseId: typeof record.tool_use_id === 'string' ? record.tool_use_id : '',
-            content: stringifyContent(record.content),
-            isError: record.is_error === true,
-        };
-    }
-    return null;
-}
-function stringifyContent(value) {
-    if (typeof value === 'string')
-        return value;
-    if (value === undefined || value === null)
-        return '';
-    try {
-        return JSON.stringify(value);
-    }
-    catch {
-        return '[non-serializable]';
-    }
-}

package/dist/manager/session-controller.d.ts

@@ -1,41 +0,0 @@
-import type { ClaudeAgentSdkAdapter, ClaudeSessionEventHandler } from '../claude/claude-agent-sdk-adapter.js';
-import type { ClaudeSessionRunResult, SessionContextSnapshot, SessionMode } from '../types/contracts.js';
-import type { ContextTracker } from './context-tracker.js';
-export declare class SessionController {
-    private readonly sdkAdapter;
-    private readonly contextTracker;
-    private readonly sessionPrompt;
-    private readonly wrapperType;
-    private readonly worktree;
-    private readonly modePrefixes;
-    private activeSessionId;
-    constructor(sdkAdapter: ClaudeAgentSdkAdapter, contextTracker: ContextTracker, sessionPrompt: string | undefined, wrapperType: string, worktree: string, modePrefixes?: {
-        plan: string;
-        free: string;
-    });
-    get isActive(): boolean;
-    get sessionId(): string | null;
-    /**
-     * Send a message to the persistent session. Creates one if none exists.
-     * Returns the session result including usage data.
-     */
-    sendMessage(message: string, options?: {
-        model?: string;
-        effort?: 'low' | 'medium' | 'high' | 'max';
-        mode?: SessionMode;
-        sessionSystemPrompt?: string;
-        abortSignal?: AbortSignal;
-    }, onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
-    /**
-     * Send /compact to the current session to compress context.
-     */
-    compactSession(onEvent?: ClaudeSessionEventHandler): Promise<ClaudeSessionRunResult>;
-    /**
-     * Clear the current session. The next sendMessage will create a fresh one.
-     */
-    clearSession(): Promise<string | null>;
-    /**
-     * Get current context tracking snapshot.
-     */
-    getContextSnapshot(): SessionContextSnapshot;
-}