@siftd/connect-agent 0.2.38 → 0.2.39

package/dist/core/task-queue.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Lia's Internal Task Queue
+ *
+ * This manages Lia's own todo list - separate from user /todos.
+ * Allows async message processing where users can keep sending
+ * while Lia works through her queue.
+ */
+export type TaskPriority = 'urgent' | 'high' | 'normal' | 'low';
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+export interface LiaTask {
+    id: string;
+    type: 'user_message' | 'follow_up' | 'scheduled' | 'background';
+    content: string;
+    priority: TaskPriority;
+    status: TaskStatus;
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    result?: string;
+    error?: string;
+    metadata?: {
+        userId?: string;
+        messageId?: string;
+        parentTaskId?: string;
+        apiKey?: string;
+        context?: 'personal' | 'team';
+        orgId?: string;
+    };
+}
+export interface LiaPlan {
+    id: string;
+    goal: string;
+    steps: LiaPlanStep[];
+    status: 'planning' | 'executing' | 'completed' | 'failed';
+    createdAt: Date;
+    completedAt?: Date;
+}
+export interface LiaPlanStep {
+    id: string;
+    description: string;
+    status: TaskStatus;
+    taskId?: string;
+    notes?: string;
+}
+export type TaskQueueCallback = (task: LiaTask) => void;
+export type PlanCallback = (plan: LiaPlan) => void;
+/**
+ * Lia's task queue - manages her internal todo list
+ */
+export declare class LiaTaskQueue {
+    private tasks;
+    private plans;
+    private queue;
+    private currentTask;
+    private isProcessing;
+    private onTaskUpdate?;
+    private onPlanUpdate?;
+    private processTask?;
+    constructor(options?: {
+        onTaskUpdate?: TaskQueueCallback;
+        onPlanUpdate?: PlanCallback;
+        processTask?: (task: LiaTask) => Promise<string>;
+    });
+    /**
+     * Add a new task to the queue
+     */
+    addTask(task: Omit<LiaTask, 'id' | 'status' | 'createdAt'>): LiaTask;
+    /**
+     * Insert task ID into queue based on priority
+     */
+    private insertByPriority;
+    /**
+     * Start processing the queue
+     */
+    startProcessing(): Promise<void>;
+    /**
+     * Get the current task being processed
+     */
+    getCurrentTask(): LiaTask | null;
+    /**
+     * Get all pending tasks
+     */
+    getPendingTasks(): LiaTask[];
+    /**
+     * Get recent tasks (last N)
+     */
+    getRecentTasks(limit?: number): LiaTask[];
+    /**
+     * Get task by ID
+     */
+    getTask(taskId: string): LiaTask | null;
+    /**
+     * Cancel a pending task
+     */
+    cancelTask(taskId: string): boolean;
+    /**
+     * Create a plan (breaks down a goal into steps)
+     */
+    createPlan(goal: string, steps: string[]): LiaPlan;
+    /**
+     * Update a plan step
+     */
+    updatePlanStep(planId: string, stepId: string, update: Partial<LiaPlanStep>): boolean;
+    /**
+     * Get current plan
+     */
+    getCurrentPlan(): LiaPlan | null;
+    /**
+     * Get all plans
+     */
+    getPlans(): LiaPlan[];
+    /**
+     * Get queue status for display
+     */
+    getStatus(): {
+        isProcessing: boolean;
+        currentTask: LiaTask | null;
+        pendingCount: number;
+        queuePreview: string[];
+    };
+    /**
+     * Format tasks as readable todo list (for LLM context)
+     */
+    formatAsTodoList(): string;
+}

package/dist/core/task-queue.js

@@ -0,0 +1,248 @@
+/**
+ * Lia's Internal Task Queue
+ *
+ * This manages Lia's own todo list - separate from user /todos.
+ * Allows async message processing where users can keep sending
+ * while Lia works through her queue.
+ */
+/**
+ * Lia's task queue - manages her internal todo list
+ */
+export class LiaTaskQueue {
+    tasks = new Map();
+    plans = new Map();
+    queue = []; // Task IDs in priority order
+    currentTask = null;
+    isProcessing = false;
+    // Callbacks for real-time updates
+    onTaskUpdate;
+    onPlanUpdate;
+    processTask;
+    constructor(options) {
+        this.onTaskUpdate = options?.onTaskUpdate;
+        this.onPlanUpdate = options?.onPlanUpdate;
+        this.processTask = options?.processTask;
+    }
+    /**
+     * Add a new task to the queue
+     */
+    addTask(task) {
+        const newTask = {
+            ...task,
+            id: `task_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            status: 'pending',
+            createdAt: new Date(),
+        };
+        this.tasks.set(newTask.id, newTask);
+        this.insertByPriority(newTask.id, newTask.priority);
+        this.onTaskUpdate?.(newTask);
+        // Auto-start processing if not already running
+        if (!this.isProcessing) {
+            this.startProcessing();
+        }
+        return newTask;
+    }
+    /**
+     * Insert task ID into queue based on priority
+     */
+    insertByPriority(taskId, priority) {
+        const priorityOrder = {
+            urgent: 0,
+            high: 1,
+            normal: 2,
+            low: 3,
+        };
+        const taskPriority = priorityOrder[priority];
+        let insertIndex = this.queue.length;
+        for (let i = 0; i < this.queue.length; i++) {
+            const existingTask = this.tasks.get(this.queue[i]);
+            if (existingTask && priorityOrder[existingTask.priority] > taskPriority) {
+                insertIndex = i;
+                break;
+            }
+        }
+        this.queue.splice(insertIndex, 0, taskId);
+    }
+    /**
+     * Start processing the queue
+     */
+    async startProcessing() {
+        if (this.isProcessing)
+            return;
+        this.isProcessing = true;
+        while (this.queue.length > 0) {
+            const taskId = this.queue.shift();
+            if (!taskId)
+                continue;
+            const task = this.tasks.get(taskId);
+            if (!task || task.status === 'cancelled')
+                continue;
+            this.currentTask = taskId;
+            task.status = 'in_progress';
+            task.startedAt = new Date();
+            this.onTaskUpdate?.(task);
+            try {
+                if (this.processTask) {
+                    const result = await this.processTask(task);
+                    task.result = result;
+                    task.status = 'completed';
+                }
+                else {
+                    task.status = 'failed';
+                    task.error = 'No task processor configured';
+                }
+            }
+            catch (error) {
+                task.status = 'failed';
+                task.error = error instanceof Error ? error.message : String(error);
+            }
+            task.completedAt = new Date();
+            this.currentTask = null;
+            this.onTaskUpdate?.(task);
+        }
+        this.isProcessing = false;
+    }
+    /**
+     * Get the current task being processed
+     */
+    getCurrentTask() {
+        return this.currentTask ? this.tasks.get(this.currentTask) || null : null;
+    }
+    /**
+     * Get all pending tasks
+     */
+    getPendingTasks() {
+        return this.queue
+            .map(id => this.tasks.get(id))
+            .filter((t) => t !== undefined && t.status === 'pending');
+    }
+    /**
+     * Get recent tasks (last N)
+     */
+    getRecentTasks(limit = 10) {
+        return Array.from(this.tasks.values())
+            .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
+            .slice(0, limit);
+    }
+    /**
+     * Get task by ID
+     */
+    getTask(taskId) {
+        return this.tasks.get(taskId) || null;
+    }
+    /**
+     * Cancel a pending task
+     */
+    cancelTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task || task.status !== 'pending')
+            return false;
+        task.status = 'cancelled';
+        this.queue = this.queue.filter(id => id !== taskId);
+        this.onTaskUpdate?.(task);
+        return true;
+    }
+    /**
+     * Create a plan (breaks down a goal into steps)
+     */
+    createPlan(goal, steps) {
+        const plan = {
+            id: `plan_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            goal,
+            steps: steps.map((desc, i) => ({
+                id: `step_${i + 1}`,
+                description: desc,
+                status: 'pending',
+            })),
+            status: 'planning',
+            createdAt: new Date(),
+        };
+        this.plans.set(plan.id, plan);
+        this.onPlanUpdate?.(plan);
+        return plan;
+    }
+    /**
+     * Update a plan step
+     */
+    updatePlanStep(planId, stepId, update) {
+        const plan = this.plans.get(planId);
+        if (!plan)
+            return false;
+        const step = plan.steps.find(s => s.id === stepId);
+        if (!step)
+            return false;
+        Object.assign(step, update);
+        // Update plan status based on steps
+        const allCompleted = plan.steps.every(s => s.status === 'completed');
+        const anyFailed = plan.steps.some(s => s.status === 'failed');
+        const anyInProgress = plan.steps.some(s => s.status === 'in_progress');
+        if (allCompleted) {
+            plan.status = 'completed';
+            plan.completedAt = new Date();
+        }
+        else if (anyFailed) {
+            plan.status = 'failed';
+        }
+        else if (anyInProgress) {
+            plan.status = 'executing';
+        }
+        this.onPlanUpdate?.(plan);
+        return true;
+    }
+    /**
+     * Get current plan
+     */
+    getCurrentPlan() {
+        return Array.from(this.plans.values())
+            .find(p => p.status === 'planning' || p.status === 'executing') || null;
+    }
+    /**
+     * Get all plans
+     */
+    getPlans() {
+        return Array.from(this.plans.values());
+    }
+    /**
+     * Get queue status for display
+     */
+    getStatus() {
+        const pending = this.getPendingTasks();
+        return {
+            isProcessing: this.isProcessing,
+            currentTask: this.getCurrentTask(),
+            pendingCount: pending.length,
+            queuePreview: pending.slice(0, 5).map(t => t.content.length > 50 ? t.content.slice(0, 50) + '...' : t.content),
+        };
+    }
+    /**
+     * Format tasks as readable todo list (for LLM context)
+     */
+    formatAsTodoList() {
+        const current = this.getCurrentTask();
+        const pending = this.getPendingTasks();
+        const recent = this.getRecentTasks(5).filter(t => t.status === 'completed' || t.status === 'failed');
+        const lines = ['## My Task Queue'];
+        if (current) {
+            lines.push('', '### Currently Working On:');
+            lines.push(`- [→] ${current.content}`);
+        }
+        if (pending.length > 0) {
+            lines.push('', '### Pending:');
+            for (const task of pending.slice(0, 10)) {
+                const priority = task.priority !== 'normal' ? ` [${task.priority}]` : '';
+                lines.push(`- [ ] ${task.content}${priority}`);
+            }
+            if (pending.length > 10) {
+                lines.push(`- ... and ${pending.length - 10} more`);
+            }
+        }
+        if (recent.length > 0) {
+            lines.push('', '### Recently Completed:');
+            for (const task of recent) {
+                const icon = task.status === 'completed' ? '✓' : '✗';
+                lines.push(`- [${icon}] ${task.content}`);
+            }
+        }
+        return lines.join('\n');
+    }
+}

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './config.js';
 export * from './api.js';
 export * from './agent.js';
 export * from './websocket.js';
+export * from './core/task-queue.js';

package/dist/index.js

@@ -2,3 +2,4 @@ export * from './config.js';
 export * from './api.js';
 export * from './agent.js';
 export * from './websocket.js';
+export * from './core/task-queue.js';

package/dist/orchestrator.d.ts

@@ -5,6 +5,7 @@
  * It does NOT do the work itself. Claude Code CLI workers do the work.
  */
 import type { MessageParam } from '@anthropic-ai/sdk/resources/messages';
+import { LiaTask, LiaPlan } from './core/task-queue.js';
 export type MessageSender = (message: string) => Promise<void>;
 export interface WorkerStatus {
     id: string;
@@ -67,6 +68,9 @@ export declare class MasterOrchestrator {
     private calendarTools;
     private sharedState;
     private verboseMode;
+    private taskQueue;
+    private taskUpdateCallback?;
+    private planUpdateCallback?;
     constructor(options: {
         apiKey: string;
         userId: string;
@@ -95,6 +99,52 @@ export declare class MasterOrchestrator {
      * Set callback for gallery updates (worker assets for UI gallery view)
      */
     setGalleryCallback(callback: GalleryCallback | null): void;
+    /**
+     * Set callback for task queue updates (for real-time UI updates)
+     */
+    setTaskUpdateCallback(callback: ((task: LiaTask) => void) | null): void;
+    /**
+     * Set callback for plan updates (for real-time UI updates)
+     */
+    setPlanUpdateCallback(callback: ((plan: LiaPlan) => void) | null): void;
+    /**
+     * Queue a message for async processing (non-blocking)
+     * Returns immediately with task ID - use callbacks or getTaskQueueStatus for results
+     */
+    queueMessage(message: string, options?: {
+        priority?: 'urgent' | 'high' | 'normal' | 'low';
+        apiKey?: string;
+        messageId?: string;
+    }): LiaTask;
+    /**
+     * Process a task from the queue (called by LiaTaskQueue)
+     */
+    private processQueuedTask;
+    /**
+     * Get task queue status (for UI)
+     */
+    getTaskQueueStatus(): {
+        isProcessing: boolean;
+        currentTask: LiaTask | null;
+        pendingCount: number;
+        queuePreview: string[];
+    };
+    /**
+     * Get pending tasks
+     */
+    getPendingTasks(): LiaTask[];
+    /**
+     * Get task by ID
+     */
+    getTask(taskId: string): LiaTask | null;
+    /**
+     * Cancel a pending task
+     */
+    cancelTask(taskId: string): boolean;
+    /**
+     * Get Lia's internal todo list formatted for context
+     */
+    getTaskQueueContext(): string;
     /**
      * Get gallery workers with their assets
      */
@@ -238,6 +288,18 @@ export declare class MasterOrchestrator {
      * Stop a running server on a port
      */
     private executeStopServer;
+    /**
+     * Create a plan with steps (Lia's internal planning)
+     */
+    private executeLiaPlan;
+    /**
+     * Add a task to Lia's internal queue
+     */
+    private executeLiaAddTask;
+    /**
+     * Get Lia's task queue status
+     */
+    private executeLiaGetQueue;
     /**
      * Format tool preview for user
      */

package/dist/orchestrator.js

@@ -20,6 +20,7 @@ import { SharedState } from './workers/shared-state.js';
 import { getKnowledgeForPrompt } from './genesis/index.js';
 import { loadHubContext, formatHubContext, logAction, logWorker } from './core/hub.js';
 import { buildWorkerPrompt } from './prompts/worker-system.js';
+import { LiaTaskQueue } from './core/task-queue.js';
 /**
  * Extract file paths from worker output
  * Workers naturally mention files they create: "Created /tmp/foo.html", "Saved to /path/file"
@@ -74,6 +75,14 @@ YOUR IDENTITY:
 HOW YOU WORK:
 You are the orchestrator, not the executor. You coordinate and remember while workers do the hands-on work.
 
+TASK QUEUE (Always-Listening):
+You have an internal task queue. Users can keep sending messages while you work - you're interruptible.
+- Use lia_plan to break down complex goals into steps
+- Use lia_add_task to queue follow-up work or new requests that come in
+- Use lia_get_queue to see what's pending
+- When you receive multiple requests, acknowledge them and queue them: "Got it, adding to my queue..."
+- You can work on one task while others wait - always stay responsive
+
 TOOL RULES:
 
 ✅ bash - READ-ONLY operations only:
@@ -179,6 +188,10 @@ export class MasterOrchestrator {
     calendarTools;
     sharedState;
     verboseMode = new Map(); // per-user verbose mode
+    // Lia's internal task queue - allows async message processing
+    taskQueue;
+    taskUpdateCallback;
+    planUpdateCallback;
     constructor(options) {
         this.client = new Anthropic({ apiKey: options.apiKey });
         this.model = options.model || 'claude-sonnet-4-20250514';
@@ -261,6 +274,12 @@ export class MasterOrchestrator {
                 this.workerLogCallback(workerId, line, stream);
             }
         });
+        // Initialize Lia's internal task queue
+        this.taskQueue = new LiaTaskQueue({
+            onTaskUpdate: (task) => this.taskUpdateCallback?.(task),
+            onPlanUpdate: (plan) => this.planUpdateCallback?.(plan),
+            processTask: async (task) => this.processQueuedTask(task),
+        });
     }
     /**
      * Initialize the orchestrator - indexes filesystem on first call
@@ -318,6 +337,75 @@ export class MasterOrchestrator {
             this.broadcastGalleryUpdate();
         } : null);
     }
+    /**
+     * Set callback for task queue updates (for real-time UI updates)
+     */
+    setTaskUpdateCallback(callback) {
+        this.taskUpdateCallback = callback || undefined;
+    }
+    /**
+     * Set callback for plan updates (for real-time UI updates)
+     */
+    setPlanUpdateCallback(callback) {
+        this.planUpdateCallback = callback || undefined;
+    }
+    /**
+     * Queue a message for async processing (non-blocking)
+     * Returns immediately with task ID - use callbacks or getTaskQueueStatus for results
+     */
+    queueMessage(message, options) {
+        return this.taskQueue.addTask({
+            type: 'user_message',
+            content: message,
+            priority: options?.priority || 'normal',
+            metadata: {
+                userId: this.userId,
+                messageId: options?.messageId,
+                apiKey: options?.apiKey,
+                context: this.instanceMode,
+                orgId: this.orgId,
+            },
+        });
+    }
+    /**
+     * Process a task from the queue (called by LiaTaskQueue)
+     */
+    async processQueuedTask(task) {
+        // This is where the actual work happens
+        return this.processMessage(task.content, [], // Fresh conversation for each task
+        undefined, // No sendMessage callback for queued tasks
+        task.metadata?.apiKey);
+    }
+    /**
+     * Get task queue status (for UI)
+     */
+    getTaskQueueStatus() {
+        return this.taskQueue.getStatus();
+    }
+    /**
+     * Get pending tasks
+     */
+    getPendingTasks() {
+        return this.taskQueue.getPendingTasks();
+    }
+    /**
+     * Get task by ID
+     */
+    getTask(taskId) {
+        return this.taskQueue.getTask(taskId);
+    }
+    /**
+     * Cancel a pending task
+     */
+    cancelTask(taskId) {
+        return this.taskQueue.cancelTask(taskId);
+    }
+    /**
+     * Get Lia's internal todo list formatted for context
+     */
+    getTaskQueueContext() {
+        return this.taskQueue.formatAsTodoList();
+    }
     /**
      * Get gallery workers with their assets
      */
@@ -1540,6 +1628,54 @@ Be specific about what you want done.`,
                     },
                     required: ['port']
                 }
+            },
+            // Lia's internal task management tools
+            {
+                name: 'lia_plan',
+                description: `Create a plan to break down a complex goal into steps. Use this when you receive multiple requests or need to organize work. The plan becomes your internal todo list.`,
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        goal: {
+                            type: 'string',
+                            description: 'The overall goal you are trying to accomplish'
+                        },
+                        steps: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'List of steps to accomplish the goal'
+                        }
+                    },
+                    required: ['goal', 'steps']
+                }
+            },
+            {
+                name: 'lia_add_task',
+                description: `Add a task to your internal queue. Use when the user sends a new request while you are busy, or when you identify follow-up work. Tasks are processed in priority order.`,
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        task: {
+                            type: 'string',
+                            description: 'The task description'
+                        },
+                        priority: {
+                            type: 'string',
+                            enum: ['urgent', 'high', 'normal', 'low'],
+                            description: 'Task priority (default: normal)'
+                        }
+                    },
+                    required: ['task']
+                }
+            },
+            {
+                name: 'lia_get_queue',
+                description: 'Get your current task queue status. Shows what you are working on and what is pending.',
+                input_schema: {
+                    type: 'object',
+                    properties: {},
+                    required: []
+                }
             }
         ];
     }
@@ -1683,6 +1819,16 @@ Be specific about what you want done.`,
                 case 'stop_local_server':
                     result = await this.executeStopServer(input.port);
                     break;
+                // Lia's internal task management tools
+                case 'lia_plan':
+                    result = this.executeLiaPlan(input.goal, input.steps);
+                    break;
+                case 'lia_add_task':
+                    result = this.executeLiaAddTask(input.task, input.priority);
+                    break;
+                case 'lia_get_queue':
+                    result = this.executeLiaGetQueue();
+                    break;
                 default:
                     result = { success: false, output: `Unknown tool: ${toolUse.name}` };
             }
@@ -2186,6 +2332,66 @@ Be specific about what you want done.`,
             return { success: false, output: `No server running on port ${port}` };
         }
     }
+    /**
+     * Create a plan with steps (Lia's internal planning)
+     */
+    executeLiaPlan(goal, steps) {
+        try {
+            const plan = this.taskQueue.createPlan(goal, steps);
+            console.log(`[ORCHESTRATOR] Created plan: ${plan.id} with ${steps.length} steps`);
+            const stepsFormatted = steps.map((s, i) => `${i + 1}. ${s}`).join('\n');
+            return {
+                success: true,
+                output: `Created plan "${goal}" with ${steps.length} steps:\n${stepsFormatted}\n\nPlan ID: ${plan.id}`
+            };
+        }
+        catch (error) {
+            return { success: false, output: `Failed to create plan: ${error}` };
+        }
+    }
+    /**
+     * Add a task to Lia's internal queue
+     */
+    executeLiaAddTask(task, priority) {
+        try {
+            const newTask = this.taskQueue.addTask({
+                type: 'follow_up',
+                content: task,
+                priority: priority || 'normal',
+                metadata: {
+                    userId: this.userId,
+                    context: this.instanceMode,
+                    orgId: this.orgId,
+                },
+            });
+            console.log(`[ORCHESTRATOR] Added task to queue: ${newTask.id}`);
+            const status = this.taskQueue.getStatus();
+            return {
+                success: true,
+                output: `Added to my queue: "${task}" (priority: ${priority || 'normal'}). ${status.pendingCount} tasks pending.`
+            };
+        }
+        catch (error) {
+            return { success: false, output: `Failed to add task: ${error}` };
+        }
+    }
+    /**
+     * Get Lia's task queue status
+     */
+    executeLiaGetQueue() {
+        try {
+            const status = this.taskQueue.getStatus();
+            const todoList = this.taskQueue.formatAsTodoList();
+            let output = todoList;
+            if (!status.isProcessing && status.pendingCount === 0) {
+                output = 'My queue is empty - ready for new tasks.';
+            }
+            return { success: true, output };
+        }
+        catch (error) {
+            return { success: false, output: `Failed to get queue: ${error}` };
+        }
+    }
     /**
      * Format tool preview for user
      */
@@ -2235,6 +2441,12 @@ Be specific about what you want done.`,
                 return `Starting server on port ${input.port || 8080}...`;
             case 'stop_local_server':
                 return `Stopping server on port ${input.port}...`;
+            case 'lia_plan':
+                return `Planning: ${input.goal}`;
+            case 'lia_add_task':
+                return `Queuing task: ${input.task.slice(0, 50)}...`;
+            case 'lia_get_queue':
+                return 'Checking my task queue...';
             default:
                 return null;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siftd/connect-agent",
-  "version": "0.2.38",
+  "version": "0.2.39",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",