tide-commander 1.82.1 → 1.83.0

package/dist/assets/{web-Bq91XvJE.js → web-D1aYcbd6.js}

@@ -1 +1 @@
-import{cg as a}from"./main-DnI9VapU.js";import{ImpactStyle as i,NotificationType as r}from"./index-Du9hl6DN.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};
+import{cg as a}from"./main-CHfGSVnw.js";import{ImpactStyle as i,NotificationType as r}from"./index-DVqDWfDB.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};

package/dist/assets/{web-ttfy3Zlk.js → web-rv0WAVTk.js}

@@ -1 +1 @@
-import{cg as s}from"./main-DnI9VapU.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};
+import{cg as s}from"./main-CHfGSVnw.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};

package/dist/index.html

@@ -22,10 +22,10 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/icons/favicon-16x16.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/icons/apple-touch-icon.png" />
     <title>Tide Commander</title>
-    <script type="module" crossorigin src="/assets/main-DnI9VapU.js"></script>
+    <script type="module" crossorigin src="/assets/main-CHfGSVnw.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-react--Eh9ivFN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-three-Chj50gSY.js">
-    <link rel="stylesheet" crossorigin href="/assets/main-DrNeyjdE.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-DmmvYoEs.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/src/packages/server/claude/runner/internal-events.js

@@ -1,3 +1,4 @@
+import { withAgentContext } from '../../utils/log-context.js';
 export class RunnerInternalEventBus {
     handlers = new Map();
     on(type, handler) {
@@ -15,8 +16,10 @@ export class RunnerInternalEventBus {
         if (!handlers || handlers.size === 0) {
             return;
         }
-        for (const handler of handlers) {
-            handler(event);
-        }
+        withAgentContext(event.agentId, () => {
+            for (const handler of handlers) {
+                handler(event);
+            }
+        });
     }
 }

package/dist/src/packages/server/claude/runner.js

@@ -4,6 +4,7 @@
  */
 import { ClaudeBackend } from './backend.js';
 import { createLogger } from '../utils/logger.js';
+import { withAgentContext } from '../utils/log-context.js';
 import { isProcessRunning } from '../data/index.js';
 import { sendToTmux, hasTmuxSession, tmuxSessionName, getTmuxPanePid } from './runner/tmux-helper.js';
 import { spawn } from 'child_process';
@@ -333,9 +334,12 @@ export class ClaudeRunner {
         }
     }
     async run(request) {
-        await this.lifecycle.run(request);
+        await withAgentContext(request.agentId, () => this.lifecycle.run(request));
     }
     sendMessage(agentId, message) {
+        return withAgentContext(agentId, () => this.sendMessageImpl(agentId, message));
+    }
+    sendMessageImpl(agentId, message) {
         const activeProcess = this.activeProcesses.get(agentId);
         if (!activeProcess) {
             log.error(`❌ [SEND_MESSAGE] No active process for agent ${agentId}`);
@@ -571,23 +575,22 @@ export class ClaudeRunner {
         log.log(`✅ [TMUX] Reconnected to tmux session ${sessionName} for agent ${agentId}`);
     }
     interrupt(agentId) {
-        return this.lifecycle.interrupt(agentId);
+        return withAgentContext(agentId, () => this.lifecycle.interrupt(agentId));
     }
     getActiveProcessCount() {
         return this.activeProcesses.size;
     }
     async stop(agentId, clearQueue = true) {
-        // Only clear queued messages on explicit user-initiated stops.
-        // Respawns (watchdog, auto-restart) should preserve the queue so
-        // messages sent while the agent was processing are not lost.
-        if (clearQueue && this.messageQueue.has(agentId)) {
-            const count = this.messageQueue.get(agentId).length;
-            this.messageQueue.delete(agentId);
-            if (count > 0) {
-                log.log(`🗑️ [QUEUE] Agent ${agentId}: Discarded ${count} queued message(s) on stop`);
+        await withAgentContext(agentId, async () => {
+            if (clearQueue && this.messageQueue.has(agentId)) {
+                const count = this.messageQueue.get(agentId).length;
+                this.messageQueue.delete(agentId);
+                if (count > 0) {
+                    log.log(`🗑️ [QUEUE] Agent ${agentId}: Discarded ${count} queued message(s) on stop`);
+                }
             }
-        }
-        await this.lifecycle.stop(agentId);
+            await this.lifecycle.stop(agentId);
+        });
     }
     async stopAll(killProcesses = true, clearQueue = true) {
         if (this.persistTimer) {

package/dist/src/packages/server/claude/session-loader.js

@@ -417,6 +417,246 @@ export async function listSessions(cwd) {
     sessions.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
     return sessions;
 }
+const FIRST_PROMPT_MAX_LEN = 240;
+const SEARCH_SNIPPET_MAX_LEN = 280;
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max - 1) + '…';
+}
+function extractClaudeMessageText(message) {
+    if (!message || typeof message !== 'object')
+        return '';
+    const m = message;
+    const content = m.content;
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const block of content) {
+            if (block && typeof block === 'object' && 'type' in block && block.type === 'text') {
+                const text = block.text;
+                if (typeof text === 'string')
+                    parts.push(text);
+            }
+        }
+        return parts.join('\n');
+    }
+    return '';
+}
+/**
+ * Read the first up-to-`maxLines` JSONL records of a session file. Used to
+ * cheaply recover `cwd` and the first user prompt without parsing the whole
+ * conversation. Falls back to a single readFileSync slice for very small files.
+ */
+async function readSessionHeader(filePath, maxLines = 20) {
+    let cwd = '';
+    let firstPrompt = '';
+    try {
+        const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+        let lineCount = 0;
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            lineCount += 1;
+            try {
+                const obj = JSON.parse(line);
+                if (!cwd && typeof obj.cwd === 'string')
+                    cwd = obj.cwd;
+                // queue-operation enqueue rows carry the user's prompt as `content`
+                if (!firstPrompt && obj.type === 'queue-operation' && obj.operation === 'enqueue') {
+                    const content = obj.content;
+                    if (typeof content === 'string')
+                        firstPrompt = content;
+                }
+                if (!firstPrompt && obj.type === 'user') {
+                    const text = extractClaudeMessageText(obj.message);
+                    if (text)
+                        firstPrompt = text;
+                }
+                if (cwd && firstPrompt)
+                    break;
+            }
+            catch {
+                // ignore malformed lines
+            }
+            if (lineCount >= maxLines)
+                break;
+        }
+        rl.close();
+        stream.destroy();
+    }
+    catch {
+        // unreadable file — return empty defaults
+    }
+    return { cwd, firstPrompt: truncate(firstPrompt, FIRST_PROMPT_MAX_LEN) };
+}
+/**
+ * List every Claude session across every project directory.
+ *
+ * Cheap: only stats each .jsonl and reads the first few lines for cwd/firstPrompt.
+ * Skips message-count computation by default to keep the operation fast even
+ * across hundreds of sessions.
+ */
+export async function listAllSessions(options) {
+    if (!fs.existsSync(PROJECTS_DIR))
+        return [];
+    const projectDirs = fs.readdirSync(PROJECTS_DIR);
+    const all = [];
+    for (const projectDir of projectDirs) {
+        const fullProjectPath = path.join(PROJECTS_DIR, projectDir);
+        let entries;
+        try {
+            entries = fs.readdirSync(fullProjectPath, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith('.jsonl'))
+                continue;
+            const sessionId = entry.name.replace(/\.jsonl$/, '');
+            const filePath = path.join(fullProjectPath, entry.name);
+            let stats;
+            try {
+                stats = fs.statSync(filePath);
+            }
+            catch {
+                continue;
+            }
+            all.push({
+                sessionId,
+                projectPath: '',
+                projectDir,
+                lastModified: stats.mtime,
+                messageCount: 0,
+                firstPrompt: '',
+                sizeBytes: stats.size,
+            });
+        }
+    }
+    all.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+    const limit = options?.limit ?? all.length;
+    const limited = all.slice(0, limit);
+    // Enrich with cwd + firstPrompt (and optionally messageCount). Run concurrently
+    // but cap concurrency so we don't open hundreds of file handles at once.
+    const concurrency = 8;
+    let cursor = 0;
+    const workers = [];
+    for (let i = 0; i < concurrency; i++) {
+        workers.push((async () => {
+            while (cursor < limited.length) {
+                const idx = cursor++;
+                const item = limited[idx];
+                const filePath = path.join(PROJECTS_DIR, item.projectDir, `${item.sessionId}.jsonl`);
+                const header = await readSessionHeader(filePath);
+                item.projectPath = header.cwd;
+                item.firstPrompt = header.firstPrompt;
+                if (options?.includeMessageCount) {
+                    try {
+                        const content = fs.readFileSync(filePath, 'utf-8');
+                        const lines = content.split('\n');
+                        let count = 0;
+                        for (const line of lines) {
+                            if (!line.trim())
+                                continue;
+                            try {
+                                const obj = JSON.parse(line);
+                                if (obj.type === 'user' || obj.type === 'assistant')
+                                    count++;
+                            }
+                            catch { /* ignore */ }
+                        }
+                        item.messageCount = count;
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        })());
+    }
+    await Promise.all(workers);
+    return limited;
+}
+/**
+ * Full-text search every Claude session for `query`. Streams files line-by-line
+ * so memory usage stays bounded even with many large sessions.
+ */
+export async function searchAllSessions(query, options) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return [];
+    const queryLower = trimmed.toLowerCase();
+    const limit = options?.limit ?? 100;
+    const cwdFilter = options?.cwdFilter?.toLowerCase();
+    const sessions = await listAllSessions({ limit: 1000 });
+    const out = [];
+    const concurrency = 6;
+    let cursor = 0;
+    const workers = [];
+    for (let i = 0; i < concurrency; i++) {
+        workers.push((async () => {
+            while (cursor < sessions.length) {
+                const idx = cursor++;
+                const session = sessions[idx];
+                if (cwdFilter && !session.projectPath.toLowerCase().includes(cwdFilter))
+                    continue;
+                const filePath = path.join(PROJECTS_DIR, session.projectDir, `${session.sessionId}.jsonl`);
+                let totalMatches = 0;
+                let snippet = '';
+                try {
+                    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+                    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+                    for await (const line of rl) {
+                        if (!line)
+                            continue;
+                        // Skip the cheap path: just lowercase the raw line and substring search.
+                        // This avoids parsing every JSON record but matches inside any field
+                        // (message text, tool args, etc.) — fine for a UX search.
+                        if (!line.toLowerCase().includes(queryLower))
+                            continue;
+                        totalMatches++;
+                        if (!snippet) {
+                            // try to extract a clean text snippet from message content
+                            try {
+                                const obj = JSON.parse(line);
+                                if (obj.type === 'user' || obj.type === 'assistant') {
+                                    const text = extractClaudeMessageText(obj.message);
+                                    if (text)
+                                        snippet = text;
+                                }
+                                else if (obj.type === 'queue-operation' && typeof obj.content === 'string') {
+                                    snippet = obj.content;
+                                }
+                            }
+                            catch { /* fall through to raw-line snippet */ }
+                            if (!snippet)
+                                snippet = line;
+                            snippet = truncate(snippet.replace(/\s+/g, ' ').trim(), SEARCH_SNIPPET_MAX_LEN);
+                        }
+                    }
+                    rl.close();
+                    stream.destroy();
+                }
+                catch { /* unreadable — skip */ }
+                if (totalMatches > 0) {
+                    out.push({
+                        sessionId: session.sessionId,
+                        projectPath: session.projectPath,
+                        projectDir: session.projectDir,
+                        lastModified: session.lastModified,
+                        totalMatches,
+                        snippet,
+                        firstPrompt: session.firstPrompt,
+                    });
+                }
+            }
+        })());
+    }
+    await Promise.all(workers);
+    out.sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+    return out.slice(0, limit);
+}
 /**
  * Wait for file to be stable (not actively being written)
  * Checks if file size remains constant over a small interval

package/dist/src/packages/server/routes/agents.js

@@ -13,6 +13,7 @@ import { loadSession } from '../claude/session-loader.js';
 import { getAllCustomClasses } from '../services/custom-class-service.js';
 // Session listing is done inline for performance
 import { createLogger } from '../utils/logger.js';
+import { withAgentContext } from '../utils/log-context.js';
 import { truncateOrEmpty } from '../utils/string.js';
 import { buildCustomAgentConfig } from '../websocket/handlers/command-handler.js';
 import { clearDelegation, getBossForSubordinate } from '../websocket/handlers/boss-response-handler.js';
@@ -21,6 +22,9 @@ import { getSystemPrompt, setSystemPrompt, clearSystemPrompt, isEchoPromptEnable
 import { getBackupStatus, setBackupEnabled } from '../services/backup-service.js';
 const log = createLogger('Routes');
 const router = Router();
+router.param('id', (req, _res, next, id) => {
+    withAgentContext(typeof id === 'string' ? id : undefined, () => next());
+});
 // Store for broadcasting via WebSocket
 let broadcastFn = null;
 /**

package/dist/src/packages/server/routes/index.js

@@ -22,6 +22,7 @@ import triggerRouter, { setBroadcast as setTriggerBroadcast } from './trigger-ro
 import integrationRouter from './integration-routes.js';
 import eventRouter from './event-routes.js';
 import workflowRouter from './workflow-routes.js';
+import sessionsRouter from './sessions.js';
 import { getPlugins } from '../integrations/integration-registry.js';
 const router = Router();
 // Health check
@@ -46,6 +47,7 @@ router.use('/triggers', triggerRouter);
 router.use('/integrations', integrationRouter);
 router.use('/events', eventRouter);
 router.use('/workflows', workflowRouter);
+router.use('/sessions', sessionsRouter);
 // Integration plugin routes (e.g. /api/slack/*, /api/documents/*, /api/jira/*)
 // Uses lazy lookup so plugins can be registered after route setup
 router.use((req, res, next) => {

package/dist/src/packages/server/routes/sessions.js

@@ -0,0 +1,93 @@
+/**
+ * Sessions Routes
+ *
+ * Cross-project (cwd-agnostic) session discovery and preview. Pairs with the
+ * global Session Finder modal in the client. Restoring a session onto an agent
+ * is still done over the WebSocket `restore_session` message, which now accepts
+ * an optional `cwd` to support cross-project attach.
+ */
+import { Router } from 'express';
+import { listAllSessions, searchAllSessions, loadSession } from '../claude/session-loader.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('Routes');
+const router = Router();
+// GET /api/sessions/global?limit=200&includeMessageCount=false
+router.get('/global', async (req, res) => {
+    try {
+        const limit = Math.max(1, Math.min(parseInt(req.query.limit) || 200, 1000));
+        const includeMessageCount = req.query.includeMessageCount === 'true';
+        const sessions = await listAllSessions({ limit, includeMessageCount });
+        res.json({
+            sessions: sessions.map((s) => ({
+                sessionId: s.sessionId,
+                projectPath: s.projectPath,
+                projectDir: s.projectDir,
+                lastModified: s.lastModified.toISOString(),
+                messageCount: s.messageCount,
+                firstPrompt: s.firstPrompt,
+                sizeBytes: s.sizeBytes,
+            })),
+        });
+    }
+    catch (err) {
+        log.error(' Failed to list global sessions:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// GET /api/sessions/search?q=...&limit=100&cwdFilter=...
+router.get('/search', async (req, res) => {
+    try {
+        const q = req.query.q || '';
+        if (!q.trim()) {
+            res.status(400).json({ error: 'Query parameter "q" is required' });
+            return;
+        }
+        const limit = Math.max(1, Math.min(parseInt(req.query.limit) || 100, 500));
+        const cwdFilter = req.query.cwdFilter || undefined;
+        const matches = await searchAllSessions(q, { limit, cwdFilter });
+        res.json({
+            query: q,
+            matches: matches.map((m) => ({
+                sessionId: m.sessionId,
+                projectPath: m.projectPath,
+                projectDir: m.projectDir,
+                lastModified: m.lastModified.toISOString(),
+                totalMatches: m.totalMatches,
+                snippet: m.snippet,
+                firstPrompt: m.firstPrompt,
+            })),
+        });
+    }
+    catch (err) {
+        log.error(' Failed to search global sessions:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// GET /api/sessions/preview?cwd=...&sessionId=...&limit=30
+router.get('/preview', async (req, res) => {
+    try {
+        const cwd = req.query.cwd || '';
+        const sessionId = req.query.sessionId || '';
+        if (!cwd || !sessionId) {
+            res.status(400).json({ error: 'Both "cwd" and "sessionId" query parameters are required' });
+            return;
+        }
+        const limit = Math.max(1, Math.min(parseInt(req.query.limit) || 30, 200));
+        const history = await loadSession(cwd, sessionId, limit, 0);
+        if (!history) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        res.json({
+            sessionId: history.sessionId,
+            cwd: history.cwd,
+            messages: history.messages,
+            totalCount: history.totalCount,
+        });
+    }
+    catch (err) {
+        log.error(' Failed to load session preview:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+export default router;

package/dist/src/packages/server/services/runtime-command-execution.js

@@ -1,8 +1,12 @@
 import * as agentService from './agent-service.js';
+import { withAgentContext } from '../utils/log-context.js';
 import { clearPendingSilentContextRefresh, clearStdinWatchdog, hasPendingSilentContextRefresh, markPendingSilentContextRefresh, startStdinWatchdog, } from './runtime-watchdog.js';
 export function createRuntimeCommandExecution(deps) {
     const { log, getRunner, getRunnerForAgent, notifyCommandStarted, emitOutput, killDetachedProviderProcessInCwd, } = deps;
     async function executeCommand(agentId, command, systemPrompt, forceNewSession, customAgent, silent, skipNotify) {
+        return withAgentContext(agentId, () => executeCommandImpl(agentId, command, systemPrompt, forceNewSession, customAgent, silent, skipNotify));
+    }
+    async function executeCommandImpl(agentId, command, systemPrompt, forceNewSession, customAgent, silent, skipNotify) {
         const agent = agentService.getAgent(agentId);
         if (!agent) {
             throw new Error(`Agent not found: ${agentId}`);
@@ -59,6 +63,9 @@ export function createRuntimeCommandExecution(deps) {
         });
     }
     async function sendCommand(agentId, command, systemPrompt, forceNewSession, customAgent) {
+        return withAgentContext(agentId, () => sendCommandImpl(agentId, command, systemPrompt, forceNewSession, customAgent));
+    }
+    async function sendCommandImpl(agentId, command, systemPrompt, forceNewSession, customAgent) {
         const agent = agentService.getAgent(agentId);
         if (!agent) {
             throw new Error(`Agent not found: ${agentId}`);
@@ -181,6 +188,9 @@ export function createRuntimeCommandExecution(deps) {
         await executeCommand(agentId, command, systemPrompt, forceNewSession, customAgent);
     }
     async function sendSilentCommand(agentId, command) {
+        return withAgentContext(agentId, () => sendSilentCommandImpl(agentId, command));
+    }
+    async function sendSilentCommandImpl(agentId, command) {
         const agent = agentService.getAgent(agentId);
         if (!agent) {
             throw new Error(`Agent not found: ${agentId}`);
@@ -210,6 +220,9 @@ export function createRuntimeCommandExecution(deps) {
         await executeCommand(agentId, command, undefined, undefined, undefined, true);
     }
     async function stopAgent(agentId) {
+        return withAgentContext(agentId, () => stopAgentImpl(agentId));
+    }
+    async function stopAgentImpl(agentId) {
         // Cancel any pending stdin watchdog timer to prevent it from respawning
         // the process after we've stopped it
         clearStdinWatchdog(agentId);

package/dist/src/packages/server/utils/index.js

@@ -1,4 +1,5 @@
 export * from './logger.js';
+export * from './log-context.js';
 export * from './unicode.js';
 export * from './string.js';
 export * from './tool-formatting.js';

package/dist/src/packages/server/utils/log-context.js

@@ -0,0 +1,10 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const als = new AsyncLocalStorage();
+export function withAgentContext(agentId, fn) {
+    if (!agentId)
+        return fn();
+    return als.run({ agentId }, fn);
+}
+export function getCurrentAgentId() {
+    return als.getStore()?.agentId;
+}

package/dist/src/packages/server/utils/logger.js

@@ -5,6 +5,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { getCurrentAgentId } from './log-context.js';
 const fileLogConfig = {
     enabled: true,
     directory: path.join(process.cwd(), 'logs'),
@@ -180,6 +181,10 @@ function formatMessage(level, context, message, ...args) {
     const timestampStr = `${colors.dim}${timestamp}${colors.reset}`;
     const levelStr = `${color}${colors.bright}${label.padStart(7)}${colors.reset}`;
     const contextStr = `${colors.yellow}[${context}]${colors.reset}`;
+    const agentId = getCurrentAgentId();
+    const agentStr = agentId
+        ? ` ${colors.cyan}[agentId=${agentId}]${colors.reset}`
+        : '';
     let formattedMessage = message;
     if (args.length > 0) {
         const argsStr = args.map(arg => {
@@ -195,7 +200,7 @@ function formatMessage(level, context, message, ...args) {
         }).join(' ');
         formattedMessage = `${message} ${colors.cyan}${argsStr}${colors.reset}`;
     }
-    return `${appName} ${pidStr}  - ${timestampStr}  ${levelStr} ${contextStr} ${formattedMessage}`;
+    return `${appName} ${pidStr}  - ${timestampStr}  ${levelStr} ${contextStr}${agentStr} ${formattedMessage}`;
 }
 class Logger {
     context;

package/dist/src/packages/server/websocket/handlers/agent-handler.js

@@ -175,6 +175,11 @@ export async function handleClearContext(ctx, payload) {
 }
 /**
  * Handle restore_session message - restores a previous session for an agent
+ *
+ * Optional `cwd` enables cross-project restore from the global Session Finder:
+ * if the chosen session lives in a different project directory than the agent
+ * currently uses, we update the agent's cwd alongside its sessionId so Claude
+ * Code can resolve the JSONL on the next run.
  */
 export async function handleRestoreSession(ctx, payload) {
     const agent = agentService.getAgent(payload.agentId);
@@ -182,13 +187,14 @@ export async function handleRestoreSession(ctx, payload) {
         ctx.sendError(`Agent not found: ${payload.agentId}`);
         return;
     }
-    log.log(`Agent ${agent.name}: Restoring session ${payload.sessionId}`);
+    const targetCwd = payload.cwd && payload.cwd !== agent.cwd ? payload.cwd : undefined;
+    log.log(`Agent ${agent.name}: Restoring session ${payload.sessionId}` +
+        (targetCwd ? ` (cwd change: ${agent.cwd} -> ${targetCwd})` : ''));
     // Archive the current session first (if any)
     agentService.archiveCurrentSession(payload.agentId);
     // Stop any running process
     await runtimeService.stopAgent(payload.agentId);
-    // Set the restored session ID
-    agentService.updateAgent(payload.agentId, {
+    const updates = {
         status: 'idle',
         currentTask: undefined,
         taskLabel: undefined,
@@ -197,8 +203,14 @@ export async function handleRestoreSession(ctx, payload) {
         tokensUsed: 0,
         contextUsed: 0,
         contextStats: undefined,
-    });
-    ctx.sendActivity(payload.agentId, `Session restored - will resume on next command`);
+    };
+    if (targetCwd) {
+        updates.cwd = targetCwd;
+    }
+    agentService.updateAgent(payload.agentId, updates);
+    ctx.sendActivity(payload.agentId, targetCwd
+        ? `Session restored from ${targetCwd} - will resume on next command`
+        : `Session restored - will resume on next command`);
     log.log(`Agent ${agent.name}: Session restored to ${payload.sessionId}`);
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tide-commander",
-  "version": "1.82.1",
+  "version": "1.83.0",
   "description": "Visual multi-agent orchestrator and manager for Claude Code with 3D/2D interface",
   "repository": {
     "type": "git",