@siftd/connect-agent 0.2.46 → 0.2.48

package/dist/orchestrator.d.ts

@@ -66,6 +66,7 @@ export declare class MasterOrchestrator {
     private workerLogCallback;
     private workerStatusInterval;
     private attachmentContext;
+    private lastUserMessage;
     private galleryCallback;
     private userId;
     private workspaceDir;
@@ -193,7 +194,13 @@ export declare class MasterOrchestrator {
     private stripTodoSnapshot;
     private hasTodoMutation;
     private hasCalendarMutation;
-    private hasExplicitDate;
+    private hasFileMutation;
+    private getUserTagHint;
+    private getBreakdownTarget;
+    private ensureBreakdownOriginalDone;
+    private getLocalDateKey;
+    private getLocalTimeZone;
+    private getTodoCalSystemPrompt;
     private getToolChoice;
     private withAttachments;
     private updateFileScope;

package/dist/orchestrator.js

@@ -157,7 +157,9 @@ CALENDAR + TODO (Lia-managed data):
 - Keep these files hidden; refer users to /cal or /todo in responses
 - If the user provides subtasks or a bullet list under one task, store them as subtasks (unless they explicitly ask to split into multiple items)
 - Preserve explicit due dates, times, and priorities exactly as given (YYYY-MM-DD, HH:MM)
+- Preserve task titles verbatim (including bracketed tags like [lia-test-...], quoted titles, and casing). Do not strip tags or rewrite titles.
 - If the user explicitly requests /todo or /cal changes, you MUST call the corresponding tool in the same response
+- Never delegate /todo or /cal changes to workers; use the tools directly in the same response
 - If the user says "Add to /todo:" followed by a list of deadlines/details, create ONE todo with notes unless they explicitly ask to split/break down
 - Schemas:
   - calendar.json: { "version": 1, "calendars": [...], "events": [...] }
@@ -185,6 +187,16 @@ Before complex work: Check CLAUDE.md → Read LANDMARKS.md → Search memory
 After completing work: Update LANDMARKS.md → Remember learnings
 
 You orchestrate through workers. You remember through memory. You never do arbitrary file operations directly (calendar_upsert_events and todo_upsert_items are the safe exceptions).`;
+const TODO_CAL_SYSTEM_PROMPT_BASE = `You are Lia. Your ONLY job is to update /todo and /cal using tools.
+
+Rules:
+- If the user requests /todo changes, call todo_upsert_items.
+- If the user requests /cal or calendar changes, call calendar_upsert_events.
+- If both are requested, call BOTH tools in the same response.
+- Preserve exact titles, dates, times, notes, and any bracketed tags (e.g., [lia-test-...]).
+- Do not spawn workers or call any other tools.
+- Do not ask follow-up questions; infer reasonable defaults from the request.
+- After tool calls, respond briefly confirming the updates.`;
 export class MasterOrchestrator {
     client;
     model;
@@ -206,6 +218,7 @@ export class MasterOrchestrator {
     workerLogCallback = null;
     workerStatusInterval = null;
     attachmentContext = null;
+    lastUserMessage = null;
     galleryCallback = null;
     userId;
     workspaceDir;
@@ -688,8 +701,73 @@ export class MasterOrchestrator {
         const query = /\b(what|show|list|open|view|see)\b/.test(lower);
         return target && action && !query;
     }
-    hasExplicitDate(message) {
-        return /\b\d{4}-\d{2}-\d{2}\b/.test(this.stripTodoSnapshot(message));
+    hasFileMutation(message) {
+        const lower = this.stripTodoSnapshot(message).toLowerCase();
+        const target = /(^|\s)\/files\b|\bfiles?\b/.test(lower);
+        const action = /\b(create|make|write|save|generate|export|upload|attach|produce|edit|update|modify|delete|remove)\b/.test(lower);
+        const query = /\b(what|show|list|open|view|see|browse|find)\b/.test(lower);
+        return target && action && !query;
+    }
+    getUserTagHint(message) {
+        if (!message)
+            return null;
+        const base = this.stripTodoSnapshot(message);
+        const matches = base.match(/\[[^\]]{2,64}\]/g) || [];
+        const unique = Array.from(new Set(matches.map((tag) => tag.trim()))).filter(Boolean);
+        if (unique.length !== 1)
+            return null;
+        return unique[0];
+    }
+    getBreakdownTarget(message) {
+        if (!message)
+            return null;
+        const stripped = this.stripTodoSnapshot(message);
+        if (!/\b(break(?:\s|-)?down|split|parse)\b/i.test(stripped))
+            return null;
+        const quoted = stripped.match(/["“]([^"”]{3,160})["”]/);
+        if (quoted && quoted[1]) {
+            return quoted[1].trim();
+        }
+        const inline = stripped.match(/break(?:\s|-)?down\s+the\s+(.+?)\s+(?:item|todo|task)\b/i);
+        if (inline && inline[1]) {
+            return inline[1].trim();
+        }
+        return null;
+    }
+    ensureBreakdownOriginalDone(items, targetTitle) {
+        const normalizedTarget = targetTitle.trim().toLowerCase();
+        let found = false;
+        const nextItems = items.map((item) => {
+            if (item?.title && item.title.trim().toLowerCase() === normalizedTarget) {
+                found = true;
+                return { ...item, done: true };
+            }
+            return item;
+        });
+        if (!found) {
+            nextItems.unshift({ title: targetTitle, done: true });
+        }
+        return nextItems;
+    }
+    getLocalDateKey(date = new Date()) {
+        const year = date.getFullYear();
+        const month = `${date.getMonth() + 1}`.padStart(2, '0');
+        const day = `${date.getDate()}`.padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+    getLocalTimeZone() {
+        try {
+            return Intl.DateTimeFormat().resolvedOptions().timeZone || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getTodoCalSystemPrompt() {
+        const today = this.getLocalDateKey();
+        const timeZone = this.getLocalTimeZone();
+        const tzNote = timeZone ? ` (${timeZone})` : '';
+        return `${TODO_CAL_SYSTEM_PROMPT_BASE}\n\nDate context:\n- Today is ${today}${tzNote}.\n- Use this to resolve relative dates like "today", "tomorrow", or "next week".`;
     }
     getToolChoice(messages) {
         const last = messages[messages.length - 1];
@@ -697,12 +775,16 @@ export class MasterOrchestrator {
             return undefined;
         const wantsTodo = this.hasTodoMutation(last.content);
         const wantsCal = this.hasCalendarMutation(last.content);
+        const wantsFiles = this.hasFileMutation(last.content);
         if (wantsTodo && !wantsCal) {
             return { type: 'tool', name: 'todo_upsert_items' };
         }
-        if (wantsCal && !wantsTodo && this.hasExplicitDate(last.content)) {
+        if (wantsCal && !wantsTodo) {
             return { type: 'tool', name: 'calendar_upsert_events' };
         }
+        if (wantsFiles) {
+            return { type: 'tool', name: 'delegate_to_worker' };
+        }
         return undefined;
     }
     withAttachments(task, context) {
@@ -775,12 +857,28 @@ export class MasterOrchestrator {
      * Process a user message
      */
     async processMessage(message, conversationHistory = [], sendMessage) {
+        this.lastUserMessage = message;
         // Handle slash commands first
         const slashResponse = this.handleSlashCommand(message);
         if (slashResponse) {
             return slashResponse;
         }
         this.updateFileScope(message);
+        const wantsTodoOrCal = this.hasTodoMutation(message) || this.hasCalendarMutation(message);
+        if (wantsTodoOrCal) {
+            this.attachmentContext = this.extractAttachmentContext(message);
+            const toolMessages = [{ role: 'user', content: message }];
+            try {
+                return await this.runAgentLoop(toolMessages, this.getTodoCalSystemPrompt(), sendMessage);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return `Error: ${errorMessage}`;
+            }
+            finally {
+                this.attachmentContext = null;
+            }
+        }
         // DISABLED: Dumb regex extraction was creating garbage todos
         // Let the AI use calendar_upsert_events and todo_upsert_items tools properly
         // const quickWrite = this.tryHandleCalendarTodo(message);
@@ -1231,14 +1329,34 @@ ${hubContextStr}
      * Run the agentic loop
      */
     async runAgentLoop(messages, system, sendMessage) {
-        const tools = this.getToolDefinitions();
+        const toolsBase = this.getToolDefinitions();
+        const last = messages[messages.length - 1];
+        const lastContent = last && last.role === 'user' && typeof last.content === 'string' ? last.content : '';
+        const restrictWorkers = lastContent
+            ? (this.hasTodoMutation(lastContent) || this.hasCalendarMutation(lastContent))
+            : false;
+        const wantsTodoOrCal = restrictWorkers;
+        const todoCalTools = new Set(['calendar_upsert_events', 'todo_upsert_items']);
+        const blockedTools = new Set([
+            'spawn_worker',
+            'delegate_to_worker',
+            'check_worker',
+            'wait_worker',
+            'list_workers',
+            'cancel_worker',
+        ]);
+        const tools = wantsTodoOrCal
+            ? toolsBase.filter((tool) => todoCalTools.has(tool.name))
+            : toolsBase.filter((tool) => !blockedTools.has(tool.name) || !restrictWorkers);
         let currentMessages = [...messages];
         let iterations = 0;
         const maxIterations = 30; // Increased for complex multi-tool tasks
         const requestTimeoutMs = 60000;
+        const forcedToolChoice = this.getToolChoice(currentMessages);
+        let retriedForcedTool = false;
         while (iterations < maxIterations) {
             iterations++;
-            const toolChoice = this.getToolChoice(currentMessages);
+            const toolChoice = forcedToolChoice ?? this.getToolChoice(currentMessages);
             const requestStart = Date.now();
             console.log(`[ORCHESTRATOR] Anthropic request ${iterations}/${maxIterations} (model: ${this.model})`);
             const response = await Promise.race([
@@ -1259,10 +1377,37 @@ ${hubContextStr}
             console.log(`[ORCHESTRATOR] Anthropic response ${iterations}/${maxIterations} in ${Date.now() - requestStart}ms`);
             // Check if done
             if (response.stop_reason === 'end_turn' || !this.hasToolUse(response.content)) {
+                if (forcedToolChoice && !retriedForcedTool) {
+                    retriedForcedTool = true;
+                    const toolName = forcedToolChoice.name;
+                    const needsNoWorkers = toolName === 'todo_upsert_items' || toolName === 'calendar_upsert_events';
+                    const followup = needsNoWorkers
+                        ? `You must call the ${toolName} tool now. Use the exact task/event titles and any bracketed tags exactly as provided. Do not spawn workers.`
+                        : `You must call the ${toolName} tool now. Use the user's request as the task details.`;
+                    currentMessages = [
+                        ...currentMessages,
+                        { role: 'assistant', content: response.content },
+                        {
+                            role: 'user',
+                            content: followup
+                        }
+                    ];
+                    continue;
+                }
                 return this.extractText(response.content);
             }
+            const toolUseBlocks = response.content.filter((block) => block.type === 'tool_use');
+            const toolNames = toolUseBlocks.map((block) => block.name);
             // Process tool calls
             const toolResults = await this.processToolCalls(response.content, sendMessage);
+            if (wantsTodoOrCal && (toolNames.includes('todo_upsert_items') || toolNames.includes('calendar_upsert_events'))) {
+                const updates = [];
+                if (toolNames.includes('todo_upsert_items'))
+                    updates.push('Updated /todo.');
+                if (toolNames.includes('calendar_upsert_events'))
+                    updates.push('Updated /cal.');
+                return `${updates.join(' ')} Open /todo or /cal to view.`;
+            }
             // Continue conversation
             currentMessages = [
                 ...currentMessages,
@@ -1878,6 +2023,17 @@ Unlike lia_plan (internal only), this creates a VISIBLE todo list that appears i
     async processToolCalls(content, sendMessage) {
         const toolUseBlocks = content.filter((block) => block.type === 'tool_use');
         const results = [];
+        const wantsTodoOrCal = this.lastUserMessage
+            ? (this.hasTodoMutation(this.lastUserMessage) || this.hasCalendarMutation(this.lastUserMessage))
+            : false;
+        const blockedWorkerTools = new Set([
+            'spawn_worker',
+            'delegate_to_worker',
+            'check_worker',
+            'wait_worker',
+            'list_workers',
+            'cancel_worker',
+        ]);
         for (const toolUse of toolUseBlocks) {
             const input = toolUse.input;
             let result;
@@ -1887,151 +2043,183 @@ Unlike lia_plan (internal only), this creates a VISIBLE todo list that appears i
                 if (preview)
                     await sendMessage(preview);
             }
-            switch (toolUse.name) {
-                // New direct tools
-                case 'bash':
-                    result = await this.bashTool.execute(input.command, input.timeout);
-                    break;
-                case 'calendar_upsert_events':
-                    result = this.calendarTools.upsertCalendarEvents(input.events, input.calendars);
-                    break;
-                case 'todo_upsert_items':
-                    result = this.calendarTools.upsertTodoItems(input.items);
-                    break;
-                case 'web_search':
-                    result = await this.webTools.webSearch(input.query, { numResults: input.num_results });
-                    break;
-                case 'fetch_url':
-                    result = await this.webTools.fetchUrl(input.url, {
-                        format: input.format,
-                        timeout: input.timeout
-                    });
-                    break;
-                // Worker tools
-                case 'spawn_worker': {
-                    const { task } = this.withAttachments(input.task);
-                    const fileScope = this.getFileScopeOverrides();
-                    const scopedTask = fileScope.instructions ? `${fileScope.instructions}\n\n${task}` : task;
-                    result = await this.workerTools.spawnWorker(scopedTask, {
-                        timeout: input.timeout,
-                        priority: input.priority,
-                        workingDirectory: input.working_directory || fileScope.workingDir
-                    });
-                    break;
-                }
-                case 'check_worker':
-                    result = await this.workerTools.checkWorker(input.job_id);
-                    break;
-                case 'wait_worker':
-                    result = await this.workerTools.waitWorker(input.job_id, input.max_wait);
-                    break;
-                case 'list_workers':
-                    result = await this.workerTools.listWorkers(input.status);
-                    break;
-                case 'cancel_worker':
-                    result = await this.workerTools.cancelWorker(input.job_id);
-                    break;
-                // Legacy delegate tool
-                case 'delegate_to_worker': {
-                    const { task, context } = this.withAttachments(input.task, input.context);
-                    const fileScope = this.getFileScopeOverrides();
-                    result = await this.delegateToWorker(task, context, input.working_directory || fileScope.workingDir, fileScope.instructions);
-                    break;
-                }
-                case 'remember':
-                    result = await this.executeRemember(input.content, input.type, input.importance);
-                    break;
-                case 'remember_entity': {
-                    const scope = input.scope === 'org' ? 'org' : 'user';
-                    const graph = scope === 'org' ? this.orgContextGraph : this.contextGraph;
-                    if (!graph) {
-                        result = { success: false, output: 'Org context is not configured for this agent.' };
+            if (wantsTodoOrCal && blockedWorkerTools.has(toolUse.name)) {
+                result = {
+                    success: false,
+                    output: '',
+                    error: 'Do not use worker tools for /todo or /cal. Call todo_upsert_items or calendar_upsert_events directly.'
+                };
+            }
+            else
+                switch (toolUse.name) {
+                    // New direct tools
+                    case 'bash':
+                        result = await this.bashTool.execute(input.command, input.timeout);
+                        break;
+                    case 'calendar_upsert_events':
+                        {
+                            const tagHint = this.getUserTagHint(this.lastUserMessage);
+                            const events = input.events || [];
+                            const taggedEvents = tagHint
+                                ? events.map((event) => ({
+                                    ...event,
+                                    title: event.title.includes(tagHint) ? event.title : `${event.title} ${tagHint}`
+                                }))
+                                : events;
+                            result = this.calendarTools.upsertCalendarEvents(taggedEvents, input.calendars);
+                        }
+                        break;
+                    case 'todo_upsert_items':
+                        {
+                            const tagHint = this.getUserTagHint(this.lastUserMessage);
+                            let items = input.items || [];
+                            const breakdownTarget = this.getBreakdownTarget(this.lastUserMessage);
+                            if (breakdownTarget) {
+                                items = this.ensureBreakdownOriginalDone(items, breakdownTarget);
+                            }
+                            const taggedItems = tagHint
+                                ? items.map((item) => ({
+                                    ...item,
+                                    title: item.title.includes(tagHint) ? item.title : `${item.title} ${tagHint}`
+                                }))
+                                : items;
+                            result = this.calendarTools.upsertTodoItems(taggedItems);
+                        }
+                        break;
+                    case 'web_search':
+                        result = await this.webTools.webSearch(input.query, { numResults: input.num_results });
+                        break;
+                    case 'fetch_url':
+                        result = await this.webTools.fetchUrl(input.url, {
+                            format: input.format,
+                            timeout: input.timeout
+                        });
+                        break;
+                    // Worker tools
+                    case 'spawn_worker': {
+                        const { task } = this.withAttachments(input.task);
+                        const fileScope = this.getFileScopeOverrides();
+                        const scopedTask = fileScope.instructions ? `${fileScope.instructions}\n\n${task}` : task;
+                        result = await this.workerTools.spawnWorker(scopedTask, {
+                            timeout: input.timeout,
+                            priority: input.priority,
+                            workingDirectory: input.working_directory || fileScope.workingDir
+                        });
                         break;
                     }
-                    const entity = await graph.upsertEntity({
-                        kind: input.kind,
-                        name: input.name,
-                        description: input.description,
-                        attributes: input.attributes,
-                        tags: input.tags
-                    });
-                    result = { success: true, output: `Stored ${scope} entity: ${entity.kind} ${entity.name} (${entity.key})` };
-                    break;
-                }
-                case 'remember_relation': {
-                    const scope = input.scope === 'org' ? 'org' : 'user';
-                    const graph = scope === 'org' ? this.orgContextGraph : this.contextGraph;
-                    if (!graph) {
-                        result = { success: false, output: 'Org context is not configured for this agent.' };
+                    case 'check_worker':
+                        result = await this.workerTools.checkWorker(input.job_id);
+                        break;
+                    case 'wait_worker':
+                        result = await this.workerTools.waitWorker(input.job_id, input.max_wait);
+                        break;
+                    case 'list_workers':
+                        result = await this.workerTools.listWorkers(input.status);
+                        break;
+                    case 'cancel_worker':
+                        result = await this.workerTools.cancelWorker(input.job_id);
+                        break;
+                    // Legacy delegate tool
+                    case 'delegate_to_worker': {
+                        const { task, context } = this.withAttachments(input.task, input.context);
+                        const fileScope = this.getFileScopeOverrides();
+                        result = await this.delegateToWorker(task, context, input.working_directory || fileScope.workingDir, fileScope.instructions);
                         break;
                     }
-                    const relation = await graph.linkEntities({
-                        from: input.from,
-                        to: input.to,
-                        type: input.type,
-                        description: input.description,
-                        fromKind: input.from_kind,
-                        toKind: input.to_kind
-                    });
-                    result = { success: true, output: `Linked ${scope}: ${relation.from} ${relation.type} ${relation.to}` };
-                    break;
-                }
-                case 'search_context': {
-                    const scope = input.scope === 'org' ? 'org' : 'user';
-                    const graph = scope === 'org' ? this.orgContextGraph : this.contextGraph;
-                    if (!graph) {
-                        result = { success: false, output: 'Org context is not configured for this agent.' };
+                    case 'remember':
+                        result = await this.executeRemember(input.content, input.type, input.importance);
+                        break;
+                    case 'remember_entity': {
+                        const scope = input.scope === 'org' ? 'org' : 'user';
+                        const graph = scope === 'org' ? this.orgContextGraph : this.contextGraph;
+                        if (!graph) {
+                            result = { success: false, output: 'Org context is not configured for this agent.' };
+                            break;
+                        }
+                        const entity = await graph.upsertEntity({
+                            kind: input.kind,
+                            name: input.name,
+                            description: input.description,
+                            attributes: input.attributes,
+                            tags: input.tags
+                        });
+                        result = { success: true, output: `Stored ${scope} entity: ${entity.kind} ${entity.name} (${entity.key})` };
                         break;
                     }
-                    const entities = await graph.searchEntities(input.query, { kind: input.kind, limit: 6 });
-                    if (entities.length === 0) {
-                        result = { success: true, output: 'No context entities found.' };
+                    case 'remember_relation': {
+                        const scope = input.scope === 'org' ? 'org' : 'user';
+                        const graph = scope === 'org' ? this.orgContextGraph : this.contextGraph;
+                        if (!graph) {
+                            result = { success: false, output: 'Org context is not configured for this agent.' };
+                            break;
+                        }
+                        const relation = await graph.linkEntities({
+                            from: input.from,
+                            to: input.to,
+                            type: input.type,
+                            description: input.description,
+                            fromKind: input.from_kind,
+                            toKind: input.to_kind
+                        });
+                        result = { success: true, output: `Linked ${scope}: ${relation.from} ${relation.type} ${relation.to}` };
                         break;
                     }
-                    const lines = entities.map(entity => {
-                        const desc = entity.description ? ` - ${entity.description}` : '';
-                        return `[${entity.kind}] ${entity.name}${desc} (${entity.key})`;
-                    });
-                    result = { success: true, output: lines.join('\n') };
-                    break;
+                    case 'search_context': {
+                        const scope = input.scope === 'org' ? 'org' : 'user';
+                        const graph = scope === 'org' ? this.orgContextGraph : this.contextGraph;
+                        if (!graph) {
+                            result = { success: false, output: 'Org context is not configured for this agent.' };
+                            break;
+                        }
+                        const entities = await graph.searchEntities(input.query, { kind: input.kind, limit: 6 });
+                        if (entities.length === 0) {
+                            result = { success: true, output: 'No context entities found.' };
+                            break;
+                        }
+                        const lines = entities.map(entity => {
+                            const desc = entity.description ? ` - ${entity.description}` : '';
+                            return `[${entity.kind}] ${entity.name}${desc} (${entity.key})`;
+                        });
+                        result = { success: true, output: lines.join('\n') };
+                        break;
+                    }
+                    case 'search_memory':
+                        result = await this.executeSearchMemory(input.query, input.type);
+                        break;
+                    case 'schedule_task':
+                        result = await this.executeScheduleTask(input.task, input.when);
+                        break;
+                    case 'list_scheduled':
+                        result = await this.executeListScheduled();
+                        break;
+                    case 'memory_stats':
+                        result = await this.executeMemoryStats();
+                        break;
+                    case 'open_browser':
+                        result = await this.executeOpenBrowser(input.url);
+                        break;
+                    case 'start_local_server':
+                        result = await this.executeStartServer(input.directory, input.port);
+                        break;
+                    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}` };
                 }
-                case 'search_memory':
-                    result = await this.executeSearchMemory(input.query, input.type);
-                    break;
-                case 'schedule_task':
-                    result = await this.executeScheduleTask(input.task, input.when);
-                    break;
-                case 'list_scheduled':
-                    result = await this.executeListScheduled();
-                    break;
-                case 'memory_stats':
-                    result = await this.executeMemoryStats();
-                    break;
-                case 'open_browser':
-                    result = await this.executeOpenBrowser(input.url);
-                    break;
-                case 'start_local_server':
-                    result = await this.executeStartServer(input.directory, input.port);
-                    break;
-                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}` };
-            }
             // Anthropic API requires content to be non-empty when is_error is true
             // Belt-and-suspenders: ensure content is NEVER empty
             let content = result.output || '';

package/dist/tools/worker.d.ts

@@ -8,6 +8,7 @@ export { GalleryCallback, GalleryWorker };
 export type { WorkerLogCallback };
 export declare class WorkerTools {
     private manager;
+    private workspaceDir;
     constructor(workspaceDir: string);
     /**
      * Set callback for gallery updates (worker assets for UI)

package/dist/tools/worker.js

@@ -5,8 +5,10 @@
 import { WorkerManager } from '../workers/manager.js';
 export class WorkerTools {
     manager;
+    workspaceDir;
     constructor(workspaceDir) {
         this.manager = new WorkerManager(workspaceDir);
+        this.workspaceDir = workspaceDir;
     }
     /**
      * Set callback for gallery updates (worker assets for UI)
@@ -34,7 +36,7 @@ export class WorkerTools {
             const jobId = await this.manager.spawn(task, {
                 timeout: options?.timeout,
                 priority: options?.priority,
-                workspace: options?.workingDirectory
+                workspace: options?.workingDirectory || this.workspaceDir
             });
             const job = this.manager.get(jobId);
             return {

package/dist/websocket.d.ts

@@ -11,7 +11,7 @@ import { AssetResponse } from './core/asset-api.js';
 export type MessageHandler = (message: WebSocketMessage) => Promise<void>;
 export type StreamHandler = (chunk: string) => void;
 export interface WebSocketMessage {
-    type: 'message' | 'interrupt' | 'ping' | 'pong' | 'connected' | 'asset_request';
+    type: 'message' | 'interrupt' | 'ping' | 'pong' | 'connected' | 'asset_request' | 'ready';
     id?: string;
     content?: string;
     timestamp?: number;
@@ -37,6 +37,8 @@ export declare class AgentWebSocket {
     private isConnected;
     private pendingResponses;
     private cloudflareBlocked;
+    private pendingMessages;
+    private readyPending;
     constructor();
     /**
      * Connect to the WebSocket server
@@ -46,6 +48,7 @@ export declare class AgentWebSocket {
      * Set handler for incoming messages
      */
     onMessage(handler: MessageHandler): void;
+    sendReady(): void;
     /**
      * Send a streaming response for a message
      */

package/dist/websocket.js

@@ -21,6 +21,8 @@ export class AgentWebSocket {
     isConnected = false;
     pendingResponses = new Map();
     cloudflareBlocked = false; // Track if Cloudflare is blocking WebSockets
+    pendingMessages = [];
+    readyPending = false;
     constructor() {
         const httpUrl = getServerUrl();
         // Check for WebSocket-specific URL (bypasses Cloudflare)
@@ -51,6 +53,12 @@ export class AgentWebSocket {
                     this.isConnected = true;
                     this.reconnectAttempts = 0;
                     this.startPingInterval();
+                    if (this.messageHandler) {
+                        this.sendReady();
+                    }
+                    else {
+                        this.readyPending = true;
+                    }
                     resolve(true);
                 });
                 this.ws.on('message', (data) => {
@@ -99,6 +107,20 @@ export class AgentWebSocket {
      */
     onMessage(handler) {
         this.messageHandler = handler;
+        if (this.isConnected && this.readyPending) {
+            this.readyPending = false;
+            this.sendReady();
+        }
+        if (this.pendingMessages.length > 0) {
+            const queued = [...this.pendingMessages];
+            this.pendingMessages = [];
+            for (const message of queued) {
+                void handler(message);
+            }
+        }
+    }
+    sendReady() {
+        this.sendToServer({ type: 'ready' });
     }
     /**
      * Send a streaming response for a message
@@ -251,6 +273,9 @@ export class AgentWebSocket {
                     if (this.messageHandler && message.content) {
                         this.messageHandler(message);
                     }
+                    else if (message.content) {
+                        this.pendingMessages.push(message);
+                    }
                     break;
                 case 'asset_request':
                     // Handle asset requests (fast-path, no LLM)

package/package.json

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