tide-commander 1.89.0 → 1.91.0

package/dist/src/packages/server/integrations/whatsapp/whatsapp-client.js

@@ -39,6 +39,10 @@ export class WhatsAppClient {
         const data = await this.request('GET', `/api/sessions/${encodeURIComponent(sessionId)}/contacts`);
         return Array.isArray(data) ? data : [];
     }
+    async getGroups(sessionId) {
+        const data = await this.request('GET', `/api/sessions/${encodeURIComponent(sessionId)}/groups`);
+        return Array.isArray(data) ? data : [];
+    }
     async syncChatMessages(sessionId, chatId, count = 50) {
         return this.request('POST', `/api/sessions/${encodeURIComponent(sessionId)}/chats/${encodeURIComponent(chatId)}/sync-messages?count=${encodeURIComponent(String(count))}`, {});
     }

package/dist/src/packages/server/integrations/whatsapp/whatsapp-trigger-handler.js

@@ -12,8 +12,10 @@ import { loadConfig, WHATSAPP_API_KEY_SECRET } from './whatsapp-config.js';
 import { WhatsAppWsClient } from './whatsapp-ws-client.js';
 import { MessageDedupeCache } from './message-dedupe.js';
 import { ContactNameCache } from './contact-name-cache.js';
+import { GroupNameCache } from './group-name-cache.js';
 import { WhatsAppClient } from './whatsapp-client.js';
 import { createLogger } from '../../utils/logger.js';
+import * as crypto from 'crypto';
 const log = createLogger('WhatsAppTrigger');
 // Module-level subscriber set fed by the in-process bridge whenever a normalized
 // WhatsApp message is broadcast. The trigger-service-facing handler below
@@ -39,7 +41,7 @@ function notifyTriggerSubscribers(payload) {
 // duplicate toasts on the frontend.
 const DEDUPE_MAX_ENTRIES = 256;
 const DEDUPE_TTL_MS = 60_000;
-const CONTACT_NAME_TTL_MS = 5 * 60_000;
+const CONTACT_NAME_TTL_MS = 10 * 60_000;
 export function createWhatsAppTriggerHandler(ctx) {
     let client = null;
     // Per-bridge instance — restarting the plugin clears it.
@@ -50,6 +52,14 @@ export function createWhatsAppTriggerHandler(ctx) {
     // Lazily build a fetcher that picks up live config + secrets each call.
     // The upstream contacts list is what carries pushName — see the file header
     // for why this enrichment exists.
+    //
+    // syncContacts() runs first because the upstream's default /contacts only
+    // exposes a small "blocked + recently active" subset (~39 entries observed).
+    // syncContacts pulls every WhatsApp address-book tier (critical_unblock_low,
+    // regular_high, regular_low, critical_block, regular) — without it, most DM
+    // JIDs miss the cache and bubbles fall back to formatted phone. The cache's
+    // 10-min TTL throttles the sync to at most once per session per window;
+    // upstream returns added:0 quickly when nothing's new.
     const contactNames = new ContactNameCache({
         ttlMs: CONTACT_NAME_TTL_MS,
         fetchContacts: async (sessionId) => {
@@ -58,9 +68,29 @@ export function createWhatsAppTriggerHandler(ctx) {
             if (!apiKey)
                 return [];
             const wac = new WhatsAppClient(cfg.baseUrl, apiKey);
+            try {
+                await wac.syncContacts(sessionId);
+            }
+            catch (err) {
+                ctx.log.warn(`WhatsApp syncContacts failed (continuing with cached list): ${err}`);
+            }
             return wac.getContacts(sessionId);
         },
     });
+    // Same idea but for group subjects: per-message webhook payloads from the
+    // upstream don't carry the group name, so we fetch the groups list once per
+    // session and cache it. See group-name-cache.ts header for the why.
+    const groupNames = new GroupNameCache({
+        ttlMs: CONTACT_NAME_TTL_MS,
+        fetchGroups: async (sessionId) => {
+            const cfg = loadConfig();
+            const apiKey = ctx.secrets.get(WHATSAPP_API_KEY_SECRET);
+            if (!apiKey)
+                return [];
+            const wac = new WhatsAppClient(cfg.baseUrl, apiKey);
+            return wac.getGroups(sessionId);
+        },
+    });
     function start() {
         if (client)
             return;
@@ -84,6 +114,7 @@ export function createWhatsAppTriggerHandler(ctx) {
         }
         dedupe.clear();
         contactNames.clear();
+        groupNames.clear();
     }
     function isRunning() {
         return client !== null;
@@ -112,27 +143,53 @@ export function createWhatsAppTriggerHandler(ctx) {
             const payload = normalizeBaileysMessage(msg.sessionId, msg.event, msg.data, msg.ts, config.baseUrl);
             if (!payload)
                 return;
-            // Enrich inbound DMs/groups whose fromName is still null. The upstream
-            // webhook payload doesn't include pushName (verified in
-            // whatsapp-api/src/webhookHandler.js sendBaileysMessage*Webhook), so
-            // we look it up via the contacts API. Async + cached + best-effort.
-            const needsEnrichment = config.enrichContactName !== false &&
-                payload.direction === 'inbound' &&
+            // Enrich inbound DMs/groups in parallel:
+            //  - fromName from the upstream contacts list (pushName is stripped from
+            //    webhook payloads — see whatsapp-api/src/webhookHandler.js)
+            //  - groupName from the upstream groups list (group subject is also
+            //    absent from per-message webhooks — confirmed in trigger_events for
+            //    the Bolba group: groupName=NULL on every stored event)
+            const enrichContactCfg = config.enrichContactName !== false;
+            // For DMs, `payload.from` is the OTHER party's JID regardless of
+            // direction (Baileys sets key.remoteJid to the chat counterparty), so
+            // looking it up in contacts gives the right name in both inbound and
+            // outbound bubbles. Skipped for outbound groups because `payload.from`
+            // there is the group JID itself, not a participant — the lookup would
+            // be a guaranteed miss.
+            const needsContactEnrich = enrichContactCfg &&
                 !payload.fromName &&
-                !!payload.from;
-            if (!needsEnrichment) {
+                !!payload.from &&
+                !(payload.isGroup && payload.direction === 'outbound');
+            const needsGroupEnrich = enrichContactCfg &&
+                payload.isGroup &&
+                !payload.groupName &&
+                !!payload.chatId;
+            if (!needsContactEnrich && !needsGroupEnrich) {
                 ctx.broadcast({ type: 'whatsapp_message', payload });
                 notifyTriggerSubscribers(payload);
                 return;
             }
-            void contactNames.lookup(msg.sessionId, payload.from).then((name) => {
-                const sanitized = sanitizeFromName(name, payload.from);
-                if (sanitized)
-                    payload.fromName = sanitized;
-                ctx.broadcast({ type: 'whatsapp_message', payload });
-                notifyTriggerSubscribers(payload);
-            }, (err) => {
-                ctx.log.warn(`WhatsApp contact lookup failed: ${err}`);
+            const contactPromise = needsContactEnrich
+                ? contactNames.lookup(msg.sessionId, payload.from).then((name) => {
+                    const sanitized = sanitizeFromName(name, payload.from);
+                    if (sanitized)
+                        payload.fromName = sanitized;
+                    log.debug(`whatsapp.enrich kind=contact resolved=${sanitized ? 'Y' : 'N'} jid=${hashJid(payload.from)}`);
+                }).catch((err) => {
+                    ctx.log.warn(`WhatsApp contact lookup failed: ${err}`);
+                })
+                : Promise.resolve();
+            const groupPromise = needsGroupEnrich
+                ? groupNames.lookup(msg.sessionId, payload.chatId).then((name) => {
+                    const trimmed = typeof name === 'string' ? name.trim() : '';
+                    if (trimmed)
+                        payload.groupName = trimmed;
+                    log.debug(`whatsapp.enrich kind=group resolved=${trimmed ? 'Y' : 'N'} jid=${hashJid(payload.chatId)}`);
+                }).catch((err) => {
+                    ctx.log.warn(`WhatsApp group lookup failed: ${err}`);
+                })
+                : Promise.resolve();
+            void Promise.all([contactPromise, groupPromise]).then(() => {
                 ctx.broadcast({ type: 'whatsapp_message', payload });
                 notifyTriggerSubscribers(payload);
             });
@@ -376,6 +433,61 @@ export function sanitizeFromName(name, fromJid) {
     }
     return trimmed;
 }
+/**
+ * Format a WhatsApp JID as a phone-style string when no display name is
+ * available. Strips the JID domain and any group-participant tag, then groups
+ * the digit run for Mexican mobiles (+52 1 NNN NNN NNNN), generic 12-digit
+ * MX (+52 NNN NNN NNNN), 11-digit US (+1 NNN NNN NNNN). Anything else falls
+ * back to '+<digits>'. Empty / unparseable input returns ''.
+ *
+ * Exported for unit testing.
+ */
+export function humanizeWhatsAppJid(jid) {
+    if (!jid)
+        return '';
+    const stripped = jid.replace(/@.*$/, '').split('-')[0];
+    const digits = stripped.replace(/\D/g, '');
+    if (!digits)
+        return '';
+    if (/^521(\d{3})(\d{3})(\d{4})$/.test(digits)) {
+        const m = digits.match(/^521(\d{3})(\d{3})(\d{4})$/);
+        return `+52 1 ${m[1]} ${m[2]} ${m[3]}`;
+    }
+    if (digits.length === 12 && digits.startsWith('52')) {
+        return `+52 ${digits.slice(2, 5)} ${digits.slice(5, 8)} ${digits.slice(8)}`;
+    }
+    if (digits.length === 11 && digits.startsWith('1')) {
+        return `+1 ${digits.slice(1, 4)} ${digits.slice(4, 7)} ${digits.slice(7)}`;
+    }
+    return `+${digits}`;
+}
+/**
+ * Best-effort label for a group chat when the upstream payload does not carry
+ * the group subject. Renders as `Grupo <last4>` so the user gets *something*
+ * stable to recognize across messages from the same group.
+ *
+ * Exported for unit testing.
+ */
+export function humanizeGroupJid(chatId) {
+    if (!chatId)
+        return '';
+    const stripped = chatId.replace(/@.*$/, '');
+    const digits = stripped.replace(/\D/g, '');
+    if (!digits)
+        return '';
+    return `Grupo ${digits.slice(-4)}`;
+}
+/**
+ * Short opaque hash of a JID for debug logging — keeps the JID off disk while
+ * still letting us correlate enrichment outcomes across log lines for the
+ * same chat. Uses 8 hex chars of SHA-1; cryptographic strength is not the
+ * point, just that it's not the JID itself.
+ */
+function hashJid(jid) {
+    if (!jid)
+        return '_';
+    return crypto.createHash('sha1').update(jid).digest('hex').slice(0, 8);
+}
 // Chat IDs that represent non-message channels (status updates, broadcast
 // lists). The bridge surfaces them as messages because Baileys delivers
 // status posts via `messages.upsert`, but they're not 1:1 / group chats and
@@ -457,14 +569,18 @@ export const whatsappTriggerHandler = {
     extractVariables(trigger, event) {
         const msg = event.data;
         void trigger;
+        const fromName = msg.fromName?.trim() || humanizeWhatsAppJid(msg.from);
+        const groupName = msg.isGroup
+            ? (msg.groupName?.trim() || humanizeGroupJid(msg.chatId))
+            : '';
         return {
             'whatsapp.from': msg.from,
-            'whatsapp.fromName': msg.fromName ?? '',
+            'whatsapp.fromName': fromName,
             'whatsapp.body': msg.body,
             'whatsapp.sessionId': msg.sessionId,
             'whatsapp.chatId': msg.chatId,
             'whatsapp.isGroup': String(msg.isGroup),
-            'whatsapp.groupName': msg.groupName ?? '',
+            'whatsapp.groupName': groupName,
             'whatsapp.direction': msg.direction,
             'whatsapp.mediaType': msg.mediaType ?? '',
             'whatsapp.mediaUrl': msg.mediaUrl ?? '',

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

@@ -7,7 +7,7 @@ import { spawn } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { agentService, runtimeService, bossMessageService } from '../services/index.js';
+import { agentService, runtimeService, bossMessageService, skillService } from '../services/index.js';
 import { getClaudeProjectDir, loadAreas, saveAreas } from '../data/index.js';
 import { loadSession } from '../claude/session-loader.js';
 import { getAllCustomClasses } from '../services/custom-class-service.js';
@@ -581,6 +581,148 @@ router.post('/bulk/move-area', async (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+// Normalize body { skillId?: string; skillIds?: string[] } into a deduped array.
+// Accepts the legacy single-skill form so older callers keep working.
+function normalizeSkillIds(body) {
+    const list = [];
+    if (Array.isArray(body.skillIds)) {
+        for (const id of body.skillIds) {
+            if (typeof id === 'string' && id)
+                list.push(id);
+        }
+    }
+    if (typeof body.skillId === 'string' && body.skillId)
+        list.push(body.skillId);
+    const deduped = Array.from(new Set(list));
+    return deduped.length > 0 ? deduped : null;
+}
+// POST /api/agents/bulk/skills/add - Assign one or more skills to multiple agents (idempotent)
+router.post('/bulk/skills/add', (req, res) => {
+    try {
+        const { agentIds } = req.body;
+        const skillIds = normalizeSkillIds(req.body ?? {});
+        if (!Array.isArray(agentIds) || agentIds.length === 0) {
+            res.status(400).json({ error: 'agentIds must be a non-empty array of strings' });
+            return;
+        }
+        if (!skillIds) {
+            res.status(400).json({ error: 'skillIds (or legacy skillId) is required' });
+            return;
+        }
+        for (const sid of skillIds) {
+            if (!skillService.getSkill(sid)) {
+                res.status(404).json({ error: `Skill not found: ${sid}` });
+                return;
+            }
+        }
+        const results = [];
+        for (const sid of skillIds) {
+            const updated = [];
+            const alreadyHad = [];
+            const failed = [];
+            const initialSkill = skillService.getSkill(sid);
+            for (const agentId of agentIds) {
+                try {
+                    const agent = agentService.getAgent(agentId);
+                    if (!agent) {
+                        failed.push(agentId);
+                        continue;
+                    }
+                    // Re-fetch on each iteration: assignSkillToAgent replaces the skill object
+                    // in the Map, so a captured outer reference goes stale.
+                    const current = skillService.getSkill(sid);
+                    const alreadyAssigned = current?.assignedAgentIds.includes(agentId) ?? false;
+                    const result = skillService.assignSkillToAgent(sid, agentId);
+                    if (!result) {
+                        failed.push(agentId);
+                        continue;
+                    }
+                    if (alreadyAssigned)
+                        alreadyHad.push(agentId);
+                    else
+                        updated.push(agentId);
+                }
+                catch (err) {
+                    log.error(` Bulk add-skill failed for agent ${agentId} / skill ${sid}:`, err);
+                    failed.push(agentId);
+                }
+            }
+            log.log(`Bulk add-skill ${initialSkill.name}: ${updated.length} added, ${alreadyHad.length} already had, ${failed.length} failed`);
+            results.push({ skillId: sid, skillName: initialSkill.name, updated, alreadyHad, failed });
+        }
+        // Legacy flat shape (kept for single-skill callers) + new shape.
+        const legacy = results.length === 1
+            ? { skillId: results[0].skillId, updated: results[0].updated, alreadyHad: results[0].alreadyHad, failed: results[0].failed }
+            : {};
+        res.json({ skillIds, results, ...legacy });
+    }
+    catch (err) {
+        log.error(' Bulk add-skill failed:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// POST /api/agents/bulk/skills/remove - Unassign one or more skills from multiple agents (idempotent)
+router.post('/bulk/skills/remove', (req, res) => {
+    try {
+        const { agentIds } = req.body;
+        const skillIds = normalizeSkillIds(req.body ?? {});
+        if (!Array.isArray(agentIds) || agentIds.length === 0) {
+            res.status(400).json({ error: 'agentIds must be a non-empty array of strings' });
+            return;
+        }
+        if (!skillIds) {
+            res.status(400).json({ error: 'skillIds (or legacy skillId) is required' });
+            return;
+        }
+        for (const sid of skillIds) {
+            if (!skillService.getSkill(sid)) {
+                res.status(404).json({ error: `Skill not found: ${sid}` });
+                return;
+            }
+        }
+        const results = [];
+        for (const sid of skillIds) {
+            const updated = [];
+            const didNotHave = [];
+            const failed = [];
+            const initialSkill = skillService.getSkill(sid);
+            for (const agentId of agentIds) {
+                try {
+                    const agent = agentService.getAgent(agentId);
+                    if (!agent) {
+                        failed.push(agentId);
+                        continue;
+                    }
+                    const current = skillService.getSkill(sid);
+                    const wasAssigned = current?.assignedAgentIds.includes(agentId) ?? false;
+                    const result = skillService.unassignSkillFromAgent(sid, agentId);
+                    if (!result) {
+                        failed.push(agentId);
+                        continue;
+                    }
+                    if (wasAssigned)
+                        updated.push(agentId);
+                    else
+                        didNotHave.push(agentId);
+                }
+                catch (err) {
+                    log.error(` Bulk remove-skill failed for agent ${agentId} / skill ${sid}:`, err);
+                    failed.push(agentId);
+                }
+            }
+            log.log(`Bulk remove-skill ${initialSkill.name}: ${updated.length} removed, ${didNotHave.length} didn't have, ${failed.length} failed`);
+            results.push({ skillId: sid, skillName: initialSkill.name, updated, didNotHave, failed });
+        }
+        const legacy = results.length === 1
+            ? { skillId: results[0].skillId, updated: results[0].updated, didNotHave: results[0].didNotHave, failed: results[0].failed }
+            : {};
+        res.json({ skillIds, results, ...legacy });
+    }
+    catch (err) {
+        log.error(' Bulk remove-skill failed:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
 // GET /api/agents/bulk/filters - Return available filter values
 router.get('/bulk/filters', (_req, res) => {
     try {
@@ -685,6 +827,45 @@ router.patch('/:id', (req, res) => {
         ok: true,
     });
 });
+// ============================================================================
+// Agent Memory Routes — per-agent persistent notes injected into system prompt
+// ============================================================================
+// GET /api/agents/:id/memory - Read the agent's current memory string
+router.get('/:id/memory', (req, res) => {
+    const agent = agentService.getAgent(req.params.id);
+    if (!agent) {
+        res.status(404).json({ error: 'Agent not found' });
+        return;
+    }
+    const memory = typeof agent.memory === 'string' ? agent.memory : '';
+    res.json({ memory, length: memory.length });
+});
+// PATCH /api/agents/:id/memory - Replace the agent's memory (full replace).
+// Body: { memory: string }
+router.patch('/:id/memory', (req, res) => {
+    const { memory } = req.body;
+    if (typeof memory !== 'string') {
+        res.status(400).json({ error: 'memory must be a string' });
+        return;
+    }
+    const updated = agentService.updateAgent(req.params.id, { memory }, false);
+    if (!updated) {
+        res.status(404).json({ error: 'Agent not found' });
+        return;
+    }
+    log.log(`Agent ${updated.name} (${updated.id}): memory updated (${memory.length} chars)`);
+    res.json({ ok: true, id: updated.id, length: memory.length });
+});
+// DELETE /api/agents/:id/memory - Clear the agent's memory
+router.delete('/:id/memory', (req, res) => {
+    const updated = agentService.updateAgent(req.params.id, { memory: '' }, false);
+    if (!updated) {
+        res.status(404).json({ error: 'Agent not found' });
+        return;
+    }
+    log.log(`Agent ${updated.name} (${updated.id}): memory cleared`);
+    res.json({ ok: true, id: updated.id });
+});
 // DELETE /api/agents/:id - Delete agent
 router.delete('/:id', (req, res) => {
     const deleted = agentService.deleteAgent(req.params.id);

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

@@ -8,6 +8,7 @@ import * as path from 'path';
 import { execSync, spawn } from 'child_process';
 import * as os from 'os';
 import { logger } from '../utils/logger.js';
+import { loadAreas } from '../data/index.js';
 const log = logger.files;
 // Get or create temp directory for tide-commander uploads
 const TEMP_DIR = path.join(os.tmpdir(), 'tide-commander-uploads');
@@ -53,6 +54,54 @@ function rememberResolution(key, found, strategy) {
     }
     resolvedPathCache.set(key, { path: found, strategy });
 }
+const AREA_DIR_TTL_MS = 30_000;
+const AREA_DIR_MAX_AREAS = 5;
+const AREA_DIR_MAX_PER_AREA = 10;
+let areaDirCache = null;
+export function _resetAreaDirCacheForTests() {
+    areaDirCache = null;
+}
+// Test seam: lets unit tests inject a deterministic area list without writing
+// to ~/.local/share/tide-commander/areas.json. Production code uses loadAreas().
+let areaLoaderForTests = null;
+export function _setAreaLoaderForTests(fn) {
+    areaLoaderForTests = fn;
+    areaDirCache = null;
+}
+function getAreaDirs(now = Date.now()) {
+    if (areaDirCache && areaDirCache.expiresAt > now)
+        return areaDirCache.entries;
+    const entries = [];
+    let areas;
+    try {
+        areas = areaLoaderForTests ? areaLoaderForTests() : loadAreas();
+    }
+    catch {
+        areas = [];
+    }
+    let areaCount = 0;
+    for (const area of areas) {
+        if (areaCount >= AREA_DIR_MAX_AREAS)
+            break;
+        const dirs = Array.isArray(area.directories) ? area.directories : [];
+        let perArea = 0;
+        for (const raw of dirs) {
+            if (perArea >= AREA_DIR_MAX_PER_AREA)
+                break;
+            if (typeof raw !== 'string' || !raw.trim())
+                continue;
+            const abs = path.isAbsolute(raw) ? raw : null;
+            if (!abs)
+                continue;
+            entries.push({ areaId: area.id, areaName: area.name, dir: abs.replace(/\/+$/, '') });
+            perArea++;
+        }
+        if (perArea > 0)
+            areaCount++;
+    }
+    areaDirCache = { entries, expiresAt: now + AREA_DIR_TTL_MS };
+    return entries;
+}
 // Recursive-walk cache for suffix-match: rooted at an absolute directory, value
 // is the flat list of file absolute paths under that root. TTL keeps it warm
 // across rapid clicks but lets edits propagate. Keys evict on TTL only — small
@@ -130,12 +179,13 @@ function findBySuffixMatch(rawPath, walkRoot) {
 /**
  * Resolve a requested file path to an existing file on disk, with fallbacks.
  * Tries (in order):
- *   1. exact         — resolved by resolveAndValidateFilePath() (absolute or baseDir+path)
- *   2. cached        — previously-resolved entry for the same requested key
- *   3. parent-walk   — tail slices anchored at baseDir AND each ancestor up to /
- *   4. git-root      — tail slices anchored at the git toplevel from baseDir
- *   5. suffix-match  — last-resort: unique trailing-segment match within a
- *                      depth-limited walk of baseDir, ignoring vendored dirs
+ *   1. exact              — resolved by resolveAndValidateFilePath() (absolute or baseDir+path)
+ *   2. cached             — previously-resolved entry for the same requested key
+ *   3. parent-walk        — tail slices anchored at baseDir AND each ancestor up to /
+ *   4. git-root           — tail slices anchored at the git toplevel from baseDir
+ *   5. suffix-match       — depth-limited walk of baseDir, unique trailing-segment match
+ *   6. area-root          — verbatim join against each user-configured area directory
+ *   7. area-suffix-match  — same depth-limited walk but rooted at each area directory
  * On miss, returns the absolute path requested AND the list of paths tried so
  * the caller can surface a clear, debuggable error.
  */
@@ -227,7 +277,45 @@ export function findFileWithFallbacks(rawPath, baseDir) {
                 }
             }
         }
-        catch { /* walk failed entirely — fall through to 404 */ }
+        catch { /* walk failed entirely — fall through to area strategies */ }
+    }
+    // Area strategies: try the user's configured area directories. Runs whether
+    // or not baseDir is set — area paths are independent. Capped to keep cold
+    // requests cheap (5 areas × 10 dirs).
+    const areaDirs = getAreaDirs();
+    const tailSegmentsForArea = rawPath.replace(/^\/+/, '').split(path.sep).filter(Boolean);
+    for (const { areaId, areaName, dir } of areaDirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        // area-root: try the requested path joined verbatim against the area dir,
+        // plus every tail-slice (so partial-prefix paths still resolve).
+        for (let i = 0; i < tailSegmentsForArea.length; i++) {
+            const candidate = path.join(dir, ...tailSegmentsForArea.slice(i));
+            const hit = tryCandidate(candidate);
+            if (hit) {
+                rememberResolution(rawPath, hit, 'area-root');
+                return { ok: true, path: hit, strategy: 'area-root', areaId, areaName };
+            }
+        }
+    }
+    for (const { areaId, areaName, dir } of areaDirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        try {
+            const suffixHit = findBySuffixMatch(rawPath, dir);
+            if (suffixHit) {
+                tried.push(`<area-suffix-match in ${dir}>`);
+                rememberResolution(rawPath, suffixHit, 'area-suffix-match');
+                return {
+                    ok: true,
+                    path: suffixHit,
+                    strategy: 'area-suffix-match',
+                    areaId,
+                    areaName,
+                };
+            }
+        }
+        catch { /* walk failed for this area — try next */ }
     }
     return {
         ok: false,
@@ -279,6 +367,8 @@ router.get('/read', async (req, res) => {
             size: stats.size,
             modified: stats.mtime,
             strategy: resolution.strategy,
+            areaId: resolution.areaId,
+            areaName: resolution.areaName,
         });
     }
     catch (err) {
@@ -413,6 +503,8 @@ router.get('/info', async (req, res) => {
             size: stats.size,
             modified: stats.mtime,
             strategy: resolution.strategy,
+            areaId: resolution.areaId,
+            areaName: resolution.areaName,
         });
     }
     catch (err) {

package/package.json

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