@finityno/claude-code-acp 0.14.0 → 0.16.0

package/dist/subagent-tracker.js

@@ -7,6 +7,8 @@ export class SubagentTracker {
         this.subagents = new Map();
         /** Map of session ID to subagent IDs in that session */
         this.sessionSubagents = new Map();
+        /** Map of agent ID to subagent ID (for resume lookups) */
+        this.agentIdToSubagent = new Map();
         /** Event listeners for subagent lifecycle events */
         this.listeners = new Map();
         this.client = client;
@@ -16,6 +18,11 @@ export class SubagentTracker {
      * Track a new subagent when Task tool is called
      */
     trackSubagent(toolUseId, sessionId, input, parentToolUseId) {
+        // Check if this is a resume operation
+        const isResumed = !!input.resume;
+        const originalTaskId = input.resume
+            ? this.agentIdToSubagent.get(input.resume)
+            : undefined;
         const subagent = {
             id: toolUseId,
             parentSessionId: sessionId,
@@ -28,6 +35,12 @@ export class SubagentTracker {
             createdAt: Date.now(),
             runInBackground: input.run_in_background ?? false,
             maxTurns: input.max_turns,
+            // SDK 0.2.17 fields
+            agentName: input.name,
+            teamName: input.team_name,
+            permissionMode: input.mode,
+            isResumed,
+            originalTaskId,
         };
         this.subagents.set(toolUseId, subagent);
         // Track by session
@@ -35,7 +48,7 @@ export class SubagentTracker {
             this.sessionSubagents.set(sessionId, new Set());
         }
         this.sessionSubagents.get(sessionId).add(toolUseId);
-        this.logger.log(`[SubagentTracker] Tracked new subagent: ${toolUseId} (${input.subagent_type}: ${input.description})`);
+        this.logger.log(`[SubagentTracker] Tracked new subagent: ${toolUseId} (${input.subagent_type}: ${input.description})${isResumed ? " [RESUMED]" : ""}`);
         return subagent;
     }
     /**
@@ -66,10 +79,12 @@ export class SubagentTracker {
         subagent.result = result;
         if (agentId) {
             subagent.agentId = agentId;
+            // Track agent ID for resume lookups
+            this.agentIdToSubagent.set(agentId, toolUseId);
         }
         await this.emitEvent("subagent_completed", subagent);
         await this.sendSubagentNotification(subagent, "subagent_completed");
-        this.logger.log(`[SubagentTracker] Subagent completed: ${toolUseId} (duration: ${this.getDuration(subagent)}ms)`);
+        this.logger.log(`[SubagentTracker] Subagent completed: ${toolUseId} (duration: ${this.getDuration(subagent)}ms)${agentId ? ` [agentId: ${agentId}]` : ""}`);
     }
     /**
      * Mark a subagent as failed
@@ -101,6 +116,40 @@ export class SubagentTracker {
         await this.sendSubagentNotification(subagent, "subagent_cancelled");
         this.logger.log(`[SubagentTracker] Subagent cancelled: ${toolUseId}`);
     }
+    /**
+     * Handle SDKTaskNotificationMessage from the Claude Agent SDK.
+     * This is called when a background task completes/fails/stops.
+     */
+    async handleTaskNotification(notification) {
+        const subagent = this.subagents.get(notification.task_id);
+        if (!subagent) {
+            this.logger.error(`[SubagentTracker] Received task notification for unknown subagent: ${notification.task_id}`);
+            return;
+        }
+        // Update subagent with notification data
+        subagent.outputFile = notification.output_file;
+        subagent.summary = notification.summary;
+        subagent.completedAt = Date.now();
+        // Map SDK status to our status
+        switch (notification.status) {
+            case "completed":
+                subagent.status = "completed";
+                await this.emitEvent("subagent_completed", subagent);
+                await this.sendSubagentNotification(subagent, "subagent_completed", notification);
+                break;
+            case "failed":
+                subagent.status = "failed";
+                await this.emitEvent("subagent_failed", subagent);
+                await this.sendSubagentNotification(subagent, "subagent_failed", notification);
+                break;
+            case "stopped":
+                subagent.status = "stopped";
+                await this.emitEvent("subagent_stopped", subagent);
+                await this.sendSubagentNotification(subagent, "subagent_stopped", notification);
+                break;
+        }
+        this.logger.log(`[SubagentTracker] Task notification: ${notification.task_id} -> ${notification.status}`);
+    }
     /**
      * Send progress update for a running subagent
      */
@@ -162,6 +211,22 @@ export class SubagentTracker {
     getAllSubagents() {
         return Array.from(this.subagents.values());
     }
+    /**
+     * Find a subagent by its agent ID (for resume operations)
+     */
+    findByAgentId(agentId) {
+        const subagentId = this.agentIdToSubagent.get(agentId);
+        if (!subagentId)
+            return undefined;
+        return this.subagents.get(subagentId);
+    }
+    /**
+     * Get tasks that can be resumed (have agentId and are completed/failed/stopped)
+     */
+    getResumableTasks() {
+        return Array.from(this.subagents.values()).filter((s) => s.agentId &&
+            (s.status === "completed" || s.status === "failed" || s.status === "stopped"));
+    }
     /**
      * Check if a tool use ID is a Task tool (subagent)
      */
@@ -192,16 +257,102 @@ export class SubagentTracker {
         for (const [id, subagent] of this.subagents) {
             if ((subagent.status === "completed" ||
                 subagent.status === "failed" ||
-                subagent.status === "cancelled") &&
+                subagent.status === "cancelled" ||
+                subagent.status === "stopped") &&
                 subagent.completedAt &&
                 now - subagent.completedAt > maxAgeMs) {
                 this.subagents.delete(id);
                 this.sessionSubagents.get(subagent.parentSessionId)?.delete(id);
+                if (subagent.agentId) {
+                    this.agentIdToSubagent.delete(subagent.agentId);
+                }
                 cleanedCount++;
             }
         }
         return cleanedCount;
     }
+    /**
+     * Export current state for persistence
+     */
+    exportState() {
+        const tasks = Array.from(this.subagents.values()).map((s) => ({
+            id: s.id,
+            parentSessionId: s.parentSessionId,
+            parentToolUseId: s.parentToolUseId,
+            subagentType: s.subagentType,
+            description: s.description,
+            prompt: s.prompt,
+            model: s.model,
+            status: s.status,
+            createdAt: s.createdAt,
+            startedAt: s.startedAt,
+            completedAt: s.completedAt,
+            result: s.result,
+            error: s.error,
+            runInBackground: s.runInBackground,
+            maxTurns: s.maxTurns,
+            agentId: s.agentId,
+            outputFile: s.outputFile,
+            summary: s.summary,
+            agentName: s.agentName,
+            teamName: s.teamName,
+            permissionMode: s.permissionMode,
+            isResumed: s.isResumed,
+            originalTaskId: s.originalTaskId,
+        }));
+        return {
+            version: 1,
+            tasks,
+            lastUpdated: Date.now(),
+        };
+    }
+    /**
+     * Import state from persistence
+     */
+    importState(state) {
+        if (state.version !== 1) {
+            this.logger.error(`[SubagentTracker] Unknown state version: ${state.version}`);
+            return;
+        }
+        for (const task of state.tasks) {
+            const subagent = {
+                id: task.id,
+                parentSessionId: task.parentSessionId,
+                parentToolUseId: task.parentToolUseId,
+                subagentType: task.subagentType,
+                description: task.description,
+                prompt: task.prompt,
+                model: task.model,
+                status: task.status,
+                createdAt: task.createdAt,
+                startedAt: task.startedAt,
+                completedAt: task.completedAt,
+                result: task.result,
+                error: task.error,
+                runInBackground: task.runInBackground,
+                maxTurns: task.maxTurns,
+                agentId: task.agentId,
+                outputFile: task.outputFile,
+                summary: task.summary,
+                agentName: task.agentName,
+                teamName: task.teamName,
+                permissionMode: task.permissionMode,
+                isResumed: task.isResumed,
+                originalTaskId: task.originalTaskId,
+            };
+            this.subagents.set(task.id, subagent);
+            // Rebuild session index
+            if (!this.sessionSubagents.has(task.parentSessionId)) {
+                this.sessionSubagents.set(task.parentSessionId, new Set());
+            }
+            this.sessionSubagents.get(task.parentSessionId).add(task.id);
+            // Rebuild agent ID index
+            if (task.agentId) {
+                this.agentIdToSubagent.set(task.agentId, task.id);
+            }
+        }
+        this.logger.log(`[SubagentTracker] Imported ${state.tasks.length} tasks from persistence`);
+    }
     /**
      * Get statistics about subagents
      */
@@ -214,6 +365,7 @@ export class SubagentTracker {
             completed: subagents.filter((s) => s.status === "completed").length,
             failed: subagents.filter((s) => s.status === "failed").length,
             cancelled: subagents.filter((s) => s.status === "cancelled").length,
+            stopped: subagents.filter((s) => s.status === "stopped").length,
             byType: this.countByType(subagents),
             averageDurationMs: this.calculateAverageDuration(subagents),
         };
@@ -224,6 +376,7 @@ export class SubagentTracker {
     clear() {
         this.subagents.clear();
         this.sessionSubagents.clear();
+        this.agentIdToSubagent.clear();
     }
     // Private helper methods
     async emitEvent(event, subagent, data) {
@@ -239,31 +392,43 @@ export class SubagentTracker {
             }
         }
     }
-    async sendSubagentNotification(subagent, eventType) {
+    async sendSubagentNotification(subagent, eventType, taskNotification) {
         if (!this.client)
             return;
+        const meta = {
+            claudeCode: {
+                subagent: {
+                    id: subagent.id,
+                    eventType,
+                    subagentType: subagent.subagentType,
+                    description: subagent.description,
+                    status: subagent.status,
+                    parentSessionId: subagent.parentSessionId,
+                    parentToolUseId: subagent.parentToolUseId,
+                    model: subagent.model,
+                    runInBackground: subagent.runInBackground,
+                    agentId: subagent.agentId,
+                    durationMs: this.getDuration(subagent),
+                    outputFile: subagent.outputFile,
+                    summary: subagent.summary,
+                },
+            },
+        };
+        // Include task notification data if available
+        if (taskNotification) {
+            meta.claudeCode.taskNotification = {
+                taskId: taskNotification.task_id,
+                status: taskNotification.status,
+                outputFile: taskNotification.output_file,
+                summary: taskNotification.summary,
+            };
+        }
         const notification = {
             sessionId: subagent.parentSessionId,
             update: {
                 sessionUpdate: "tool_call_update",
                 toolCallId: subagent.id,
-                _meta: {
-                    claudeCode: {
-                        subagent: {
-                            id: subagent.id,
-                            eventType,
-                            subagentType: subagent.subagentType,
-                            description: subagent.description,
-                            status: subagent.status,
-                            parentSessionId: subagent.parentSessionId,
-                            parentToolUseId: subagent.parentToolUseId,
-                            model: subagent.model,
-                            runInBackground: subagent.runInBackground,
-                            agentId: subagent.agentId,
-                            durationMs: this.getDuration(subagent),
-                        },
-                    },
-                },
+                _meta: meta,
             },
         };
         await this.client.sessionUpdate(notification);
@@ -282,7 +447,9 @@ export class SubagentTracker {
         return counts;
     }
     calculateAverageDuration(subagents) {
-        const completed = subagents.filter((s) => (s.status === "completed" || s.status === "failed") && s.startedAt && s.completedAt);
+        const completed = subagents.filter((s) => (s.status === "completed" || s.status === "failed" || s.status === "stopped") &&
+            s.startedAt &&
+            s.completedAt);
         if (completed.length === 0)
             return undefined;
         const totalDuration = completed.reduce((sum, s) => sum + (s.completedAt - s.startedAt), 0);

package/dist/task-manager.d.ts

@@ -0,0 +1,106 @@
+import { TrackedSubagent, SubagentTracker, SubagentStatus } from "./subagent-tracker.js";
+import { Logger } from "./acp-agent.js";
+export interface TaskManagerOptions {
+    /** Path to persistence file. Defaults to ~/.claude/acp-task-state.json */
+    persistencePath?: string;
+    /** Logger for output. Defaults to console */
+    logger?: Logger;
+    /** Enable auto-save. Defaults to true */
+    autoSave?: boolean;
+    /** Auto-save interval in milliseconds. Defaults to 30000 (30 seconds) */
+    autoSaveIntervalMs?: number;
+    /** Maximum age of tasks to keep in milliseconds. Defaults to 24 hours */
+    maxTaskAgeMs?: number;
+}
+export interface TaskFilter {
+    /** Filter by task status */
+    status?: SubagentStatus[];
+    /** Filter by session ID */
+    sessionId?: string;
+    /** Filter by background execution */
+    runInBackground?: boolean;
+    /** Filter by subagent type */
+    subagentType?: string;
+    /** Only include tasks newer than this timestamp */
+    newerThan?: number;
+    /** Only include tasks older than this timestamp */
+    olderThan?: number;
+}
+/**
+ * TaskManager handles cross-session task persistence and management.
+ *
+ * It wraps SubagentTracker and provides:
+ * - Persistence to disk for background tasks
+ * - Cross-session task querying
+ * - Resume capability tracking
+ * - Task output file reading
+ */
+export declare class TaskManager {
+    private tracker;
+    private persistencePath;
+    private logger;
+    private autoSaveInterval?;
+    private maxTaskAgeMs;
+    private isDirty;
+    constructor(tracker: SubagentTracker, options?: TaskManagerOptions);
+    /**
+     * Load persisted task state from disk
+     */
+    loadState(): Promise<void>;
+    /**
+     * Save current task state to disk
+     */
+    saveState(): Promise<void>;
+    /**
+     * Force save state immediately
+     */
+    forceSave(): Promise<void>;
+    /**
+     * Get all tasks across all sessions with optional filtering
+     */
+    getAllTasks(filter?: TaskFilter): TrackedSubagent[];
+    /**
+     * Get tasks that can be resumed
+     */
+    getResumableTasks(): TrackedSubagent[];
+    /**
+     * Get a task by ID
+     */
+    getTask(taskId: string): TrackedSubagent | undefined;
+    /**
+     * Get a task by agent ID (for resume operations)
+     */
+    getTaskByAgentId(agentId: string): TrackedSubagent | undefined;
+    /**
+     * Read output file content for a background task
+     */
+    getTaskOutput(taskId: string): Promise<string | null>;
+    /**
+     * Read last N lines of output file for a background task
+     */
+    getTaskOutputTail(taskId: string, lines: number): Promise<string | null>;
+    /**
+     * Cancel a running task
+     */
+    cancelTask(taskId: string): Promise<boolean>;
+    /**
+     * Get statistics about all tasks
+     */
+    getStats(): import("./subagent-tracker.js").SubagentStats;
+    /**
+     * Get the underlying tracker
+     */
+    getTracker(): SubagentTracker;
+    /**
+     * Clean up old completed tasks
+     */
+    cleanup(): Promise<number>;
+    /**
+     * Dispose of the task manager
+     */
+    dispose(): void;
+    private setupEventListeners;
+    private startAutoSave;
+}
+export type { SerializedTrackerState } from "./subagent-tracker.js";
+//# sourceMappingURL=task-manager.d.ts.map

package/dist/task-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-manager.d.ts","sourceRoot":"","sources":["../src/task-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,eAAe,EACf,cAAc,EAEf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAKxC,MAAM,WAAW,kBAAkB;IACjC,0EAA0E;IAC1E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yEAAyE;IACzE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,UAAU;IACzB,4BAA4B;IAC5B,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC;IAC1B,2BAA2B;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,8BAA8B;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mDAAmD;IACnD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,gBAAgB,CAAC,CAAiB;IAC1C,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,OAAO,CAAkB;gBAErB,OAAO,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,kBAAkB;IAgBlE;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAyChC;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAwBhC;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAKhC;;OAEG;IACH,WAAW,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,eAAe,EAAE;IA0BnD;;OAEG;IACH,iBAAiB,IAAI,eAAe,EAAE;IAItC;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAIpD;;OAEG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI9D;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAiB3D;;OAEG;IACG,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAU9E;;OAEG;IACG,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAYlD;;OAEG;IACH,QAAQ;IAIR;;OAEG;IACH,UAAU,IAAI,eAAe;IAI7B;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAShC;;OAEG;IACH,OAAO,IAAI,IAAI;IAYf,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,aAAa;CAYtB;AAGD,YAAY,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/task-manager.js

@@ -0,0 +1,231 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+/**
+ * TaskManager handles cross-session task persistence and management.
+ *
+ * It wraps SubagentTracker and provides:
+ * - Persistence to disk for background tasks
+ * - Cross-session task querying
+ * - Resume capability tracking
+ * - Task output file reading
+ */
+export class TaskManager {
+    constructor(tracker, options) {
+        this.isDirty = false;
+        this.tracker = tracker;
+        this.persistencePath =
+            options?.persistencePath ??
+                path.join(os.homedir(), ".claude", "acp-task-state.json");
+        this.logger = options?.logger ?? console;
+        this.maxTaskAgeMs = options?.maxTaskAgeMs ?? 24 * 60 * 60 * 1000; // 24 hours
+        // Set up event listeners to mark state as dirty
+        this.setupEventListeners();
+        if (options?.autoSave !== false) {
+            this.startAutoSave(options?.autoSaveIntervalMs ?? 30000);
+        }
+    }
+    /**
+     * Load persisted task state from disk
+     */
+    async loadState() {
+        try {
+            if (fs.existsSync(this.persistencePath)) {
+                const content = await fs.promises.readFile(this.persistencePath, "utf-8");
+                const state = JSON.parse(content);
+                // Validate state version
+                if (state.version !== 1) {
+                    this.logger.error(`[TaskManager] Unknown state version: ${state.version}, skipping load`);
+                    return;
+                }
+                // Filter out tasks older than maxTaskAgeMs
+                const cutoff = Date.now() - this.maxTaskAgeMs;
+                const filteredTasks = state.tasks.filter((task) => task.createdAt > cutoff || task.status === "running");
+                if (filteredTasks.length !== state.tasks.length) {
+                    this.logger.log(`[TaskManager] Filtered out ${state.tasks.length - filteredTasks.length} old tasks`);
+                }
+                // Import filtered state
+                this.tracker.importState({
+                    ...state,
+                    tasks: filteredTasks,
+                });
+                this.logger.log(`[TaskManager] Loaded ${filteredTasks.length} tasks from persistence`);
+            }
+        }
+        catch (error) {
+            this.logger.error("[TaskManager] Failed to load persisted state:", error);
+        }
+    }
+    /**
+     * Save current task state to disk
+     */
+    async saveState() {
+        if (!this.isDirty) {
+            return; // No changes to save
+        }
+        try {
+            const state = this.tracker.exportState();
+            // Ensure directory exists
+            const dir = path.dirname(this.persistencePath);
+            await fs.promises.mkdir(dir, { recursive: true });
+            // Write atomically using temp file
+            const tempPath = `${this.persistencePath}.tmp`;
+            await fs.promises.writeFile(tempPath, JSON.stringify(state, null, 2), "utf-8");
+            await fs.promises.rename(tempPath, this.persistencePath);
+            this.isDirty = false;
+            this.logger.log(`[TaskManager] Saved ${state.tasks.length} tasks to persistence`);
+        }
+        catch (error) {
+            this.logger.error("[TaskManager] Failed to save state:", error);
+        }
+    }
+    /**
+     * Force save state immediately
+     */
+    async forceSave() {
+        this.isDirty = true;
+        await this.saveState();
+    }
+    /**
+     * Get all tasks across all sessions with optional filtering
+     */
+    getAllTasks(filter) {
+        let tasks = this.tracker.getAllSubagents();
+        if (filter?.status) {
+            tasks = tasks.filter((t) => filter.status.includes(t.status));
+        }
+        if (filter?.sessionId) {
+            tasks = tasks.filter((t) => t.parentSessionId === filter.sessionId);
+        }
+        if (filter?.runInBackground !== undefined) {
+            tasks = tasks.filter((t) => t.runInBackground === filter.runInBackground);
+        }
+        if (filter?.subagentType) {
+            tasks = tasks.filter((t) => t.subagentType === filter.subagentType);
+        }
+        if (filter?.newerThan !== undefined) {
+            tasks = tasks.filter((t) => t.createdAt > filter.newerThan);
+        }
+        if (filter?.olderThan !== undefined) {
+            tasks = tasks.filter((t) => t.createdAt < filter.olderThan);
+        }
+        // Sort by creation time, newest first
+        return tasks.sort((a, b) => b.createdAt - a.createdAt);
+    }
+    /**
+     * Get tasks that can be resumed
+     */
+    getResumableTasks() {
+        return this.tracker.getResumableTasks();
+    }
+    /**
+     * Get a task by ID
+     */
+    getTask(taskId) {
+        return this.tracker.getSubagent(taskId);
+    }
+    /**
+     * Get a task by agent ID (for resume operations)
+     */
+    getTaskByAgentId(agentId) {
+        return this.tracker.findByAgentId(agentId);
+    }
+    /**
+     * Read output file content for a background task
+     */
+    async getTaskOutput(taskId) {
+        const task = this.tracker.getSubagent(taskId);
+        if (!task?.outputFile) {
+            return null;
+        }
+        try {
+            return await fs.promises.readFile(task.outputFile, "utf-8");
+        }
+        catch (error) {
+            this.logger.error(`[TaskManager] Failed to read output file for task ${taskId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Read last N lines of output file for a background task
+     */
+    async getTaskOutputTail(taskId, lines) {
+        const content = await this.getTaskOutput(taskId);
+        if (content === null) {
+            return null;
+        }
+        const allLines = content.split("\n");
+        return allLines.slice(-lines).join("\n");
+    }
+    /**
+     * Cancel a running task
+     */
+    async cancelTask(taskId) {
+        const task = this.tracker.getSubagent(taskId);
+        if (!task || task.status !== "running") {
+            return false;
+        }
+        await this.tracker.cancelSubagent(taskId);
+        this.isDirty = true;
+        await this.saveState();
+        return true;
+    }
+    /**
+     * Get statistics about all tasks
+     */
+    getStats() {
+        return this.tracker.getStats();
+    }
+    /**
+     * Get the underlying tracker
+     */
+    getTracker() {
+        return this.tracker;
+    }
+    /**
+     * Clean up old completed tasks
+     */
+    async cleanup() {
+        const cleaned = this.tracker.cleanup(this.maxTaskAgeMs);
+        if (cleaned > 0) {
+            this.isDirty = true;
+            await this.saveState();
+        }
+        return cleaned;
+    }
+    /**
+     * Dispose of the task manager
+     */
+    dispose() {
+        if (this.autoSaveInterval) {
+            clearInterval(this.autoSaveInterval);
+            this.autoSaveInterval = undefined;
+        }
+        // Final save on dispose
+        this.saveState().catch((error) => {
+            this.logger.error("[TaskManager] Failed to save on dispose:", error);
+        });
+    }
+    setupEventListeners() {
+        // Mark state as dirty when subagent events occur
+        const markDirty = () => {
+            this.isDirty = true;
+        };
+        this.tracker.addEventListener("subagent_started", markDirty);
+        this.tracker.addEventListener("subagent_completed", markDirty);
+        this.tracker.addEventListener("subagent_failed", markDirty);
+        this.tracker.addEventListener("subagent_cancelled", markDirty);
+        this.tracker.addEventListener("subagent_stopped", markDirty);
+    }
+    startAutoSave(intervalMs) {
+        this.autoSaveInterval = setInterval(() => {
+            this.saveState().catch((error) => {
+                this.logger.error("[TaskManager] Auto-save failed:", error);
+            });
+        }, intervalMs);
+        // Don't prevent process exit
+        if (this.autoSaveInterval.unref) {
+            this.autoSaveInterval.unref();
+        }
+    }
+}

package/dist/task-mcp-tools.d.ts

@@ -0,0 +1,16 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { TaskManager } from "./task-manager.js";
+import { SubagentTracker } from "./subagent-tracker.js";
+export interface TaskMcpToolsOptions {
+    /** The SubagentTracker instance */
+    tracker: SubagentTracker;
+    /** Optional TaskManager for persistence features */
+    taskManager?: TaskManager;
+    /** Session ID for context */
+    sessionId: string;
+}
+/**
+ * Register MCP tools for task management
+ */
+export declare function registerTaskMcpTools(server: McpServer, options: TaskMcpToolsOptions): void;
+//# sourceMappingURL=task-mcp-tools.d.ts.map

package/dist/task-mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-mcp-tools.d.ts","sourceRoot":"","sources":["../src/task-mcp-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAkB,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExE,MAAM,WAAW,mBAAmB;IAClC,mCAAmC;IACnC,OAAO,EAAE,eAAe,CAAC;IACzB,oDAAoD;IACpD,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,6BAA6B;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,mBAAmB,GAC3B,IAAI,CA0RN"}