@siftd/connect-agent 0.2.37 → 0.2.39

package/dist/orchestrator.js

@@ -11,13 +11,16 @@ import { AdvancedMemoryStore } from './core/memory-advanced.js';
 import { PostgresMemoryStore, isPostgresConfigured } from './core/memory-postgres.js';
 import { TaskScheduler } from './core/scheduler.js';
 import { SystemIndexer } from './core/system-indexer.js';
+import { ContextGraph, ContextGraphKinds } from './core/context-graph.js';
 import { BashTool } from './tools/bash.js';
 import { WebTools } from './tools/web.js';
 import { WorkerTools } from './tools/worker.js';
+import { CalendarTools } from './tools/calendar.js';
 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"
@@ -72,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:
@@ -90,11 +101,21 @@ TOOL RULES:
 - Building, testing, deploying
 - Any filesystem modification
 
+ATTACHMENTS:
+- If the user message includes "📎 Attached files:", include those URLs verbatim in any worker task.
+- Workers should download the files from the URLs and proceed without asking for the content again.
+
 MEMORY:
 - Search memory before starting work (context is valuable)
 - Remember important things after significant actions
 - Learn from failures - what went wrong, how to avoid it
 
+CONTEXT GRAPH:
+- Use remember_entity to store people, teams, projects, tools, tasks
+- Use remember_relation to link entities (owns, works_on, depends_on, etc.)
+- Use search_context to retrieve team context before asking users to repeat
+- If user asks for "/context", call search_context and summarize results
+
 YOUR HUB: ~/Lia-Hub/
 - **CLAUDE.md** - User's instructions (always follow these)
 - **LANDMARKS.md** - Current state and context
@@ -109,22 +130,52 @@ The Lia interface has a built-in gallery that shows worker outputs automatically
 ✅ Workers write to ~/Lia-Hub/shared/outputs/
 ✅ Gallery displays assets in-app automatically
 
+FILES BROWSER:
+Users can type /files to open the Finder UI (cloud mode).
+When asked to browse or locate files, point them to /files.
+Refer to /files instead of internal Lia-Hub paths in responses.
+
+FILES SCOPES:
+- "My Files" are private to the user (default /files view)
+- "Team Files" are shared across the org (use /files team or the Team Files location)
+- If a user asks to share with the team, store outputs in Team Files and mention that it is shared
+
+CALENDAR + TODO (Lia-managed data):
+- /cal reads ~/Lia-Hub/shared/outputs/.lia/calendar.json
+- /todo reads ~/Lia-Hub/shared/outputs/.lia/todos.json
+- When users add, edit, or delete events, use calendar_upsert_events
+- When users add, edit, or delete tasks, use todo_upsert_items
+- Keep these files hidden; refer users to /cal or /todo in responses
+- Schemas:
+  - calendar.json: { "version": 1, "calendars": [...], "events": [...] }
+  - todos.json: { "version": 1, "items": [...] }
+
 WORKFLOW:
 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 file operations directly.`;
+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).`;
 export class MasterOrchestrator {
     client;
     model;
     maxTokens;
     memory;
+    contextGraph;
+    orgMemory;
+    orgContextGraph;
+    orgId;
+    orgRole;
+    instanceMode;
+    userOrgMemories;
+    userOrgContextGraphs;
     scheduler;
     indexer;
     jobs = new Map();
     jobCounter = 0;
     workerStatusCallback = null;
+    workerLogCallback = null;
     workerStatusInterval = null;
+    attachmentContext = null;
     galleryCallback = null;
     userId;
     workspaceDir;
@@ -134,17 +185,28 @@ export class MasterOrchestrator {
     bashTool;
     webTools;
     workerTools;
+    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';
         this.maxTokens = options.maxTokens || 4096;
         this.userId = options.userId;
+        this.orgId = options.orgId;
+        this.orgRole = options.orgRole;
+        this.instanceMode = options.instanceMode || 'personal';
         this.workspaceDir = options.workspaceDir || process.env.HOME || '/tmp';
+        this.userOrgMemories = new Map();
+        this.userOrgContextGraphs = new Map();
         // Find claude binary - critical for worker delegation
         this.claudePath = this.findClaudeBinary();
         console.log(`[ORCHESTRATOR] Claude binary: ${this.claudePath}`);
+        console.log(`[ORCHESTRATOR] Instance mode: ${this.instanceMode}`);
         // Initialize memory - use Postgres if DATABASE_URL is set, otherwise SQLite
         if (isPostgresConfigured()) {
             console.log('[ORCHESTRATOR] DATABASE_URL detected, using PostgreSQL + pgvector');
@@ -160,6 +222,44 @@ export class MasterOrchestrator {
                 voyageApiKey: options.voyageApiKey
             });
         }
+        this.contextGraph = new ContextGraph(this.memory, { scope: options.userId });
+        // Initialize org memory for team mode or when orgId is provided
+        if (this.orgId) {
+            if (isPostgresConfigured()) {
+                this.orgMemory = new PostgresMemoryStore({
+                    connectionString: process.env.DATABASE_URL,
+                    userId: `org:${this.orgId}`
+                });
+            }
+            else {
+                this.orgMemory = new AdvancedMemoryStore({
+                    dbPath: `memories_org_${this.orgId}.db`,
+                    vectorPath: `./memory_vectors_org_${this.orgId}`,
+                    voyageApiKey: options.voyageApiKey
+                });
+            }
+            this.orgContextGraph = new ContextGraph(this.orgMemory, { scope: `org:${this.orgId}` });
+        }
+        // For personal mode: initialize memory stores for all user's teams (for reading)
+        if (this.instanceMode === 'personal' && options.userOrgIds) {
+            for (const orgId of options.userOrgIds) {
+                if (isPostgresConfigured()) {
+                    this.userOrgMemories.set(orgId, new PostgresMemoryStore({
+                        connectionString: process.env.DATABASE_URL,
+                        userId: `org:${orgId}`
+                    }));
+                }
+                else {
+                    this.userOrgMemories.set(orgId, new AdvancedMemoryStore({
+                        dbPath: `memories_org_${orgId}.db`,
+                        vectorPath: `./memory_vectors_org_${orgId}`,
+                        voyageApiKey: options.voyageApiKey
+                    }));
+                }
+                this.userOrgContextGraphs.set(orgId, new ContextGraph(this.userOrgMemories.get(orgId), { scope: `org:${orgId}` }));
+            }
+            console.log(`[ORCHESTRATOR] Personal mode: initialized ${this.userOrgMemories.size} team memory stores for reading`);
+        }
         this.scheduler = new TaskScheduler(`scheduled_${options.userId}.json`);
         // Create indexer (will index on first initialize call)
         this.indexer = new SystemIndexer(this.memory);
@@ -167,7 +267,19 @@ export class MasterOrchestrator {
         this.bashTool = new BashTool(this.workspaceDir);
         this.webTools = new WebTools();
         this.workerTools = new WorkerTools(this.workspaceDir);
+        this.calendarTools = new CalendarTools();
         this.sharedState = new SharedState(this.workspaceDir);
+        this.workerTools.setLogCallback((workerId, line, stream) => {
+            if (this.workerLogCallback) {
+                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
@@ -208,6 +320,12 @@ export class MasterOrchestrator {
             }
         }
     }
+    /**
+     * Set callback for worker log streaming
+     */
+    setWorkerLogCallback(callback) {
+        this.workerLogCallback = callback;
+    }
     /**
      * Set callback for gallery updates (worker assets for UI gallery view)
      */
@@ -219,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
      */
@@ -412,6 +599,35 @@ export class MasterOrchestrator {
         }
         return null;
     }
+    extractAttachmentContext(message) {
+        const marker = '📎 Attached files:';
+        const index = message.indexOf(marker);
+        if (index === -1)
+            return null;
+        const raw = message.slice(index + marker.length);
+        const lines = raw
+            .split('\n')
+            .map(line => line.trim())
+            .filter(Boolean);
+        if (lines.length === 0)
+            return null;
+        return lines.join('\n');
+    }
+    withAttachments(task, context) {
+        if (!this.attachmentContext)
+            return { task, context };
+        const attachmentBlock = this.attachmentContext;
+        const hasAttachments = task.includes(attachmentBlock) ||
+            task.includes('Attached files') ||
+            (context && (context.includes(attachmentBlock) || context.includes('Attached files')));
+        if (hasAttachments)
+            return { task, context };
+        const attachmentNote = `Attached files (download these URLs and use their contents; do not ask the user to resend):\n${attachmentBlock}`;
+        if (context && context.trim().length > 0) {
+            return { task, context: `${context}\n\n${attachmentNote}` };
+        }
+        return { task: `${task}\n\n${attachmentNote}` };
+    }
     /**
      * Check if verbose mode is enabled
      */
@@ -428,9 +644,15 @@ export class MasterOrchestrator {
         if (slashResponse) {
             return slashResponse;
         }
+        // Deterministic calendar/todo writes (do not rely on the model calling tools)
+        const quickWrite = this.tryHandleCalendarTodo(message);
+        if (quickWrite) {
+            return quickWrite;
+        }
         // Load hub context (AGENTS.md identity, LANDMARKS.md state, project bio if relevant)
         const hubContext = loadHubContext(message);
         const hubContextStr = formatHubContext(hubContext);
+        this.attachmentContext = this.extractAttachmentContext(message);
         // Build context from memory
         const memoryContext = await this.getMemoryContext(message);
         // Build system prompt with hub context, genesis knowledge, and memory context
@@ -467,6 +689,7 @@ ${hubContextStr}
             const response = await this.runAgentLoop(messages, systemWithContext, sendMessage, apiKey);
             // Auto-remember important things from the conversation
             await this.autoRemember(message, response);
+            void this.autoCaptureContext(message);
             // Log significant actions to hub
             if (response.length > 100) {
                 const action = message.length > 50 ? message.slice(0, 50) + '...' : message;
@@ -478,16 +701,239 @@ ${hubContextStr}
             const errorMessage = error instanceof Error ? error.message : String(error);
             return `Error: ${errorMessage}`;
         }
+        finally {
+            this.attachmentContext = null;
+        }
+    }
+    tryHandleCalendarTodo(message) {
+        const todoItems = this.extractTodoItems(message);
+        const calendarEvents = this.extractCalendarEvents(message);
+        if (todoItems.length === 0 && calendarEvents.length === 0)
+            return null;
+        const results = [];
+        if (todoItems.length > 0) {
+            const todoRes = this.calendarTools.upsertTodoItems(todoItems);
+            if (!todoRes.success) {
+                return `Failed to update /todo: ${todoRes.error || todoRes.output || 'unknown error'}`;
+            }
+            results.push(`Updated /todo with ${todoItems.length} item(s).`);
+        }
+        if (calendarEvents.length > 0) {
+            const calRes = this.calendarTools.upsertCalendarEvents(calendarEvents);
+            if (!calRes.success) {
+                return `Failed to update /cal: ${calRes.error || calRes.output || 'unknown error'}`;
+            }
+            results.push(`Updated /cal with ${calendarEvents.length} event(s).`);
+        }
+        return `${results.join(' ')} Open /todo or /cal to view.`;
+    }
+    extractTodoItems(message) {
+        const lower = message.toLowerCase();
+        const hasTodoIntent = (/(\s|^)\/todo\b/i.test(message) || /\bto\s+my\s+todo\b/i.test(message) || /\bto\s+my\s+\/todo\b/i.test(message)) &&
+            /\b(add|put|save|store|track)\b/i.test(message);
+        if (!hasTodoIntent)
+            return [];
+        const items = [];
+        const wantSteps = /\b(step\s*[- ]?by\s*[- ]?step|break\s*down|smaller\s*steps|parse\s*it)\b/i.test(message);
+        const hasRag = /\b(rag|retrieval augmented|retrieval-augmented|embedding|embeddings|pierce)\b/i.test(message);
+        const hasWhenIsGood = /\b(whenisgood|when\s+is\s+good|availability|unavailable|schedule|scheduling|lab\s+meeting)\b/i.test(message);
+        if (wantSteps && hasRag) {
+            items.push({ title: '[RAG] Finish embedding Pierce 2025', priority: 'high' }, { title: '[RAG] Ingest/open-source genetics book content', priority: 'high' }, { title: '[RAG] Chunk + embed genetics book (verify coverage)', priority: 'high' }, { title: '[RAG] Build/refresh retrieval index + metadata', priority: 'medium' }, { title: '[RAG] Smoke test RAG queries + failure cases', priority: 'medium' }, { title: '[RAG] Create student access + usage instructions', priority: 'medium' }, { title: '[RAG] Grant access to students + announce', priority: 'medium' });
+        }
+        if (wantSteps && hasWhenIsGood) {
+            items.push({ title: '[Meetings] Review WhenIsGood results (unavailability)', priority: 'high' }, { title: '[Meetings] Build availability matrix per student', priority: 'high' }, { title: '[Meetings] Identify 2–3 candidate lab meeting slots', priority: 'medium' }, { title: '[Meetings] Decide lab meeting time + confirm with group', priority: 'medium' }, { title: '[Meetings] Pick individual meeting times for each student', priority: 'medium' }, { title: '[Meetings] Send invites/confirmations', priority: 'medium' }, { title: '[Meetings] Add meetings to /cal', priority: 'medium' });
+        }
+        if (!wantSteps || (items.length === 0 && (hasRag || hasWhenIsGood))) {
+            const raw = message.trim().slice(0, 240);
+            items.push({
+                title: `[Todo] ${raw}${message.trim().length > 240 ? '…' : ''}`,
+                priority: 'medium',
+                notes: message.trim()
+            });
+        }
+        return items;
+    }
+    extractCalendarEvents(message) {
+        const hasCalendarIntent = /\bto\s+my\s+cal\b/i.test(message) ||
+            /\bto\s+my\s+calendar\b/i.test(message) ||
+            /(\s|^)\/cal\b/i.test(message) ||
+            /(\s|^)\/calendar\b/i.test(message);
+        const hasAddIntent = /\b(add|put|schedule|book)\b/i.test(message);
+        if (!hasAddIntent)
+            return [];
+        const candidates = message
+            .split(/\n\s*\n/)
+            .map((chunk) => chunk.trim())
+            .filter(Boolean);
+        const events = [];
+        for (const chunk of candidates) {
+            const parsed = this.parseCalendarEvent(chunk, hasCalendarIntent);
+            if (parsed)
+                events.push(parsed);
+        }
+        return events;
+    }
+    parseCalendarEvent(message, hasCalendarIntent) {
+        const explicit = this.parseExplicitDateTimeEvent(message, hasCalendarIntent);
+        if (explicit)
+            return explicit;
+        const weekdayMatch = message.match(/\b(mon(?:day)?|tue(?:sday)?|wed(?:nesday)?|thu(?:rsday)?|fri(?:day)?|sat(?:urday)?|sun(?:day)?)\b/i);
+        const timeMatch = message.match(/\b(\d{1,2})(?::(\d{2}))?\s*(a|am|p|pm)\s*-\s*(\d{1,2})(?::(\d{2}))?\s*(a|am|p|pm)\b/i);
+        if (!weekdayMatch || !timeMatch)
+            return null;
+        const weekday = weekdayMatch[1].slice(0, 3).toLowerCase();
+        const weekdayIndex = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 }[weekday];
+        const startTime = this.to24h(timeMatch[1], timeMatch[2], timeMatch[3]);
+        const endTime = this.to24h(timeMatch[4], timeMatch[5], timeMatch[6]);
+        const startDate = this.nextOccurrence(weekdayIndex, startTime);
+        const dateKey = this.toDateKey(startDate);
+        const title = message
+            .replace(/^\s*add\s+/i, '')
+            .replace(/\s+to\s+\b(mon(?:day)?|tue(?:sday)?|wed(?:nesday)?|thu(?:rsday)?|fri(?:day)?|sat(?:urday)?|sun(?:day)?)\b[\s\S]*$/i, '')
+            .trim();
+        if (!title)
+            return null;
+        return {
+            title,
+            date: dateKey,
+            startTime,
+            endTime,
+            calendarId: 'primary'
+        };
+    }
+    parseExplicitDateTimeEvent(message, hasCalendarIntent) {
+        if (!hasCalendarIntent)
+            return null;
+        // e.g. "Tuesday, January 13, 3:30 pm, A211 PDB—TITLE, \"Talk...\" ... Host: ..."
+        const monthMatch = message.match(/\b(jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\b/i);
+        if (!monthMatch)
+            return null;
+        const monthText = monthMatch[1].slice(0, 3).toLowerCase();
+        const monthIndex = { jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11 }[monthText];
+        const dayMatch = message.match(new RegExp(`${monthMatch[1]}\\s+(\\d{1,2})`, 'i'));
+        const timeMatch = message.match(/\b(\d{1,2})(?::(\d{2}))?\s*(a|am|p|pm)\b/i);
+        if (!dayMatch || !timeMatch)
+            return null;
+        const dayOfMonth = Number(dayMatch[1]);
+        const startTime = this.to24h(timeMatch[1], timeMatch[2], timeMatch[3]);
+        const yearMatch = message.match(/\b(20\d{2})\b/);
+        const now = new Date();
+        const year = yearMatch ? Number(yearMatch[1]) : now.getFullYear();
+        const date = new Date(year, monthIndex, dayOfMonth, 0, 0, 0, 0);
+        const dateKey = this.toDateKey(date);
+        const cleaned = message
+            .replace(/^\s*add\s+(these\s+)?to\s+my\s+(cal|calendar)\b[:\s-]*/i, '')
+            .trim();
+        const parts = cleaned.split(/—|--|–/);
+        const head = parts[0] || cleaned;
+        const after = parts.slice(1).join('—').trim();
+        // Try to extract a succinct title from the segment after the location delimiter, otherwise use head.
+        const titleCandidate = after ? after : head;
+        const title = titleCandidate
+            .replace(/^[^A-Za-z0-9]*\b(mon(?:day)?|tue(?:sday)?|wed(?:nesday)?|thu(?:rsday)?|fri(?:day)?|sat(?:urday)?|sun(?:day)?)\b[, ]*/i, '')
+            .replace(/\b(jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:tember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\b\s+\d{1,2}(?:,\s*\d{4})?/i, '')
+            .replace(/\b\d{1,2}(?::\d{2})?\s*(a|am|p|pm)\b/i, '')
+            .replace(/^[,\s]+|[,\s]+$/g, '')
+            .slice(0, 160);
+        if (!title)
+            return null;
+        const notes = cleaned.length > title.length ? cleaned : undefined;
+        return {
+            title,
+            date: dateKey,
+            startTime,
+            calendarId: 'primary',
+            notes
+        };
+    }
+    to24h(hourText, minuteText, meridiemText) {
+        const hour = Number(hourText);
+        const minute = Number(minuteText || '0');
+        const meridiem = meridiemText.toLowerCase();
+        let h = hour % 12;
+        if (meridiem.startsWith('p'))
+            h += 12;
+        return `${String(h).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+    }
+    nextOccurrence(weekdayIndex, startTime) {
+        const now = new Date();
+        const candidate = new Date(now);
+        candidate.setHours(0, 0, 0, 0);
+        const delta = (weekdayIndex - candidate.getDay() + 7) % 7;
+        candidate.setDate(candidate.getDate() + delta);
+        if (startTime) {
+            const [h, m] = startTime.split(':').map(Number);
+            candidate.setHours(h, m, 0, 0);
+            if (candidate.getTime() <= now.getTime()) {
+                candidate.setDate(candidate.getDate() + 7);
+            }
+        }
+        return candidate;
+    }
+    toDateKey(date) {
+        const year = date.getFullYear();
+        const month = `${date.getMonth() + 1}`.padStart(2, '0');
+        const day = `${date.getDate()}`.padStart(2, '0');
+        return `${year}-${month}-${day}`;
     }
     /**
      * Get relevant memory context for a message
+     * Routes based on instanceMode:
+     * - personal: search personal memories + all team memories
+     * - team: search ONLY team memory (never personal - team Lia is isolated)
      */
     async getMemoryContext(message) {
         try {
+            const sections = [];
+            // Team mode: ONLY search team memory - never personal
+            if (this.instanceMode === 'team') {
+                if (!this.orgMemory) {
+                    return null;
+                }
+                const teamMemories = await this.orgMemory.search(message, { limit: 10 });
+                const teamMemoryLines = teamMemories.map(m => `[team:${m.type}] ${m.content}`).join('\n');
+                const teamContextSummary = this.orgContextGraph
+                    ? await this.orgContextGraph.getContextSummary(message, { limit: 5 })
+                    : null;
+                if (teamMemoryLines)
+                    sections.push(`TEAM MEMORIES:\n${teamMemoryLines}`);
+                if (teamContextSummary)
+                    sections.push(`TEAM CONTEXT:\n${teamContextSummary}`);
+                if (sections.length === 0)
+                    return null;
+                return sections.join('\n\n');
+            }
+            // Personal mode: search personal + all team memories
             const memories = await this.memory.search(message, { limit: 5 });
-            if (memories.length === 0)
+            const memoryLines = memories.map(m => `[${m.type}] ${m.content}`).join('\n');
+            const contextSummary = await this.contextGraph.getContextSummary(message, { limit: 3 });
+            if (memoryLines)
+                sections.push(`YOUR MEMORIES:\n${memoryLines}`);
+            if (contextSummary)
+                sections.push(`YOUR CONTEXT:\n${contextSummary}`);
+            // In personal mode, also include all team memories for reading
+            for (const [orgId, orgMem] of this.userOrgMemories) {
+                try {
+                    const teamMems = await orgMem.search(message, { limit: 3 });
+                    if (teamMems.length > 0) {
+                        const teamLines = teamMems.map(m => `[${m.type}] ${m.content}`).join('\n');
+                        sections.push(`TEAM (${orgId}) MEMORIES:\n${teamLines}`);
+                    }
+                    const teamGraph = this.userOrgContextGraphs.get(orgId);
+                    if (teamGraph) {
+                        const teamContext = await teamGraph.getContextSummary(message, { limit: 2 });
+                        if (teamContext) {
+                            sections.push(`TEAM (${orgId}) CONTEXT:\n${teamContext}`);
+                        }
+                    }
+                }
+                catch {
+                    // Skip failed team memory access
+                }
+            }
+            if (sections.length === 0)
                 return null;
-            return memories.map(m => `[${m.type}] ${m.content}`).join('\n');
+            return sections.join('\n\n');
         }
         catch {
             return null;
@@ -495,6 +941,9 @@ ${hubContextStr}
     }
     /**
      * Auto-remember important information from conversations
+     * Routes based on instanceMode:
+     * - personal: write to personal memory
+     * - team: write to team memory
      */
     async autoRemember(userMessage, response) {
         // Look for preference indicators
@@ -502,16 +951,140 @@ ${hubContextStr}
         const lower = userMessage.toLowerCase();
         for (const indicator of prefIndicators) {
             if (lower.includes(indicator)) {
-                await this.memory.remember(userMessage, {
-                    type: 'semantic',
-                    source: 'auto-extract',
-                    importance: 0.7,
-                    tags: ['preference', 'user']
-                });
+                // Route to correct memory store based on instanceMode
+                const targetMemory = this.instanceMode === 'team' ? this.orgMemory : this.memory;
+                if (targetMemory) {
+                    await targetMemory.remember(userMessage, {
+                        type: 'semantic',
+                        source: 'auto-extract',
+                        importance: 0.7,
+                        tags: ['preference', this.instanceMode === 'team' ? 'team' : 'user']
+                    });
+                }
                 break;
             }
         }
     }
+    async autoCaptureContext(userMessage) {
+        const marker = '📎 Attached files:';
+        const base = userMessage.split(marker)[0]?.trim() || '';
+        if (!base || base.startsWith('/'))
+            return;
+        const text = base.replace(/\s+/g, ' ').trim();
+        const shareToOrg = !!this.orgContextGraph &&
+            /\b(share with team|team files|shared with team|team-wide|org-wide|company-wide)\b/i.test(text);
+        const graphs = shareToOrg && this.orgContextGraph
+            ? [this.contextGraph, this.orgContextGraph]
+            : [this.contextGraph];
+        const seenEntities = new Set();
+        const tasks = [];
+        const rememberEntity = (kind, name, attributes) => {
+            const cleaned = this.normalizeEntityName(name);
+            if (!cleaned || this.isIgnoredEntity(cleaned))
+                return;
+            for (const graph of graphs) {
+                const scopeLabel = graph === this.orgContextGraph ? 'org' : 'user';
+                const key = `${scopeLabel}:${kind}:${cleaned.toLowerCase()}`;
+                if (seenEntities.has(key))
+                    continue;
+                seenEntities.add(key);
+                tasks.push(graph.upsertEntity({
+                    kind,
+                    name: cleaned,
+                    attributes,
+                    tags: ['ctx:auto']
+                }));
+            }
+        };
+        const rememberRelation = (from, to, type, fromKind, toKind) => {
+            const fromClean = this.normalizeEntityName(from);
+            const toClean = this.normalizeEntityName(to);
+            if (!fromClean || !toClean || this.isIgnoredEntity(fromClean) || this.isIgnoredEntity(toClean))
+                return;
+            for (const graph of graphs) {
+                tasks.push(graph.linkEntities({
+                    from: fromClean,
+                    to: toClean,
+                    type,
+                    fromKind,
+                    toKind,
+                    source: 'auto-capture'
+                }));
+            }
+        };
+        const emailMatches = text.match(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi) || [];
+        for (const email of emailMatches.slice(0, 5)) {
+            rememberEntity('person', email, { email });
+        }
+        for (const match of text.matchAll(/\bproject\s+([A-Za-z0-9][\w .'-]{1,60})/gi)) {
+            rememberEntity('project', match[1]);
+        }
+        for (const match of text.matchAll(/\bteam\s+([A-Za-z0-9][\w .'-]{1,50})/gi)) {
+            rememberEntity('team', match[1]);
+        }
+        for (const match of text.matchAll(/\b([A-Za-z0-9][\w .'-]{1,50})\s+team\b/gi)) {
+            rememberEntity('team', match[1]);
+        }
+        for (const match of text.matchAll(/\b(company|org|organization)\s+([A-Za-z0-9][\w .'-]{1,60})/gi)) {
+            rememberEntity('org', match[2]);
+        }
+        for (const match of text.matchAll(/\b(tool|platform|stack|using)\s+([A-Za-z0-9][\w .'-]{1,40})/gi)) {
+            rememberEntity('tool', match[2]);
+        }
+        for (const match of text.matchAll(/([A-Za-z][\w .'-]{1,50})\s+(works on|working on)\s+(?:the\s+)?project\s+([A-Za-z0-9][\w .'-]{1,60})/gi)) {
+            rememberRelation(match[1], match[3], 'works_on', 'person', 'project');
+        }
+        for (const match of text.matchAll(/([A-Za-z][\w .'-]{1,50})\s+owns\s+(?:the\s+)?project\s+([A-Za-z0-9][\w .'-]{1,60})/gi)) {
+            rememberRelation(match[1], match[2], 'owns', 'person', 'project');
+        }
+        for (const match of text.matchAll(/([A-Za-z][\w .'-]{1,50})\s+leads\s+(?:the\s+)?([A-Za-z0-9][\w .'-]{1,50})\s+team/gi)) {
+            rememberRelation(match[1], match[2], 'leads', 'person', 'team');
+        }
+        for (const match of text.matchAll(/([A-Za-z][\w .'-]{1,50})\s+is\s+on\s+the\s+([A-Za-z0-9][\w .'-]{1,50})\s+team/gi)) {
+            rememberRelation(match[1], match[2], 'member_of', 'person', 'team');
+        }
+        for (const match of text.matchAll(/project\s+([A-Za-z0-9][\w .'-]{1,60})\s+depends on\s+project\s+([A-Za-z0-9][\w .'-]{1,60})/gi)) {
+            rememberRelation(match[1], match[2], 'depends_on', 'project', 'project');
+        }
+        for (const match of text.matchAll(/([A-Za-z][\w .'-]{1,50})\s+reports to\s+([A-Za-z0-9][\w .'-]{1,50})/gi)) {
+            rememberRelation(match[1], match[2], 'reports_to', 'person', 'person');
+        }
+        for (const match of text.matchAll(/([A-Za-z][\w .'-]{1,50})\s+uses\s+([A-Za-z0-9][\w .'-]{1,40})/gi)) {
+            const subject = match[1];
+            const tool = match[2];
+            const lowered = subject.toLowerCase();
+            let subjectKind = 'person';
+            let subjectName = subject;
+            if (lowered.includes('team')) {
+                subjectKind = 'team';
+                subjectName = subject.replace(/team/gi, '').trim();
+            }
+            else if (lowered.includes('project')) {
+                subjectKind = 'project';
+                subjectName = subject.replace(/project/gi, '').trim();
+            }
+            rememberEntity('tool', tool);
+            rememberRelation(subjectName, tool, 'uses', subjectKind, 'tool');
+        }
+        if (tasks.length > 0) {
+            try {
+                await Promise.all(tasks);
+            }
+            catch {
+                // Best-effort; context capture should never block responses.
+            }
+        }
+    }
+    normalizeEntityName(name) {
+        return name.replace(/["'`]/g, '').replace(/\s+/g, ' ').trim();
+    }
+    isIgnoredEntity(name) {
+        if (!name || name.length < 2 || name.length > 80)
+            return true;
+        const lower = name.toLowerCase();
+        const ignored = new Set(['i', 'we', 'you', 'they', 'he', 'she', 'it', 'our', 'my', 'your', 'their']);
+        return ignored.has(lower);
+    }
     /**
      * Run the agentic loop
      * @param apiKey Optional per-request API key (creates temporary client)
@@ -521,17 +1094,28 @@ ${hubContextStr}
         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 response = await client.messages.create({
-                model: this.model,
-                max_tokens: this.maxTokens,
-                system,
-                tools,
-                messages: currentMessages
-            });
+            const requestStart = Date.now();
+            console.log(`[ORCHESTRATOR] Anthropic request ${iterations}/${maxIterations} (model: ${this.model})`);
+            const response = await Promise.race([
+                client.messages.create({
+                    model: this.model,
+                    max_tokens: this.maxTokens,
+                    system,
+                    tools,
+                    messages: currentMessages
+                }),
+                new Promise((_, reject) => {
+                    setTimeout(() => {
+                        reject(new Error(`Anthropic request timed out after ${requestTimeoutMs}ms`));
+                    }, requestTimeoutMs);
+                })
+            ]);
+            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)) {
                 return this.extractText(response.content);
@@ -576,6 +1160,87 @@ For ANY file creation, editing, or system modification, use delegate_to_worker i
                     required: ['command']
                 }
             },
+            {
+                name: 'calendar_upsert_events',
+                description: `Create or update calendar events for /cal.
+
+Writes ONLY to ~/Lia-Hub/shared/outputs/.lia/calendar.json (creates the directory/file if missing).`,
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        events: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    id: { type: 'string' },
+                                    title: { type: 'string' },
+                                    date: { type: 'string', description: 'YYYY-MM-DD' },
+                                    startTime: { type: 'string', description: 'HH:MM (24h) or ISO timestamp' },
+                                    endTime: { type: 'string', description: 'HH:MM (24h) or ISO timestamp' },
+                                    calendarId: { type: 'string' },
+                                    notes: { type: 'string' }
+                                },
+                                required: ['title']
+                            }
+                        },
+                        calendars: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    id: { type: 'string' },
+                                    name: { type: 'string' },
+                                    color: { type: 'string' }
+                                },
+                                required: ['id', 'name']
+                            },
+                            description: 'Optional calendar definitions; omitted to keep existing.'
+                        }
+                    },
+                    required: ['events']
+                }
+            },
+            {
+                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).`,
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        items: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    id: { type: 'string' },
+                                    title: { type: 'string' },
+                                    done: { type: 'boolean' },
+                                    due: { type: 'string' },
+                                    priority: { type: 'string', enum: ['low', 'medium', 'high'] },
+                                    notes: { type: 'string' },
+                                    subtasks: {
+                                        type: 'array',
+                                        items: {
+                                            type: 'object',
+                                            properties: {
+                                                id: { type: 'string' },
+                                                title: { type: 'string' },
+                                                done: { type: 'boolean' },
+                                                notes: { type: 'string' }
+                                            },
+                                            required: ['title']
+                                        }
+                                    }
+                                },
+                                required: ['title']
+                            }
+                        }
+                    },
+                    required: ['items']
+                }
+            },
             // Web tools
             {
                 name: 'web_search',
@@ -759,6 +1424,110 @@ Be specific about what you want done.`,
                     required: ['content']
                 }
             },
+            {
+                name: 'remember_entity',
+                description: 'Store or update a team context entity (person, team, project, tool, task, doc).',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        kind: {
+                            type: 'string',
+                            enum: ContextGraphKinds.entities,
+                            description: 'Entity kind'
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'Entity name'
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Short description or role'
+                        },
+                        attributes: {
+                            type: 'object',
+                            description: 'Optional key/value attributes',
+                            additionalProperties: { type: 'string' }
+                        },
+                        tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                            description: 'Optional tags'
+                        },
+                        scope: {
+                            type: 'string',
+                            enum: ['user', 'org'],
+                            description: 'Where to store the entity (default: user)'
+                        }
+                    },
+                    required: ['kind', 'name']
+                }
+            },
+            {
+                name: 'remember_relation',
+                description: 'Link two entities with a relationship (depends_on, works_on, member_of, etc).',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        from: {
+                            type: 'string',
+                            description: 'Entity name or key'
+                        },
+                        to: {
+                            type: 'string',
+                            description: 'Entity name or key'
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ContextGraphKinds.relations,
+                            description: 'Relationship type'
+                        },
+                        from_kind: {
+                            type: 'string',
+                            enum: ContextGraphKinds.entities,
+                            description: 'Optional kind hint for from'
+                        },
+                        to_kind: {
+                            type: 'string',
+                            enum: ContextGraphKinds.entities,
+                            description: 'Optional kind hint for to'
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Optional relation detail'
+                        },
+                        scope: {
+                            type: 'string',
+                            enum: ['user', 'org'],
+                            description: 'Where to store the relation (default: user)'
+                        }
+                    },
+                    required: ['from', 'to', 'type']
+                }
+            },
+            {
+                name: 'search_context',
+                description: 'Search the context graph for entities and relationships.',
+                input_schema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'What to search for'
+                        },
+                        kind: {
+                            type: 'string',
+                            enum: ContextGraphKinds.entities,
+                            description: 'Optional entity kind filter'
+                        },
+                        scope: {
+                            type: 'string',
+                            enum: ['user', 'org'],
+                            description: 'Which context scope to search (default: user)'
+                        }
+                    },
+                    required: ['query']
+                }
+            },
             {
                 name: 'search_memory',
                 description: 'Search your memory for relevant information. Use before delegating to include user context.',
@@ -859,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: []
+                }
             }
         ];
     }
@@ -882,6 +1699,12 @@ Be specific about what you want done.`,
                 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;
@@ -892,12 +1715,14 @@ Be specific about what you want done.`,
                     });
                     break;
                 // Worker tools
-                case 'spawn_worker':
-                    result = await this.workerTools.spawnWorker(input.task, {
+                case 'spawn_worker': {
+                    const { task } = this.withAttachments(input.task);
+                    result = await this.workerTools.spawnWorker(task, {
                         timeout: input.timeout,
                         priority: input.priority
                     });
                     break;
+                }
                 case 'check_worker':
                     result = await this.workerTools.checkWorker(input.job_id);
                     break;
@@ -911,12 +1736,68 @@ Be specific about what you want done.`,
                     result = await this.workerTools.cancelWorker(input.job_id);
                     break;
                 // Legacy delegate tool
-                case 'delegate_to_worker':
-                    result = await this.delegateToWorker(input.task, input.context, input.working_directory);
+                case 'delegate_to_worker': {
+                    const { task, context } = this.withAttachments(input.task, input.context);
+                    result = await this.delegateToWorker(task, context, input.working_directory);
                     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.' };
+                        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.' };
+                        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.' };
+                        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;
@@ -938,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}` };
             }
@@ -999,10 +1890,31 @@ Be specific about what you want done.`,
         };
         // Escape single quotes in prompt for shell safety
         const escapedPrompt = prompt.replace(/'/g, "'\\''");
+        const claudeCmd = `${this.claudePath} -p '${escapedPrompt}' --output-format text --dangerously-skip-permissions`;
+        const isRoot = process.getuid?.() === 0;
+        const shellCmd = isRoot
+            ? `runuser -u lia -m -- /bin/bash -l -c "${claudeCmd.replace(/"/g, '\\"')}"`
+            : claudeCmd;
+        let workerUser = process.env.USER || 'lia';
+        let workerLogname = process.env.LOGNAME || workerUser;
+        if (isRoot) {
+            workerUser = 'lia';
+            workerLogname = 'lia';
+        }
+        const spawnEnv = {
+            ...process.env,
+            ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+            GH_TOKEN: process.env.GH_TOKEN,
+            GITHUB_TOKEN: process.env.GITHUB_TOKEN,
+            HOME: cwd,
+            LIA_WORKSPACE: cwd,
+            USER: workerUser,
+            LOGNAME: workerLogname
+        };
         // Spawn worker
-        const child = spawn('/bin/bash', ['-l', '-c', `claude -p '${escapedPrompt}' --dangerously-skip-permissions`], {
+        const child = spawn('/bin/bash', ['-l', '-c', shellCmd], {
             cwd,
-            env: { ...process.env },
+            env: spawnEnv,
             stdio: ['pipe', 'pipe', 'pipe']
         });
         job.process = child;
@@ -1024,12 +1936,18 @@ Be specific about what you want done.`,
             job.output += text;
             // Stream output to console
             process.stdout.write(`[${id}] ${text}`);
+            if (this.workerLogCallback) {
+                this.workerLogCallback(id, text, 'stdout');
+            }
         });
         child.stderr?.on('data', (data) => {
             const text = data.toString();
             if (!text.includes('Checking') && !text.includes('Connected')) {
                 job.output += text;
             }
+            if (this.workerLogCallback) {
+                this.workerLogCallback(id, text, 'stderr');
+            }
         });
         child.on('close', async (code) => {
             clearTimeout(timeout);
@@ -1196,9 +2114,24 @@ Be specific about what you want done.`,
     }
     /**
      * Execute remember tool
+     * Routes writes based on instanceMode:
+     * - personal: write to personal memory only
+     * - team: write to team memory only
      */
     async executeRemember(content, type, importance) {
         try {
+            // Team mode: write to org memory only
+            if (this.instanceMode === 'team') {
+                if (!this.orgMemory) {
+                    return { success: false, output: 'Team memory not configured. Cannot store team memory.' };
+                }
+                const id = await this.orgMemory.remember(content, {
+                    type: type || undefined,
+                    importance
+                });
+                return { success: true, output: `Remembered in team memory (${id})` };
+            }
+            // Personal mode: write to personal memory only
             const id = await this.memory.remember(content, {
                 type: type || undefined,
                 importance
@@ -1211,17 +2144,53 @@ Be specific about what you want done.`,
     }
     /**
      * Execute search memory tool
+     * Routes searches based on instanceMode:
+     * - personal: search personal + all team memories
+     * - team: search team memory only (never personal)
      */
     async executeSearchMemory(query, type) {
         try {
-            const memories = await this.memory.search(query, {
+            const searchOpts = {
                 type: type || undefined,
                 limit: 10
-            });
-            if (memories.length === 0) {
+            };
+            // Team mode: search only team memory
+            if (this.instanceMode === 'team') {
+                if (!this.orgMemory) {
+                    return { success: false, output: 'Team memory not configured.' };
+                }
+                const memories = await this.orgMemory.search(query, searchOpts);
+                if (memories.length === 0) {
+                    return { success: true, output: 'No relevant team memories found.' };
+                }
+                const output = memories.map(m => `[team:${m.type}] (${(m.importance * 100).toFixed(0)}%) ${m.content}`).join('\n\n');
+                return { success: true, output };
+            }
+            // Personal mode: search personal + all team memories
+            const allMemories = [];
+            // Search personal memories
+            const personalMemories = await this.memory.search(query, { ...searchOpts, limit: 5 });
+            for (const m of personalMemories) {
+                allMemories.push({ source: 'personal', memory: m });
+            }
+            // Search all team memories user belongs to
+            for (const [orgId, orgMem] of this.userOrgMemories) {
+                try {
+                    const teamMems = await orgMem.search(query, { ...searchOpts, limit: 3 });
+                    for (const m of teamMems) {
+                        allMemories.push({ source: `team:${orgId}`, memory: m });
+                    }
+                }
+                catch {
+                    // Skip failed team memory searches
+                }
+            }
+            if (allMemories.length === 0) {
                 return { success: true, output: 'No relevant memories found.' };
             }
-            const output = memories.map(m => `[${m.type}] (${(m.importance * 100).toFixed(0)}%) ${m.content}`).join('\n\n');
+            // Sort by importance and format
+            allMemories.sort((a, b) => b.memory.importance - a.memory.importance);
+            const output = allMemories.map(({ source, memory: m }) => `[${source}:${m.type}] (${(m.importance * 100).toFixed(0)}%) ${m.content}`).join('\n\n');
             return { success: true, output };
         }
         catch (error) {
@@ -1363,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
      */
@@ -1396,6 +2425,12 @@ Be specific about what you want done.`,
                 return `Delegating: ${input.task.slice(0, 60)}...`;
             case 'remember':
                 return `Remembering: ${input.content.slice(0, 50)}...`;
+            case 'remember_entity':
+                return `Remembering entity: ${input.name}`;
+            case 'remember_relation':
+                return `Linking context: ${input.from} -> ${input.type} -> ${input.to}`;
+            case 'search_context':
+                return `Searching context: ${input.query}`;
             case 'search_memory':
                 return `Searching memory: ${input.query}`;
             case 'schedule_task':
@@ -1406,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;
         }
@@ -1438,5 +2479,24 @@ Be specific about what you want done.`,
         else {
             this.memory.close();
         }
+        if (this.orgMemory) {
+            if (this.orgMemory instanceof PostgresMemoryStore) {
+                await this.orgMemory.close();
+            }
+            else {
+                this.orgMemory.close();
+            }
+        }
+        // Close all user org memory stores (for personal mode reading team memories)
+        for (const [, orgMem] of this.userOrgMemories) {
+            if (orgMem instanceof PostgresMemoryStore) {
+                await orgMem.close();
+            }
+            else {
+                orgMem.close();
+            }
+        }
+        this.userOrgMemories.clear();
+        this.userOrgContextGraphs.clear();
     }
 }