@siftd/connect-agent 0.2.39 → 0.2.40

package/README.md

@@ -18,7 +18,7 @@ Connect Agent runs on your machine and bridges the Connect web app to Claude Cod
 ```bash
 # 1. Go to https://connect.siftd.app and get a pairing code
 
-# 2. Pair your machine (with API key for full orchestrator mode)
+# 2. Pair your machine (with API key)
 npx @siftd/connect-agent pair <CODE> --api-key <YOUR_ANTHROPIC_API_KEY>
 
 # 3. Start the agent
@@ -33,17 +33,13 @@ On first start, the agent creates `~/Lia-Hub/` with:
 
 ## Modes
 
-### Orchestrator Mode (Recommended)
-When you provide an Anthropic API key, the agent runs as a **master orchestrator**:
+The agent runs as a **master orchestrator** (requires an Anthropic API key):
 - Uses Claude API directly for the orchestration layer
 - Maintains persistent memory about you and your projects
 - Delegates file/code work to Claude Code CLI workers
 - Schedules future tasks
 - Reads hub files for context on every startup
 
-### Simple Relay Mode
-Without an API key, the agent acts as a simple relay to `claude -p --continue`.
-
 ## Commands
 
 ```bash
@@ -66,7 +62,7 @@ connect-agent logout
 ## Special Commands (via web chat)
 
 - `/reset` or `/clear` - Clear conversation history
-- `/mode` - Check current mode (orchestrator vs simple)
+- `/mode` - Show runtime details
 - `/memory` - Show memory statistics
 - `/verbose` - Toggle verbose tool output
 

package/dist/agent.js

@@ -12,10 +12,6 @@ import { startHeartbeat, stopHeartbeat, getHeartbeatState } from './heartbeat.js
 import { loadHubContext, readScratchpad } from './core/hub.js';
 import { PRODUCT_FULL_NAME } from './branding.js';
 import { startPreviewWorker, stopPreviewWorker } from './core/preview-worker.js';
-// Strip ANSI escape codes for clean output
-function stripAnsi(str) {
-    return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
-}
 function parseAttachments(content) {
     const marker = '📎 Attached files:';
     const index = content.indexOf(marker);
@@ -162,13 +158,10 @@ function initOrchestrator() {
     const instanceMode = getInstanceMode();
     const userOrgIds = getUserOrgIds();
     if (!apiKey) {
-        console.log('[AGENT] No API key - using simple relay mode');
-        console.log('[AGENT] To enable orchestrator: pair with --api-key flag');
-        return null;
+        throw new Error('Missing Anthropic API key. Set ANTHROPIC_API_KEY or run `lia-agent set-key <key>`.');
     }
     if (!userId) {
-        console.log('[AGENT] No userId configured - using simple relay mode');
-        return null;
+        throw new Error('Missing userId configuration. Re-pair the agent.');
     }
     console.log(`[AGENT] Initializing Master Orchestrator (mode: ${instanceMode})...`);
     if (instanceMode === 'personal' && userOrgIds.length > 0) {
@@ -187,59 +180,11 @@ function initOrchestrator() {
         userOrgIds: instanceMode === 'personal' ? userOrgIds : undefined,
     });
 }
-/**
- * Simple relay mode - just pipes to Claude Code CLI
- */
-async function sendToClaudeSimple(input) {
-    return new Promise((resolve) => {
-        console.log(`\n[CLAUDE] Sending: ${input.substring(0, 80)}...`);
-        const claude = spawn('claude', ['-p', '--continue'], {
-            cwd: process.env.HOME,
-            env: process.env,
-            shell: true,
-        });
-        let output = '';
-        let errorOutput = '';
-        claude.stdout?.on('data', (data) => {
-            const text = data.toString();
-            output += text;
-            process.stdout.write(text);
-        });
-        claude.stderr?.on('data', (data) => {
-            const text = data.toString();
-            errorOutput += text;
-            if (!text.includes('Checking') && !text.includes('Connected')) {
-                process.stderr.write(text);
-            }
-        });
-        claude.on('close', (code) => {
-            if (code === 0) {
-                const response = stripAnsi(output).trim();
-                console.log(`\n[CLAUDE] Response: ${response.substring(0, 80)}...`);
-                resolve(response || 'No response from Claude');
-            }
-            else {
-                const error = errorOutput || `Claude exited with code ${code}`;
-                console.error(`\n[CLAUDE] Error: ${error}`);
-                resolve(`Error: ${stripAnsi(error).trim()}`);
-            }
-        });
-        claude.on('error', (err) => {
-            console.error(`\n[CLAUDE] Failed to start: ${err.message}`);
-            resolve(`Error: Failed to start Claude - ${err.message}`);
-        });
-        if (claude.stdin) {
-            claude.stdin.write(input);
-            claude.stdin.end();
-        }
-    });
-}
 /**
  * Orchestrator mode - uses the master orchestrator with memory
  * Supports WebSocket streaming for real-time progress updates
- * @param apiKey Optional per-request API key from user
  */
-async function sendToOrchestrator(input, orch, messageId, apiKey) {
+async function sendToOrchestrator(input, orch, messageId) {
     console.log(`\n[ORCHESTRATOR] Processing: ${input.substring(0, 80)}...`);
     // Send typing indicator via WebSocket
     if (wsClient?.connected()) {
@@ -263,8 +208,7 @@ async function sendToOrchestrator(input, orch, messageId, apiKey) {
             if (wsClient?.connected() && messageId) {
                 wsClient.sendProgress(messageId, msg);
             }
-        }, apiKey // Pass per-request API key
-        );
+        });
         // Update conversation history (only if response is non-empty)
         if (response && response.trim()) {
             conversationHistory.push({ role: 'user', content: input });
@@ -307,14 +251,11 @@ export async function processMessage(message) {
         const wsStatus = wsClient?.connected() ? 'WebSocket' : 'Polling';
         const hbState = getHeartbeatState();
         const runnerInfo = hbState.runnerId ? ` [${hbState.runnerId}]` : '';
-        return orchestrator
-            ? `Running in ORCHESTRATOR mode (${wsStatus})${runnerInfo} with memory and delegation`
-            : `Running in SIMPLE mode (${wsStatus})${runnerInfo} - direct Claude Code relay`;
+        return `Running in ORCHESTRATOR mode (${wsStatus})${runnerInfo} with memory and delegation`;
     }
     if (content === '/memory' && orchestrator) {
         // Trigger memory stats
-        const response = await orchestrator.processMessage('Show me my memory stats', [], undefined, message.apiKey // Use per-message API key if provided
-        );
+        const response = await orchestrator.processMessage('Show me my memory stats', [], undefined);
         return response;
     }
     // System command: force update (sent by webapp banner)
@@ -359,12 +300,7 @@ export async function processMessage(message) {
         };
     }
     try {
-        if (orchestrator) {
-            return await sendToOrchestrator(message.content, orchestrator, message.id, message.apiKey);
-        }
-        else {
-            return await sendToClaudeSimple(message.content);
-        }
+        return await sendToOrchestrator(message.content, orchestrator, message.id);
     }
     catch (error) {
         console.error('Error:', error);
@@ -372,9 +308,15 @@ export async function processMessage(message) {
     }
 }
 export async function runAgent(pollInterval = 2000) {
-    // Initialize orchestrator
-    orchestrator = initOrchestrator();
-    const mode = orchestrator ? 'ORCHESTRATOR' : 'SIMPLE RELAY';
+    try {
+        orchestrator = initOrchestrator();
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[AGENT] ${msg}`);
+        process.exit(1);
+    }
+    const mode = 'ORCHESTRATOR';
     const deployment = getDeploymentInfo();
     console.log('╔══════════════════════════════════════════════════╗');
     console.log(`║  ${PRODUCT_FULL_NAME.padEnd(47)}║`);
@@ -385,29 +327,27 @@ export async function runAgent(pollInterval = 2000) {
         console.log(`[AGENT] Running in CLOUD mode`);
         console.log(`[AGENT] Server: ${deployment.server}`);
     }
-    if (orchestrator) {
-        console.log('[AGENT] Features: Memory, Scheduling, Worker Delegation');
-        // Initialize orchestrator (indexes filesystem into memory)
-        await orchestrator.initialize();
-        // Load hub context on startup
-        const hubContext = loadHubContext();
-        if (hubContext.agentIdentity) {
-            console.log('[AGENT] Hub: AGENTS.md loaded');
-        }
-        if (hubContext.claudeMd) {
-            console.log('[AGENT] Hub: CLAUDE.md loaded');
-        }
-        if (hubContext.landmarks) {
-            console.log('[AGENT] Hub: LANDMARKS.md loaded');
-        }
-        // Check scratchpad for pending plans
-        const scratchpad = readScratchpad();
-        if (scratchpad && scratchpad.length > 100) {
-            console.log(`[AGENT] Scratchpad: ${scratchpad.length} chars of pending notes`);
-        }
+    console.log('[AGENT] Features: Memory, Scheduling, Worker Delegation');
+    // Initialize orchestrator (indexes filesystem into memory)
+    await orchestrator.initialize();
+    // Load hub context on startup
+    const hubContext = loadHubContext();
+    if (hubContext.agentIdentity) {
+        console.log('[AGENT] Hub: AGENTS.md loaded');
+    }
+    if (hubContext.claudeMd) {
+        console.log('[AGENT] Hub: CLAUDE.md loaded');
+    }
+    if (hubContext.landmarks) {
+        console.log('[AGENT] Hub: LANDMARKS.md loaded');
+    }
+    // Check scratchpad for pending plans
+    const scratchpad = readScratchpad();
+    if (scratchpad && scratchpad.length > 100) {
+        console.log(`[AGENT] Scratchpad: ${scratchpad.length} chars of pending notes`);
     }
     // Start preview worker for fast-path asset previews (no LLM)
-    const previewWorker = startPreviewWorker({
+    startPreviewWorker({
         verbose: true,
         onAsset: (manifest) => {
             console.log(`[PREVIEW] New asset: ${manifest.name} (${manifest.id})`);
@@ -425,7 +365,7 @@ export async function runAgent(pollInterval = 2000) {
     const runnerType = isCloudMode() ? 'vm' : 'local';
     startHeartbeat({
         runnerType,
-        capabilities: orchestrator ? ['orchestrator', 'memory'] : [],
+        capabilities: ['orchestrator', 'memory'],
         onError: (error) => {
             // Log only significant errors
             if (error.message.includes('401') || error.message.includes('403')) {
@@ -449,35 +389,38 @@ export async function runAgent(pollInterval = 2000) {
     // Try WebSocket first
     wsClient = new AgentWebSocket();
     const wsConnected = await wsClient.connect();
-    // Set up worker callbacks
-    if (orchestrator) {
-        // Progress bars
-        orchestrator.setWorkerStatusCallback((workers) => {
-            if (wsClient?.connected()) {
-                wsClient.sendWorkersUpdate(workers);
-            }
-            const running = workers.filter(w => w.status === 'running');
-            if (running.length > 0) {
-                console.log(`[WORKERS] ${running.length} running`);
-            }
-        });
-        // Gallery updates - send worker assets for UI gallery view
-        orchestrator.setGalleryCallback((galleryWorkers) => {
-            if (wsClient?.connected()) {
-                wsClient.sendGalleryWorkers(galleryWorkers);
-                const totalAssets = galleryWorkers.reduce((sum, w) => sum + w.assets.length, 0);
-                console.log(`[GALLERY] ${galleryWorkers.length} workers, ${totalAssets} assets`);
-            }
-        });
-        // Worker results - send to user when workers complete
-        orchestrator.setWorkerResultCallback((workerId, result) => {
-            console.log(`[WORKER DONE] ${workerId}: ${result.slice(0, 100)}...`);
-            if (wsClient?.connected()) {
-                // Send as response with worker ID as message ID
-                wsClient.sendResponse(workerId, `**Worker completed:**\n\n${result}`);
-            }
-        });
-    }
+    // Progress bars
+    orchestrator.setWorkerStatusCallback((workers) => {
+        if (wsClient?.connected()) {
+            wsClient.sendWorkersUpdate(workers);
+        }
+        const running = workers.filter(w => w.status === 'running');
+        if (running.length > 0) {
+            console.log(`[WORKERS] ${running.length} running`);
+        }
+    });
+    // Todo updates - send to user for inline display in chat
+    orchestrator.setTodoUpdateCallback((todos) => {
+        if (wsClient?.connected()) {
+            wsClient.sendTodoUpdate(todos);
+        }
+    });
+    // Gallery updates - send worker assets for UI gallery view
+    orchestrator.setGalleryCallback((galleryWorkers) => {
+        if (wsClient?.connected()) {
+            wsClient.sendGalleryWorkers(galleryWorkers);
+            const totalAssets = galleryWorkers.reduce((sum, w) => sum + w.assets.length, 0);
+            console.log(`[GALLERY] ${galleryWorkers.length} workers, ${totalAssets} assets`);
+        }
+    });
+    // Worker results - send to user when workers complete
+    orchestrator.setWorkerResultCallback((workerId, result) => {
+        console.log(`[WORKER DONE] ${workerId}: ${result.slice(0, 100)}...`);
+        if (wsClient?.connected()) {
+            // Send as response with worker ID as message ID
+            wsClient.sendResponse(workerId, `**Worker completed:**\n\n${result}`);
+        }
+    });
     if (wsConnected) {
         console.log('[AGENT] Using WebSocket for real-time communication\n');
         // Handle messages via WebSocket
@@ -486,8 +429,7 @@ export async function runAgent(pollInterval = 2000) {
                 const message = {
                     id: wsMsg.id,
                     content: wsMsg.content,
-                    timestamp: wsMsg.timestamp || Date.now(),
-                    apiKey: wsMsg.apiKey // Pass through per-request API key
+                    timestamp: wsMsg.timestamp || Date.now()
                 };
                 const response = await processMessage(message);
                 // Send response via WebSocket

package/dist/api.d.ts

@@ -2,7 +2,6 @@ export interface Message {
     id: string;
     content: string;
     timestamp: number;
-    apiKey?: string;
 }
 export interface ConnectResponse {
     success: boolean;

package/dist/cli.js

@@ -84,7 +84,7 @@ program
     console.log(`Config file: ${getConfigPath()}`);
     console.log(`Server URL: ${getServerUrl()}`);
     console.log(`Configured: ${isConfigured() ? 'Yes' : 'No'}`);
-    console.log(`Orchestrator mode: ${getAnthropicApiKey() ? 'Yes (API key saved)' : 'No (simple relay)'}`);
+    console.log(`Anthropic API key: ${getAnthropicApiKey() ? 'Configured' : 'Missing'}`);
     if (isConfigured()) {
         const spinner = ora('Checking connection...').start();
         const connected = await checkConnection();

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

@@ -22,7 +22,6 @@ export interface LiaTask {
         userId?: string;
         messageId?: string;
         parentTaskId?: string;
-        apiKey?: string;
         context?: 'personal' | 'team';
         orgId?: string;
     };

package/dist/orchestrator.d.ts

@@ -17,6 +17,15 @@ export interface WorkerStatus {
 }
 export type WorkerStatusCallback = (workers: WorkerStatus[]) => void;
 export type WorkerLogCallback = (workerId: string, line: string, stream: 'stdout' | 'stderr') => void;
+export interface LiaTodoItem {
+    id: string;
+    content: string;
+    activeForm: string;
+    status: 'pending' | 'in_progress' | 'completed';
+    workerId?: string;
+    progress?: number;
+}
+export type TodoUpdateCallback = (todos: LiaTodoItem[]) => void;
 export interface WorkerAsset {
     path: string;
     name: string;
@@ -71,6 +80,8 @@ export declare class MasterOrchestrator {
     private taskQueue;
     private taskUpdateCallback?;
     private planUpdateCallback?;
+    private currentTodos;
+    private todoUpdateCallback?;
     constructor(options: {
         apiKey: string;
         userId: string;
@@ -107,13 +118,16 @@ export declare class MasterOrchestrator {
      * Set callback for plan updates (for real-time UI updates)
      */
     setPlanUpdateCallback(callback: ((plan: LiaPlan) => void) | null): void;
+    /**
+     * Set callback for visible todo list updates (displayed inline in chat)
+     */
+    setTodoUpdateCallback(callback: TodoUpdateCallback | 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;
     /**
@@ -181,9 +195,8 @@ export declare class MasterOrchestrator {
     isVerbose(): boolean;
     /**
      * Process a user message
-     * @param apiKey Optional per-request API key (overrides default)
      */
-    processMessage(message: string, conversationHistory?: MessageParam[], sendMessage?: MessageSender, apiKey?: string): Promise<string>;
+    processMessage(message: string, conversationHistory?: MessageParam[], sendMessage?: MessageSender): Promise<string>;
     private tryHandleCalendarTodo;
     private extractTodoItems;
     private extractCalendarEvents;
@@ -211,7 +224,6 @@ export declare class MasterOrchestrator {
     private isIgnoredEntity;
     /**
      * Run the agentic loop
-     * @param apiKey Optional per-request API key (creates temporary client)
      */
     private runAgentLoop;
     /**
@@ -300,6 +312,10 @@ export declare class MasterOrchestrator {
      * Get Lia's task queue status
      */
     private executeLiaGetQueue;
+    /**
+     * Update visible todo list (displayed inline in chat)
+     */
+    private executeLiaTodoWrite;
     /**
      * Format tool preview for user
      */

package/dist/orchestrator.js

@@ -75,6 +75,13 @@ 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
@@ -150,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
@@ -192,9 +216,12 @@ export class MasterOrchestrator {
     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;
@@ -349,6 +376,12 @@ export class MasterOrchestrator {
     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
@@ -361,7 +394,6 @@ export class MasterOrchestrator {
             metadata: {
                 userId: this.userId,
                 messageId: options?.messageId,
-                apiKey: options?.apiKey,
                 context: this.instanceMode,
                 orgId: this.orgId,
             },
@@ -373,8 +405,8 @@ export class MasterOrchestrator {
     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);
+        undefined // No sendMessage callback for queued tasks
+        );
     }
     /**
      * Get task queue status (for UI)
@@ -517,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) {
@@ -636,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) {
@@ -686,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);
@@ -1087,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,
@@ -1205,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: {
@@ -1676,6 +1731,37 @@ Be specific about what you want done.`,
                     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']
+                }
             }
         ];
     }
@@ -1829,6 +1915,9 @@ Be specific about what you want done.`,
                 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}` };
             }
@@ -2392,6 +2481,42 @@ Be specific about what you want done.`,
             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
      */
@@ -2447,6 +2572,8 @@ Be specific about what you want done.`,
                 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.39",
+  "version": "0.2.40",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",