create-walle 0.9.11 → 0.9.13

package/template/claude-task-manager/lib/session-jobs.js

@@ -16,6 +16,7 @@ const path = require('path');
 const os = require('os');
 const { verifyCandidateForTab, readFirstUserMessage, wordOverlap } = require('./session-verify.js');
 const { verifyLineage } = require('./session-lineage.js');
+const claudeDesktopSessions = require('./claude-desktop-sessions');
 
 const HOSTNAME = os.hostname();
 const fsp = fs.promises;
@@ -133,8 +134,10 @@ function registerSessionJobs(scheduler, deps) {
       for (let index = 0; index < files.length; index++) {
         const { filePath, projectPath, projectEntry } = files[index];
         try {
-          const sessionId = path.basename(filePath).replace(/\.jsonl(\.bak)?$/, '');
-          const stat = await fsp.stat(filePath);
+          const virtualSession = claudeDesktopSessions.parseVirtualSessionPath(filePath);
+          const sessionId = virtualSession ? virtualSession.sessionId : path.basename(filePath).replace(/\.jsonl(\.bak)?$/, '');
+          const statPath = claudeDesktopSessions.sourcePathForStat(filePath);
+          const stat = await fsp.stat(statPath);
           const modifiedAt = stat.mtime.toISOString();
           const existing = existingMap.get(sessionId);
 
@@ -174,6 +177,7 @@ function registerSessionJobs(scheduler, deps) {
               fileSize: parsed.fileSize,
               modifiedAt: parsed.modifiedAt,
               firstMessage: parsed.firstMessage || '',
+              createdAt: parsed.timestamp || '',
               provider: parsed.agent || 'claude',
               model: parsed.modelId || '',
               gitBranch: parsed.gitBranch || '',
@@ -191,6 +195,7 @@ function registerSessionJobs(scheduler, deps) {
               fileSize: parsed.fileSize,
               modifiedAt: parsed.modifiedAt,
               firstMessage: parsed.firstMessage || '',
+              createdAt: parsed.timestamp || '',
               provider: parsed.agent || 'claude',
               model: parsed.modelId || '',
               gitBranch: parsed.gitBranch || '',
@@ -234,7 +239,7 @@ function registerSessionJobs(scheduler, deps) {
         const rows = db.prepare(
           "SELECT id, jsonl_path FROM sessions WHERE jsonl_path != '' AND jsonl_path IS NOT NULL AND (user_msg_count = 0 OR user_msg_count IS NULL)"
         ).all();
-        const toDelete = rows.filter(r => !fs.existsSync(r.jsonl_path)).map(r => r.id);
+        const toDelete = rows.filter(r => !fs.existsSync(claudeDesktopSessions.sourcePathForStat(r.jsonl_path))).map(r => r.id);
         if (toDelete.length > 0) {
           const txn = db.transaction(() => {
             const stmt = db.prepare("DELETE FROM sessions WHERE id = ?");
@@ -249,7 +254,7 @@ function registerSessionJobs(scheduler, deps) {
         const rows = db.prepare(
           "SELECT a.agent_session_id, a.jsonl_path, a.ctm_session_id FROM agent_sessions a WHERE a.jsonl_path != '' AND a.jsonl_path IS NOT NULL"
         ).all();
-        const missingFiles = rows.filter(r => !fs.existsSync(r.jsonl_path));
+        const missingFiles = rows.filter(r => !fs.existsSync(claudeDesktopSessions.sourcePathForStat(r.jsonl_path)));
         if (missingFiles.length > 0) {
           const txn = db.transaction(() => {
             const delAgent = db.prepare("DELETE FROM agent_sessions WHERE agent_session_id = ?");
@@ -296,7 +301,7 @@ function registerSessionJobs(scheduler, deps) {
         try {
           if (!row.jsonl_path) continue;
           let stat;
-          try { stat = await fsp.stat(row.jsonl_path); } catch { continue; }
+          try { stat = await fsp.stat(claudeDesktopSessions.sourcePathForStat(row.jsonl_path)); } catch { continue; }
           const newMtime = stat.mtime.toISOString();
           if (row.file_size !== stat.size || row.modified_at !== newMtime) {
             updateMetadata.run(stat.size, newMtime, row.agent_session_id);

package/template/claude-task-manager/lib/session-stream.js

@@ -11,6 +11,7 @@ const PTY_ACTIVE_WINDOW_MS = 5000;
 const JSONL_ACTIVE_WINDOW_MS = 10000;
 const IDLE_THRESHOLD_MS = 30000;
 const SUMMARY_DEBOUNCE_MS = 2000;
+const SUMMARY_RETRY_COOLDOWN_MS = 60000;
 const PROMPT_CACHE_TEXT_LIMIT = 4000;
 const SUMMARY_TEXT_LIMIT = 220;
 const PROGRESS_BULLET_LIMIT = 3;
@@ -149,6 +150,35 @@ function truncateText(text, limit) {
   return t.slice(0, Math.max(0, limit - 3)).trimEnd() + '...';
 }
 
+function roleForEventType(type) {
+  if (type === 'user' || type === 'assistant') return type;
+  if (type === 'tool_result') return 'tool';
+  if (type === 'summary') return 'system';
+  return 'event';
+}
+
+function captureKindForEventType(type) {
+  if (type === 'user' || type === 'assistant') return 'message';
+  if (type === 'tool_result') return 'tool_result';
+  if (type === 'summary') return 'summary';
+  return 'event';
+}
+
+function decorateStreamEvent(evt, source = 'jsonl') {
+  if (!evt || typeof evt !== 'object') return evt;
+  const out = {
+    ...evt,
+    schemaVersion: 1,
+    eventId: evt.eventId || `${evt.sessionId || 'session'}:${evt.seq ?? 'x'}:${evt.type || 'event'}`,
+    captureKind: evt.captureKind || captureKindForEventType(evt.type),
+    role: evt.role || roleForEventType(evt.type),
+    source: evt.source || source,
+    agentSessionId: evt.agentSessionId || evt.sessionId,
+  };
+  if (out.text == null && out.data && typeof out.data.text === 'string') out.text = out.data.text;
+  return out;
+}
+
 // --- SessionStream: EventEmitter-based structured event stream ---
 
 class SessionStream extends EventEmitter {
@@ -158,12 +188,13 @@ class SessionStream extends EventEmitter {
    * @param {Map} opts.sessions - CTM in-memory sessions map
    * @param {number} [opts.ringSize=200]
    */
-  constructor({ jsonlWatcher, sessions, ringSize = DEFAULT_RING_SIZE, dbModule } = {}) {
+  constructor({ jsonlWatcher, sessions, ringSize = DEFAULT_RING_SIZE, dbModule, summaryProvider } = {}) {
     super();
     this._jsonlWatcher = jsonlWatcher;
     this._sessions = sessions;
     this._ringSize = ringSize;
     this._dbModule = dbModule || null;
+    this._summaryProvider = typeof summaryProvider === 'function' ? summaryProvider : null;
     this._tailer = new JsonlTailer();
     this._stopped = false;
 
@@ -285,6 +316,9 @@ class SessionStream extends EventEmitter {
     const summary = summaryRecord?.text || (st.cachedSummary?.model === 'fallback' ? st.cachedSummary.text : null);
     const intent = this._buildIntent(summaryRecord, displayPromptEntry, lastPromptEntry);
     const progress = this._buildProgress(st, intent);
+    if (!summaryRecord && st.cachedSummary?.model === 'fallback') {
+      this._maybeRetryFallbackSummary(sessionId, st);
+    }
 
     return {
       sessionId,
@@ -374,12 +408,14 @@ class SessionStream extends EventEmitter {
     if (jsonlPath) {
       this._readAndProcess(agentSessionId, jsonlPath, { drain: true, rememberStat: true }).catch(() => {});
     }
+    this.emit('link', { ctmSessionId, agentSessionId, jsonlPath });
   }
 
   /** Clean up on session exit */
   removeSession(agentSessionId) {
     const st = this._state.get(agentSessionId);
     if (!st) return;
+    const ctmSessionId = st.ctmSessionId;
     // Emit final status
     const oldStatus = this._computeStatus(st);
     if (oldStatus !== 'exited') {
@@ -391,6 +427,7 @@ class SessionStream extends EventEmitter {
     const timer = this._summaryTimers.get(agentSessionId);
     if (timer) { clearTimeout(timer); this._summaryTimers.delete(agentSessionId); }
     this._state.delete(agentSessionId);
+    this.emit('unlink', { ctmSessionId, agentSessionId });
   }
 
   /** Get the set of actively tracked session IDs */
@@ -444,6 +481,7 @@ class SessionStream extends EventEmitter {
       lastJsonlActivity: 0,
       lastAssistantParent: null,
       cachedSummary: null,
+      lastSummaryAttempt: 0,
       lastKnownSize: 0,
       lastKnownMtime: 0,
     };
@@ -514,7 +552,7 @@ class SessionStream extends EventEmitter {
       let text = extractText(content);
       if (text.length > MAX_TEXT_LEN) text = text.slice(0, MAX_TEXT_LEN) + `...truncated (${text.length} chars)`;
 
-      const evt = {
+      const evt = decorateStreamEvent({
         type: 'user',
         sessionId: agentSessionId,
         ctmSessionId: st.ctmSessionId,
@@ -527,7 +565,7 @@ class SessionStream extends EventEmitter {
           gitBranch: entry.gitBranch || undefined,
           parentUuid: entry.uuid || undefined,
         },
-      };
+      }, 'claude-jsonl');
       st.ring.push(evt);
       if (st.ring.length > this._ringSize) st.ring.shift();
       this._markJsonlActivity(st, timestamp);
@@ -550,7 +588,7 @@ class SessionStream extends EventEmitter {
         // Find and replace last assistant event with this parentUuid
         for (let i = st.ring.length - 1; i >= 0; i--) {
           if (st.ring[i].type === 'assistant' && st.ring[i].data.parentUuid === parentUuid) {
-            st.ring[i] = {
+            st.ring[i] = decorateStreamEvent({
               ...st.ring[i],
               timestamp,
               data: {
@@ -560,7 +598,7 @@ class SessionStream extends EventEmitter {
                 toolUses: toolUses.length ? toolUses : undefined,
                 parentUuid,
               },
-            };
+            }, 'claude-jsonl');
             this._markJsonlActivity(st, timestamp);
             this._emitEvent(agentSessionId, { ...st.ring[i], _update: true }, 'event:update');
             return;
@@ -569,7 +607,7 @@ class SessionStream extends EventEmitter {
       }
 
       st.lastAssistantParent = parentUuid;
-      const evt = {
+      const evt = decorateStreamEvent({
         type: 'assistant',
         sessionId: agentSessionId,
         ctmSessionId: st.ctmSessionId,
@@ -582,7 +620,7 @@ class SessionStream extends EventEmitter {
           toolUses: toolUses.length ? toolUses : undefined,
           parentUuid,
         },
-      };
+      }, 'claude-jsonl');
       st.ring.push(evt);
       if (st.ring.length > this._ringSize) st.ring.shift();
 
@@ -601,7 +639,7 @@ class SessionStream extends EventEmitter {
       let text = extractText(content || '');
       if (text.length > MAX_TEXT_LEN) text = text.slice(0, MAX_TEXT_LEN) + `...truncated (${text.length} chars)`;
 
-      const evt = {
+      const evt = decorateStreamEvent({
         type: 'tool_result',
         sessionId: agentSessionId,
         ctmSessionId: st.ctmSessionId,
@@ -611,7 +649,7 @@ class SessionStream extends EventEmitter {
           text,
           contentBlocks: stripBase64Blobs(Array.isArray(content) ? content : []),
         },
-      };
+      }, 'claude-jsonl');
       st.ring.push(evt);
       if (st.ring.length > this._ringSize) st.ring.shift();
       this._markJsonlActivity(st, timestamp);
@@ -628,7 +666,7 @@ class SessionStream extends EventEmitter {
       if (!key || st.codexUserSeen.has(key)) return true;
       st.codexUserSeen.add(key);
       const timestamp = eventTimestampMs({ timestamp: msg.timestamp });
-      const evt = {
+      const evt = decorateStreamEvent({
         type: 'user',
         sessionId: agentSessionId,
         ctmSessionId: st.ctmSessionId,
@@ -638,7 +676,7 @@ class SessionStream extends EventEmitter {
           text: msg.text.length > MAX_TEXT_LEN ? msg.text.slice(0, MAX_TEXT_LEN) + `...truncated (${msg.text.length} chars)` : msg.text,
           contentBlocks: [{ type: 'text', text: msg.text }],
         },
-      };
+      }, 'codex-jsonl');
       st.ring.push(evt);
       if (st.ring.length > this._ringSize) st.ring.shift();
       this._markJsonlActivity(st, timestamp);
@@ -651,14 +689,14 @@ class SessionStream extends EventEmitter {
       const timestamp = eventTimestampMs({ timestamp: msg.timestamp });
       const text = msg.text.length > MAX_TEXT_LEN ? msg.text.slice(0, MAX_TEXT_LEN) + `...truncated (${msg.text.length} chars)` : msg.text;
       const oldStatus = this._computeStatus(st);
-      const evt = {
+      const evt = decorateStreamEvent({
         type: 'assistant',
         sessionId: agentSessionId,
         ctmSessionId: st.ctmSessionId,
         timestamp,
         seq: st.seq++,
         data: { text, contentBlocks: [{ type: 'text', text }] },
-      };
+      }, 'codex-jsonl');
       st.ring.push(evt);
       if (st.ring.length > this._ringSize) st.ring.shift();
       this._markJsonlActivity(st, timestamp);
@@ -1007,7 +1045,17 @@ class SessionStream extends EventEmitter {
     }, SUMMARY_DEBOUNCE_MS));
   }
 
+  _maybeRetryFallbackSummary(agentSessionId, st) {
+    if (!this._summaryProvider || !st) return;
+    if (this._summaryTimers.has(agentSessionId)) return;
+    const now = Date.now();
+    const lastAttempt = st.lastSummaryAttempt || st.cachedSummary?.timestamp || 0;
+    if (lastAttempt && now - lastAttempt < SUMMARY_RETRY_COOLDOWN_MS) return;
+    this._debounceSummary(agentSessionId, st);
+  }
+
   async _generateSummary(agentSessionId, st) {
+    st.lastSummaryAttempt = Date.now();
     // Use userPromptCache (survives ring buffer churn from tool_result-only events)
     const userPrompts = st.userPromptCache.map((entry) => this._promptText(entry)).filter(Boolean);
     if (userPrompts.length === 0) return;
@@ -1015,11 +1063,18 @@ class SessionStream extends EventEmitter {
     const turnsText = userPrompts.map((t, i) => `Prompt ${i + 1}: ${t}`).join('\n');
     const sysPrompt = 'Summarize what the user is working on based on their prompts. 10-15 words. Return ONLY the summary, no quotes or prefix.';
 
-    // Tier 1: cloud Anthropic (when API key is present)
+    // Tier 0: configured Wall-E provider (DeepSeek/OpenAI/Claude/Gemini/etc.).
     let summaryText = '';
     let usedModel = null;
-    const cloud = await this._tryCloudSummary(turnsText, sysPrompt);
-    if (cloud) { summaryText = cloud.text; usedModel = cloud.model; }
+
+    const configured = await this._tryConfiguredSummary(turnsText, sysPrompt);
+    if (configured) { summaryText = configured.text; usedModel = configured.model; }
+
+    // Tier 1: legacy cloud Anthropic (when API key is present)
+    if (!summaryText) {
+      const cloud = await this._tryCloudSummary(turnsText, sysPrompt);
+      if (cloud) { summaryText = cloud.text; usedModel = cloud.model; }
+    }
 
     // Tier 2: local Ollama fallback (when cloud is unavailable or failed)
     if (!summaryText) {
@@ -1034,14 +1089,14 @@ class SessionStream extends EventEmitter {
         model: usedModel,
         timestamp: Date.now(),
       };
-      const summaryEvt = {
+      const summaryEvt = decorateStreamEvent({
         type: 'summary',
         sessionId: agentSessionId,
         ctmSessionId: st.ctmSessionId,
         timestamp: Date.now(),
         seq: st.seq++,
         data: st.cachedSummary,
-      };
+      }, 'summary');
       st.ring.push(summaryEvt);
       if (st.ring.length > this._ringSize) st.ring.shift();
       this._emitEvent(agentSessionId, summaryEvt);
@@ -1051,6 +1106,19 @@ class SessionStream extends EventEmitter {
     }
   }
 
+  /** Tier 0: CTM-injected Wall-E provider. Returns { text, model } or null. */
+  async _tryConfiguredSummary(turnsText, sysPrompt) {
+    if (!this._summaryProvider) return null;
+    try {
+      const result = await this._summaryProvider({ turnsText, sysPrompt });
+      const text = this._sanitizeSummary(result?.text || '');
+      return text ? { text, model: result?.model || 'configured' } : null;
+    } catch (e) {
+      console.warn('[session-stream] configured summary failed:', e.message);
+      return null;
+    }
+  }
+
   /** Tier 1: Anthropic cloud. Returns { text, model } or null. */
   async _tryCloudSummary(turnsText, sysPrompt) {
     const apiKey = process.env.ANTHROPIC_API_KEY || '';
@@ -1186,4 +1254,4 @@ SessionStream._ACK_TOKENS = new Set([
   'a', 'an', 'the', 'to', 'main', 'that', 'this',
 ]);
 
-module.exports = { SessionStream, JsonlTailer };
+module.exports = { SessionStream, JsonlTailer, decorateStreamEvent };

package/template/claude-task-manager/lib/setup-provider-config.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const SETUP_PROVIDER_TYPES = Object.freeze([
+  'anthropic',
+  'openai',
+  'google',
+  'ollama',
+  'deepseek',
+]);
+
+const SETUP_PROVIDER_NAMES = Object.freeze({
+  anthropic: 'Anthropic',
+  openai: 'OpenAI',
+  google: 'Google Gemini',
+  ollama: 'Ollama (Local)',
+  deepseek: 'DeepSeek',
+});
+
+const SETUP_PROVIDER_ENV_KEYS = Object.freeze({
+  anthropic: 'ANTHROPIC_API_KEY',
+  openai: 'OPENAI_API_KEY',
+  google: 'GOOGLE_API_KEY',
+  deepseek: 'DEEPSEEK_API_KEY',
+});
+
+const SETUP_LOCAL_PROVIDER_TYPES = Object.freeze([
+  'ollama',
+  'mlx',
+]);
+
+const SETUP_KEYLESS_AUTH_METHODS = Object.freeze({
+  anthropic: ['claude_cli', 'oauth_proxy', 'devbox'],
+  openai: ['codex_cli'],
+});
+
+function sanitizeSetupProviderType(value) {
+  return typeof value === 'string'
+    ? value.toLowerCase().replace(/[^a-z]/g, '').slice(0, 20)
+    : '';
+}
+
+function sanitizeSetupModel(value) {
+  return typeof value === 'string'
+    ? value.replace(/[\r\n\s]/g, '').slice(0, 100)
+    : '';
+}
+
+function isSetupProviderType(value) {
+  return SETUP_PROVIDER_TYPES.includes(sanitizeSetupProviderType(value));
+}
+
+function setupProviderTypeList() {
+  return SETUP_PROVIDER_TYPES.join(', ');
+}
+
+function resolveSetupDefaultSelection({ type, model, storedModel }) {
+  const providerType = sanitizeSetupProviderType(type);
+  if (!isSetupProviderType(providerType)) {
+    return {
+      ok: false,
+      type: providerType,
+      error: 'Invalid provider type. Must be one of: ' + setupProviderTypeList(),
+    };
+  }
+  const requestedModel = sanitizeSetupModel(model);
+  const fallbackModel = sanitizeSetupModel(storedModel);
+  return {
+    ok: true,
+    type: providerType,
+    requestedModel,
+    targetModel: requestedModel || fallbackModel,
+  };
+}
+
+function setupProviderAuthMethodHasRuntimeAccess(type, authMethod) {
+  const providerType = sanitizeSetupProviderType(type);
+  const method = typeof authMethod === 'string' ? authMethod.trim() : '';
+  return (SETUP_KEYLESS_AUTH_METHODS[providerType] || []).includes(method);
+}
+
+function setupProviderHasRuntimeAccess({ type, env = process.env, authMethod = '', hasStoredKey = false } = {}) {
+  const providerType = sanitizeSetupProviderType(type);
+  if (SETUP_LOCAL_PROVIDER_TYPES.includes(providerType)) return true;
+  if (hasStoredKey) return true;
+  if (setupProviderAuthMethodHasRuntimeAccess(providerType, authMethod)) return true;
+
+  if (providerType === 'anthropic') {
+    return !!(env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_BASE_URL);
+  }
+  if (providerType === 'openai') {
+    return !!env.OPENAI_API_KEY;
+  }
+  if (providerType === 'google') {
+    return !!(env.GOOGLE_API_KEY || env.GEMINI_API_KEY);
+  }
+  if (providerType === 'deepseek') {
+    return !!env.DEEPSEEK_API_KEY;
+  }
+  return false;
+}
+
+module.exports = {
+  SETUP_PROVIDER_TYPES,
+  SETUP_PROVIDER_NAMES,
+  SETUP_PROVIDER_ENV_KEYS,
+  SETUP_LOCAL_PROVIDER_TYPES,
+  SETUP_KEYLESS_AUTH_METHODS,
+  sanitizeSetupProviderType,
+  sanitizeSetupModel,
+  isSetupProviderType,
+  setupProviderTypeList,
+  resolveSetupDefaultSelection,
+  setupProviderAuthMethodHasRuntimeAccess,
+  setupProviderHasRuntimeAccess,
+};

package/template/claude-task-manager/lib/walle-ctm-history.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const fs = require('fs');
+
+function cloneToolCalls(toolCalls) {
+  return JSON.parse(JSON.stringify(toolCalls || []));
+}
+
+function applyWalleToolEvent(toolCalls, event) {
+  if (!event || typeof event !== 'object') return toolCalls;
+  if (event.type === 'tool_call') {
+    toolCalls.push({
+      name: event.tool || event.name || 'tool',
+      summary: event.summary || '',
+      args: event.args || null,
+      status: 'working',
+      output: '',
+    });
+    return toolCalls;
+  }
+  if (event.type === 'tool_result' || event.type === 'tool_done') {
+    if (!toolCalls.length) return toolCalls;
+    const idx = toolCalls.length - 1;
+    const tc = toolCalls[idx];
+    tc.status = event.error ? 'error' : 'done';
+    tc.summary = event.summary || tc.summary || '';
+    tc.output = event.output || event.result || '';
+  }
+  return toolCalls;
+}
+
+function readWalleCtmHistory(filePath) {
+  let raw = '';
+  try { raw = fs.readFileSync(filePath, 'utf8'); } catch { return []; }
+  const messages = [];
+  let pendingToolCalls = [];
+  for (const line of raw.split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    if (entry.type === 'user') {
+      messages.push({
+        role: 'user',
+        content: entry.content || '',
+        timestamp: entry.timestamp || 0,
+      });
+      continue;
+    }
+    if (entry.type === 'tool_call' || entry.type === 'tool_result' || entry.type === 'tool_done') {
+      applyWalleToolEvent(pendingToolCalls, entry);
+      continue;
+    }
+    if (entry.type === 'assistant') {
+      messages.push({
+        role: 'assistant',
+        content: entry.content || '',
+        model: entry.model || '',
+        latency_ms: entry.latencyMs || entry.latency_ms || 0,
+        timestamp: entry.timestamp || 0,
+        toolCalls: entry.toolCalls || cloneToolCalls(pendingToolCalls),
+      });
+      pendingToolCalls = [];
+    }
+  }
+  return messages;
+}
+
+module.exports = {
+  applyWalleToolEvent,
+  cloneToolCalls,
+  readWalleCtmHistory,
+};

package/template/claude-task-manager/lib/walle-session-context.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function pathExists(p) {
+  if (!p || typeof p !== 'string') return false;
+  try { return fs.existsSync(path.resolve(p)); } catch { return false; }
+}
+
+function firstExistingPath(paths) {
+  for (const p of paths) {
+    if (pathExists(p)) return path.resolve(p);
+  }
+  return '';
+}
+
+function sessionLabel(session) {
+  return session?.label || session?.meta?.label || '';
+}
+
+function resolveWalleChatContext({ session, contextSession, requestedCwd } = {}) {
+  const candidates = [];
+  if (requestedCwd) candidates.push({ cwd: requestedCwd, source: 'request', sessionId: null, label: '' });
+  if (contextSession && contextSession.id !== session?.id) {
+    candidates.push(
+      { cwd: contextSession.worktree_path, source: 'context_worktree', sessionId: contextSession.id, label: sessionLabel(contextSession) },
+      { cwd: contextSession.cwd, source: 'context_session', sessionId: contextSession.id, label: sessionLabel(contextSession) },
+      { cwd: contextSession.meta?.worktree_path, source: 'context_worktree', sessionId: contextSession.id, label: sessionLabel(contextSession) },
+      { cwd: contextSession.meta?.cwd, source: 'context_session', sessionId: contextSession.id, label: sessionLabel(contextSession) },
+    );
+  }
+  candidates.push(
+    { cwd: session?.worktree_path, source: 'walle_worktree', sessionId: session?.id || null, label: sessionLabel(session) },
+    { cwd: session?.cwd, source: 'walle_session', sessionId: session?.id || null, label: sessionLabel(session) },
+    { cwd: session?.meta?.worktree_path, source: 'walle_worktree', sessionId: session?.id || null, label: sessionLabel(session) },
+    { cwd: session?.meta?.cwd, source: 'walle_session', sessionId: session?.id || null, label: sessionLabel(session) },
+  );
+
+  for (const candidate of candidates) {
+    const cwd = firstExistingPath([candidate.cwd]);
+    if (!cwd) continue;
+    return {
+      cwd,
+      source: candidate.source,
+      contextSessionId: candidate.sessionId,
+      contextSessionLabel: candidate.label,
+    };
+  }
+
+  return {
+    cwd: '',
+    source: 'none',
+    contextSessionId: null,
+    contextSessionLabel: '',
+  };
+}
+
+module.exports = {
+  resolveWalleChatContext,
+};