fraim 2.0.185 → 2.0.187

package/dist/src/ai-hub/conversation-store.js

@@ -3,10 +3,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AiHubConversationStore = void 0;
+exports.AiHubConversationStore = exports.COMPANY_SCOPE_KEY = exports.MANAGER_SCOPE_KEY = void 0;
+exports.conversationScopeKey = conversationScopeKey;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+// Issue #708: reserved, project-independent bucket keys for non-project scopes.
+// They are NOT filesystem paths and must never be passed through path.resolve.
+exports.MANAGER_SCOPE_KEY = '@manager';
+exports.COMPANY_SCOPE_KEY = '@company';
+/**
+ * Issue #708: resolve the conversation store bucket key for a given scope.
+ * - 'manager'/'company' → a stable sentinel key (project-independent home).
+ * - 'project' (or undefined) → the resolved project path (existing behavior).
+ */
+function conversationScopeKey(scope, projectPath) {
+    if (scope === 'manager')
+        return exports.MANAGER_SCOPE_KEY;
+    if (scope === 'company')
+        return exports.COMPANY_SCOPE_KEY;
+    return normalizeConversationKey(projectPath);
+}
 const emptyProjectState = () => ({
     activeId: null,
     conversations: [],
@@ -23,8 +40,58 @@ function timestampValue(value) {
     }
     return 0;
 }
+// Issue #708: sentinel scope keys (e.g. '@manager') are stable bucket keys, not paths —
+// pass them through untouched; resolve everything else as a real project path.
+function normalizeConversationKey(key) {
+    if (typeof key === 'string' && (key === exports.MANAGER_SCOPE_KEY || key === exports.COMPANY_SCOPE_KEY)) {
+        return key;
+    }
+    return path_1.default.resolve(key || process.cwd());
+}
+// Retained name for project-path stamping; now sentinel-aware so manager/company
+// records keep their scope key rather than being resolved into cwd/@manager.
 function normalizeProjectPath(projectPath) {
-    return path_1.default.resolve(projectPath || process.cwd());
+    return normalizeConversationKey(projectPath);
+}
+// Issue #708: one-time, idempotent migration. Legacy manager/company-invoked runs were
+// stored inside project buckets and distinguished only by the client-side `invokedArea`
+// field. Fold them into the reserved scope buckets (stamping `scope`) so they have a
+// stable, project-independent home. Runs already in a scope bucket are left untouched.
+function migrateScopeBuckets(store) {
+    const projects = {};
+    const ensure = (key) => {
+        if (!projects[key])
+            projects[key] = { activeId: null, conversations: [] };
+        return projects[key];
+    };
+    // Seed existing scope buckets first so their activeId is preserved.
+    for (const [key, state] of Object.entries(store.projects || {})) {
+        if (key === exports.MANAGER_SCOPE_KEY || key === exports.COMPANY_SCOPE_KEY) {
+            ensure(key).conversations.push(...(state.conversations || []));
+            projects[key].activeId = state.activeId ?? null;
+        }
+    }
+    for (const [key, state] of Object.entries(store.projects || {})) {
+        if (key === exports.MANAGER_SCOPE_KEY || key === exports.COMPANY_SCOPE_KEY)
+            continue;
+        const stay = [];
+        for (const conv of (state.conversations || [])) {
+            const scope = conv.scope
+                ?? conv.invokedArea;
+            if (scope === 'manager' || scope === 'company') {
+                const bucketKey = scope === 'manager' ? exports.MANAGER_SCOPE_KEY : exports.COMPANY_SCOPE_KEY;
+                const bucket = ensure(bucketKey);
+                if (!bucket.conversations.some((c) => c && c.id === conv.id)) {
+                    bucket.conversations.push({ ...conv, scope: scope });
+                }
+            }
+            else {
+                stay.push(conv);
+            }
+        }
+        projects[key] = { activeId: state.activeId ?? null, conversations: stay };
+    }
+    return { version: 1, projects };
 }
 function normalizeConversation(projectPath, raw) {
     if (!raw || typeof raw !== 'object')
@@ -77,6 +144,32 @@ class AiHubConversationStore {
         const normalizedProjectPath = normalizeProjectPath(projectPath);
         return normalizeProjectState(normalizedProjectPath, state.projects[normalizedProjectPath]);
     }
+    // Issue #719: delete a project's KEY from the store entirely. Writing an empty
+    // conversation list is not enough — knownProjects re-derives a project from
+    // every stored key (listProjectPaths), so removal must drop the key itself.
+    // Sentinel scope buckets (@manager/@company) are not projects and never removable.
+    removeProject(projectPath) {
+        if (projectPath === exports.MANAGER_SCOPE_KEY || projectPath === exports.COMPANY_SCOPE_KEY)
+            return false;
+        const canonicalKey = (value) => {
+            const resolved = path_1.default.resolve(value);
+            return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+        };
+        const target = canonicalKey(projectPath);
+        const state = this.readStore();
+        let removed = false;
+        for (const key of Object.keys(state.projects)) {
+            if (key === exports.MANAGER_SCOPE_KEY || key === exports.COMPANY_SCOPE_KEY)
+                continue;
+            if (canonicalKey(key) === target) {
+                delete state.projects[key];
+                removed = true;
+            }
+        }
+        if (removed)
+            this.writeStore(state);
+        return removed;
+    }
     replaceProject(projectPath, next) {
         const normalizedProjectPath = normalizeProjectPath(projectPath);
         const normalized = normalizeProjectState(normalizedProjectPath, next);
@@ -149,10 +242,8 @@ class AiHubConversationStore {
             if (raw.version !== 1 || !raw.projects || typeof raw.projects !== 'object') {
                 return { version: 1, projects: {} };
             }
-            return {
-                version: 1,
-                projects: raw.projects,
-            };
+            // Issue #708: fold legacy manager/company-invoked runs into scope buckets on read.
+            return migrateScopeBuckets({ version: 1, projects: raw.projects });
         }
         catch {
             return { version: 1, projects: {} };

package/dist/src/ai-hub/hosts.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHubEvent = exports.createHubMessage = exports.ScriptedHostRuntime = exports.FakeHostRuntime = exports.CliHostRuntime = void 0;
 exports.parseSeekMentoringSignal = parseSeekMentoringSignal;
+exports.parseFraimJobLoadSignal = parseFraimJobLoadSignal;
 exports.parseUsageSignal = parseUsageSignal;
 exports.parseAgentIdentitySignal = parseAgentIdentitySignal;
 exports.detectEmployees = detectEmployees;
@@ -91,6 +92,58 @@ function parseSeekMentoringSignal(line) {
     }
     return null;
 }
+// Issue #710: extract the job name from a get_fraim_job tool call. This
+// is structured known-job evidence; the server still validates the job id
+// against the catalog before promoting any run.
+function parseFraimJobLoadSignal(line) {
+    if (!line.includes('get_fraim_job'))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const obj = parsed;
+    // Codex shape: { type: 'item.started' | 'item.completed', item:
+    // { type: 'mcp_tool_call', tool: 'get_fraim_job', arguments: { job } } }.
+    if ((obj.type === 'item.started' || obj.type === 'item.completed') &&
+        typeof obj.item === 'object' && obj.item !== null) {
+        const item = obj.item;
+        const tool = typeof item.tool === 'string' ? item.tool : '';
+        if (item.type === 'mcp_tool_call' && isGetFraimJobTool(tool)) {
+            const sig = readFraimJobFromArgs(item.arguments);
+            if (sig)
+                return sig;
+        }
+    }
+    // Claude Code shape: tool_use blocks live inside message.content with
+    // an MCP-prefixed name such as mcp__fraim__get_fraim_job.
+    const candidates = [obj];
+    if (Array.isArray(obj.content))
+        candidates.push(...obj.content);
+    if (typeof obj.message === 'object' && obj.message !== null) {
+        const msg = obj.message;
+        if (Array.isArray(msg.content))
+            candidates.push(...msg.content);
+    }
+    for (const candidate of candidates) {
+        if (typeof candidate !== 'object' || candidate === null)
+            continue;
+        const c = candidate;
+        const isToolUse = c.type === 'tool_use' || c.type === 'function_call';
+        const nameField = typeof c.name === 'string' ? c.name : (typeof c.tool_name === 'string' ? c.tool_name : '');
+        if (!isToolUse || !isGetFraimJobTool(nameField))
+            continue;
+        const sig = readFraimJobFromArgs(c.input || c.arguments || c.parameters);
+        if (sig)
+            return sig;
+    }
+    return null;
+}
 // Issue #347 — extract per-turn usage from the host's JSON stream.
 // Codex: `{"type":"turn.completed","usage":{input_tokens, cached_input_tokens, output_tokens, reasoning_output_tokens}}`.
 // Claude Code: `{"type":"result", ..., "usage":{input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens}, "total_cost_usd": ...}`.
@@ -256,6 +309,41 @@ function readAgentFromArgs(args) {
         return null;
     return { agentName, agentModel };
 }
+function isGetFraimJobTool(toolName) {
+    return toolName === 'get_fraim_job' ||
+        toolName === 'mcp__fraim__get_fraim_job' ||
+        toolName.endsWith('get_fraim_job');
+}
+function readFraimJobFromArgs(rawArgs) {
+    const args = normalizeToolArgs(rawArgs);
+    if (!args)
+        return null;
+    const rawJob = stringValue(args.job) ||
+        stringValue(args.jobName) ||
+        stringValue(args.job_id) ||
+        stringValue(args.name);
+    const jobId = rawJob.trim().toLowerCase();
+    if (!jobId)
+        return null;
+    return { jobId, source: 'get_fraim_job' };
+}
+function normalizeToolArgs(rawArgs) {
+    if (rawArgs && typeof rawArgs === 'object' && !Array.isArray(rawArgs)) {
+        return rawArgs;
+    }
+    if (typeof rawArgs !== 'string' || rawArgs.trim().length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(rawArgs);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
 function numberOrNull(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : null;
 }
@@ -987,17 +1075,24 @@ function parseHostLine(hostId, line) {
     const trimmed = line.trim();
     if (!trimmed)
         return {};
-    // Issue #347: scan every line for the three signals the Hub UI cares
-    // about — seekMentoring (drives the tracker), turn-level usage
-    // (drives the totals tokens/cost), and the agent identity from
-    // fraim_connect (used to look up cost when the host doesn't emit it).
+    // Scan every line for structured signals the Hub UI cares about:
+    // seekMentoring (tracker), get_fraim_job (job identity promotion),
+    // turn-level usage (totals), and fraim_connect agent identity
+    // (cost lookup when the host doesn't emit it).
     const seekMentoring = parseSeekMentoringSignal(trimmed);
+    const fraimJob = parseFraimJobLoadSignal(trimmed);
     const usage = parseUsageSignal(trimmed);
     const agentIdentity = parseAgentIdentitySignal(trimmed);
     const withSignal = (event) => {
-        if (!seekMentoring && !usage && !agentIdentity)
+        if (!seekMentoring && !fraimJob && !usage && !agentIdentity)
             return event;
-        return { ...event, ...(seekMentoring ? { seekMentoring } : {}), ...(usage ? { usage } : {}), ...(agentIdentity ? { agentIdentity } : {}) };
+        return {
+            ...event,
+            ...(seekMentoring ? { seekMentoring } : {}),
+            ...(fraimJob ? { fraimJob } : {}),
+            ...(usage ? { usage } : {}),
+            ...(agentIdentity ? { agentIdentity } : {}),
+        };
     };
     if (hostId === 'codex') {
         try {
@@ -1339,9 +1434,10 @@ class ScriptedHostRuntime {
             { id: 'gemini', label: 'Gemini CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
             { id: 'copilot', label: 'GitHub Copilot CLI', available: true, detail: 'Scripted test double.', supportsRaw: true },
         ];
-        // Track each active run so the test can emit signals at it. Key is the
-        // sessionId we hand back on startRun; mapping sessionId → handlers
-        // lets emitPhase() reach the right run's onEvent callback.
+        // Track each active run so the test can emit signals at it. The Hub
+        // passes the run id as the requested start session id in test/demo paths;
+        // real resume flows still use the host session id. Resolving by the
+        // supplied id first lets concurrent scripted runs receive targeted events.
         this.handlersBySession = new Map();
         // Tracks runDiscriminant per sessionId so consecutive emitPhase calls
         // can resolve onSuccess routing without each test having to repeat it.
@@ -1352,8 +1448,8 @@ class ScriptedHostRuntime {
     }
     startRun(_hostId, _projectPath, _message, handlers, requestedSessionId) {
         const sessionId = requestedSessionId || (0, crypto_1.randomUUID)();
-        handlers.onEvent({ sessionId, raw: 'scripted-session-start' }, 'system');
         this.handlersBySession.set(sessionId, handlers);
+        handlers.onEvent({ sessionId, raw: 'scripted-session-start' }, 'system');
         return this.spawnDouble();
     }
     continueRun(_hostId, _projectPath, sessionId, _message, handlers) {
@@ -1363,6 +1459,7 @@ class ScriptedHostRuntime {
     }
     startDirectRun(_hostId, _message, _projectPath, handlers, requestedSessionId) {
         const sessionId = requestedSessionId || (0, crypto_1.randomUUID)();
+        this.handlersBySession.set(sessionId, handlers);
         handlers.onEvent({ sessionId, raw: 'scripted-direct-session-start' }, 'system');
         return this.spawnDouble();
     }
@@ -1420,6 +1517,18 @@ class ScriptedHostRuntime {
             },
         }, 'stdout');
     }
+    // Test API — emit the structured job-load signal that get_fraim_job
+    // produces before the first seekMentoring phase call.
+    emitFraimJobLoad(runId, jobId) {
+        const target = this.resolveSession(runId);
+        if (!target)
+            return;
+        target.handlers.onEvent({
+            sessionId: target.sessionId,
+            raw: `scripted-get_fraim_job:${jobId}`,
+            fraimJob: { jobId, source: 'get_fraim_job' },
+        }, 'stdout');
+    }
     // Test API — emit a per-turn usage signal in the normalized shape
     // the server expects. Mirrors what parseUsageSignal would produce
     // from a real host's stream.
@@ -1464,13 +1573,16 @@ class ScriptedHostRuntime {
         this.handlersBySession.clear();
         this.discriminantBySession.clear();
     }
-    // The Hub server keeps its own sessionId map keyed off run.sessionId —
-    // but at the time the test calls emitPhase(runId), we may only have
-    // one handler registered (the latest start). Resolve by sessionId
-    // first, fall back to the most recent registered handler.
-    resolveSession(_runId) {
+    // The Hub passes run.id as the requested session id for scripted starts,
+    // so tests/demo controls can target a specific run even when multiple runs
+    // are active. Fall back to the latest handler for older callers that do not
+    // provide a known id.
+    resolveSession(runId) {
         if (this.handlersBySession.size === 0)
             return null;
+        const direct = this.handlersBySession.get(runId);
+        if (direct)
+            return { sessionId: runId, handlers: direct };
         const entries = [...this.handlersBySession.entries()];
         const [sessionId, handlers] = entries[entries.length - 1];
         return { sessionId, handlers };

package/dist/src/ai-hub/openclaw-bridge.js

@@ -134,6 +134,7 @@ class OpenClawAiHubBridge {
                         jobId: run.jobId,
                         projectPath,
                         lastSeenAt: new Date().toISOString(),
+                        managerTexts: [inbound.text],
                     };
                     this.threads.set(key, state);
                     this.persistThreadState();
@@ -147,6 +148,7 @@ class OpenClawAiHubBridge {
                     }
                     run = continued.data;
                     state.lastSeenAt = new Date().toISOString();
+                    state.managerTexts = [...(state.managerTexts ?? []), inbound.text];
                     this.persistThreadState();
                 }
                 const settled = await this.waitForSettlement(run.id);
@@ -193,6 +195,19 @@ class OpenClawAiHubBridge {
         return this.fetchRun(runId);
     }
     presentThread(state, run) {
+        // The Hub records the invocation it sent as each manager bubble (#696). For a channel
+        // transcript we substitute the user's own words (state.managerTexts, in turn order)
+        // for manager-role messages, so the thread reflects what the user actually typed.
+        const managerTexts = state.managerTexts ?? [];
+        let managerIdx = 0;
+        const transcript = run.messages.map((message) => ({
+            role: message.role,
+            text: message.role === 'manager' && managerIdx < managerTexts.length
+                ? managerTexts[managerIdx++]
+                : message.text,
+            createdAt: message.createdAt,
+        }));
+        const latestManagerMessage = [...transcript].reverse().find((m) => m.role === 'manager')?.text || null;
         return {
             channelId: state.channelId,
             threadId: state.threadId,
@@ -204,13 +219,9 @@ class OpenClawAiHubBridge {
             currentPhase: run.currentPhase || null,
             stages: run.stages || [],
             totals: run.totals || null,
-            latestManagerMessage: lastMessage(run.messages, 'manager')?.text || null,
+            latestManagerMessage,
             latestEmployeeMessage: lastMessage(run.messages, 'employee')?.text || null,
-            transcript: run.messages.map((message) => ({
-                role: message.role,
-                text: message.text,
-                createdAt: message.createdAt,
-            })),
+            transcript,
         };
     }
     threadKey(channelId, threadId) {