@siftd/connect-agent 0.2.38 → 0.2.40

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,21 @@ YOUR IDENTITY:
 HOW YOU WORK:
 You are the orchestrator, not the executor. You coordinate and remember while workers do the hands-on work.
 
+CRITICAL - DATE AWARENESS:
+ALWAYS run \`date\` via bash FIRST before referencing ANY temporal context from memory.
+- Before mentioning meetings, deadlines, or scheduled items: check today's date
+- Cross-reference memory timestamps with current date
+- Only surface RELEVANT, CURRENT information - never reference past events as if they're upcoming
+- A personal assistant that gives outdated information is worse than useless - it's actively misleading
+
+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:
@@ -141,6 +157,23 @@ CALENDAR + TODO (Lia-managed data):
   - calendar.json: { "version": 1, "calendars": [...], "events": [...] }
   - todos.json: { "version": 1, "items": [...] }
 
+COMPLEX TODO/CALENDAR OPERATIONS:
+When users ask to "break down", "split", or "parse" a todo item:
+1. READ THE NOTES FIELD - the TODO SNAPSHOT includes notes with full content
+2. Parse the notes into distinct actionable items (grants, meetings, tasks, etc.)
+3. Call todo_upsert_items with MULTIPLE new items extracted from the notes
+4. Mark the original item as done: true OR delete by not including it in upsert
+5. Each new item should have: id (unique), title, priority, notes (if details needed), due (if deadline mentioned)
+
+Example: If a todo has notes listing "NIH R01 deadline Jan 25, AASLD pilot Feb, ADA Mar":
+→ Create 3 separate todos: one for NIH R01 (due: 2026-01-25), one for AASLD, one for ADA
+→ Extract deadlines, descriptions, requirements from the original notes
+
+When users reference a todo by number (e.g., "#3", "item 3", "the third one"):
+- Match it to the items in the TODO SNAPSHOT (which is ordered)
+- READ its notes field carefully - that's where the real content lives
+- Don't guess what it contains - the snapshot shows you exactly what's there
+
 WORKFLOW:
 Before complex work: Check CLAUDE.md → Read LANDMARKS.md → Search memory
 After completing work: Update LANDMARKS.md → Remember learnings
@@ -179,9 +212,16 @@ export class MasterOrchestrator {
     calendarTools;
     sharedState;
     verboseMode = new Map(); // per-user verbose mode
+    // Lia's internal task queue - allows async message processing
+    taskQueue;
+    taskUpdateCallback;
+    planUpdateCallback;
+    // Lia's visible todo list (displayed inline in chat)
+    currentTodos = [];
+    todoUpdateCallback;
     constructor(options) {
         this.client = new Anthropic({ apiKey: options.apiKey });
-        this.model = options.model || 'claude-sonnet-4-20250514';
+        this.model = options.model || process.env.ANTHROPIC_MODEL || 'claude-sonnet-4-20250514';
         this.maxTokens = options.maxTokens || 4096;
         this.userId = options.userId;
         this.orgId = options.orgId;
@@ -261,6 +301,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 +364,80 @@ 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;
+    }
+    /**
+     * Set callback for visible todo list updates (displayed inline in chat)
+     */
+    setTodoUpdateCallback(callback) {
+        this.todoUpdateCallback = 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,
+                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
+        );
+    }
+    /**
+     * 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
      */
@@ -429,6 +549,22 @@ export class MasterOrchestrator {
         if (hasRunning || workers.length > 0) {
             this.workerStatusCallback(workers);
         }
+        // Update linked todos with worker progress
+        if (this.currentTodos.length > 0 && this.todoUpdateCallback) {
+            let todoUpdated = false;
+            for (const todo of this.currentTodos) {
+                if (todo.workerId && todo.status === 'in_progress') {
+                    const worker = workers.find(w => w.id === todo.workerId);
+                    if (worker && todo.progress !== worker.progress) {
+                        todo.progress = worker.progress;
+                        todoUpdated = true;
+                    }
+                }
+            }
+            if (todoUpdated) {
+                this.todoUpdateCallback(this.currentTodos);
+            }
+        }
         // Clean up completed jobs after 3 seconds
         const now = Date.now();
         for (const [id, job] of this.jobs) {
@@ -548,9 +684,8 @@ export class MasterOrchestrator {
     }
     /**
      * Process a user message
-     * @param apiKey Optional per-request API key (overrides default)
      */
-    async processMessage(message, conversationHistory = [], sendMessage, apiKey) {
+    async processMessage(message, conversationHistory = [], sendMessage) {
         // Handle slash commands first
         const slashResponse = this.handleSlashCommand(message);
         if (slashResponse) {
@@ -598,7 +733,7 @@ ${hubContextStr}
             { role: 'user', content: message }
         ];
         try {
-            const response = await this.runAgentLoop(messages, systemWithContext, sendMessage, apiKey);
+            const response = await this.runAgentLoop(messages, systemWithContext, sendMessage);
             // Auto-remember important things from the conversation
             await this.autoRemember(message, response);
             void this.autoCaptureContext(message);
@@ -999,22 +1134,19 @@ ${hubContextStr}
     }
     /**
      * Run the agentic loop
-     * @param apiKey Optional per-request API key (creates temporary client)
      */
-    async runAgentLoop(messages, system, sendMessage, apiKey) {
+    async runAgentLoop(messages, system, sendMessage) {
         const tools = this.getToolDefinitions();
         let currentMessages = [...messages];
         let iterations = 0;
         const maxIterations = 30; // Increased for complex multi-tool tasks
         const requestTimeoutMs = 60000;
-        // Use per-request client if apiKey provided, otherwise use default
-        const client = apiKey ? new Anthropic({ apiKey }) : this.client;
         while (iterations < maxIterations) {
             iterations++;
             const requestStart = Date.now();
             console.log(`[ORCHESTRATOR] Anthropic request ${iterations}/${maxIterations} (model: ${this.model})`);
             const response = await Promise.race([
-                client.messages.create({
+                this.client.messages.create({
                     model: this.model,
                     max_tokens: this.maxTokens,
                     system,
@@ -1117,7 +1249,18 @@ Writes ONLY to ~/Lia-Hub/shared/outputs/.lia/calendar.json (creates the director
                 name: 'todo_upsert_items',
                 description: `Create or update todo items for /todo.
 
-Writes ONLY to ~/Lia-Hub/shared/outputs/.lia/todos.json (creates the directory/file if missing).`,
+Writes ONLY to ~/Lia-Hub/shared/outputs/.lia/todos.json (creates the directory/file if missing).
+
+UPSERT BEHAVIOR:
+- Items with matching 'id' are REPLACED (use this to update or mark done)
+- Items with new 'id' are ADDED
+- To "delete" an item, set done: true or exclude it when replacing
+
+BREAKING DOWN A TODO:
+When asked to split/parse a todo into multiple items:
+1. Include the original item with done: true (marks it complete)
+2. Add the new parsed items with unique ids
+3. Extract deadlines, priorities, and notes from the original content`,
                 input_schema: {
                     type: 'object',
                     properties: {
@@ -1540,6 +1683,85 @@ 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: []
+                }
+            },
+            {
+                name: 'lia_todo_write',
+                description: `Update your visible todo list displayed inline in the chat. Use this to show the user what you're working on.
+
+Unlike lia_plan (internal only), this creates a VISIBLE todo list that appears in the chat conversation.
+- Use for multi-step tasks to show real-time progress
+- Update status as you complete each item
+- Only have ONE item as in_progress at a time
+- Link workerId to show actual worker progress percentage`,
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        todos: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    id: { type: 'string', description: 'Unique identifier for the todo (optional, auto-generated if not provided)' },
+                                    content: { type: 'string', description: 'Imperative form: "Run tests", "Build component"' },
+                                    activeForm: { type: 'string', description: 'Present continuous: "Running tests", "Building component"' },
+                                    status: { type: 'string', enum: ['pending', 'in_progress', 'completed'] },
+                                    workerId: { type: 'string', description: 'Optional: link to a spawned worker ID for real progress tracking' }
+                                },
+                                required: ['content', 'activeForm', 'status']
+                            },
+                            description: 'The full todo list (replaces existing list)'
+                        }
+                    },
+                    required: ['todos']
+                }
             }
         ];
     }
@@ -1683,6 +1905,19 @@ 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;
+                case 'lia_todo_write':
+                    result = this.executeLiaTodoWrite(input.todos);
+                    break;
                 default:
                     result = { success: false, output: `Unknown tool: ${toolUse.name}` };
             }
@@ -2186,6 +2421,102 @@ 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}` };
+        }
+    }
+    /**
+     * Update visible todo list (displayed inline in chat)
+     */
+    executeLiaTodoWrite(todos) {
+        try {
+            // Assign IDs if missing
+            this.currentTodos = todos.map((todo, i) => ({
+                ...todo,
+                id: todo.id || `todo_${Date.now()}_${i}`,
+            }));
+            // Update progress from linked workers
+            const allWorkers = this.getWorkerStatus();
+            for (const todo of this.currentTodos) {
+                if (todo.workerId && todo.status === 'in_progress') {
+                    const workerStatus = allWorkers.find(w => w.id === todo.workerId);
+                    if (workerStatus) {
+                        todo.progress = workerStatus.progress;
+                    }
+                }
+            }
+            // Broadcast to UI
+            this.todoUpdateCallback?.(this.currentTodos);
+            const counts = {
+                pending: this.currentTodos.filter(t => t.status === 'pending').length,
+                inProgress: this.currentTodos.filter(t => t.status === 'in_progress').length,
+                completed: this.currentTodos.filter(t => t.status === 'completed').length,
+            };
+            return {
+                success: true,
+                output: `Todo list updated: ${counts.completed}/${this.currentTodos.length} completed, ${counts.inProgress} in progress`
+            };
+        }
+        catch (error) {
+            return { success: false, output: `Failed to update todo list: ${error}` };
+        }
+    }
     /**
      * Format tool preview for user
      */
@@ -2235,6 +2566,14 @@ 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...';
+            case 'lia_todo_write':
+                return null; // Don't show preview - the todo list itself is the UI
             default:
                 return null;
         }

package/dist/websocket.d.ts

@@ -6,7 +6,7 @@
  * - Streams responses as they're generated
  * - Supports interruption and progress updates
  */
-import type { WorkerStatus } from './orchestrator.js';
+import type { WorkerStatus, LiaTodoItem } from './orchestrator.js';
 import { AssetResponse } from './core/asset-api.js';
 export type MessageHandler = (message: WebSocketMessage) => Promise<void>;
 export type StreamHandler = (chunk: string) => void;
@@ -15,7 +15,6 @@ export interface WebSocketMessage {
     id?: string;
     content?: string;
     timestamp?: number;
-    apiKey?: string;
     requestId?: string;
     assetId?: string;
     groupId?: string;
@@ -67,6 +66,10 @@ export declare class AgentWebSocket {
      * Send workers status update for progress bars
      */
     sendWorkersUpdate(workers: WorkerStatus[]): void;
+    /**
+     * Send todo list update for inline display in chat
+     */
+    sendTodoUpdate(todos: LiaTodoItem[]): void;
     /**
      * Send gallery command (AI controls the gallery)
      */

package/dist/websocket.js

@@ -169,6 +169,16 @@ export class AgentWebSocket {
             workers
         });
     }
+    /**
+     * Send todo list update for inline display in chat
+     */
+    sendTodoUpdate(todos) {
+        this.sendToServer({
+            type: 'lia_todo_update',
+            todos,
+            timestamp: Date.now()
+        });
+    }
     /**
      * Send gallery command (AI controls the gallery)
      */

package/package.json

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