madarx 2.21.0 → 2.22.0

package/.next/static/chunks/app/tasks/loading-1ba78d5ff6330abc.js

@@ -0,0 +1 @@
+(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[64,72,167,178,229,232,280,332,489,497,552,658,723,767,769,796,870,888,899,939,972,1053,1115,1177,1426,1523,1557,1562,1581,1672,1851,1990,2008,2139,2153,2162,2164,2175,2254,2334,2343,2433,2635,2640,2711,2726,2748,2837,2873,2889,2943,3033,3076,3159,3190,3203,3395,3437,3465,3492,3499,3554,3558,3577,3629,3630,3641,3659,3745,3756,3802,3839,3870,3886,3904,3905,3942,3975,3976,4094,4095,4104,4115,4190,4204,4209,4218,4229,4231,4269,4373,4410,4431,4475,4507,4519,4530,4537,4562,4662,4721,4819,4890,4999,5049,5085,5092,5098,5118,5120,5130,5169,5180,5207,5223,5289,5324,5331,5441,5520,5551,5588,5610,5689,5707,5722,5743,5794,5810,5850,5875,5887,5903,5906,6002,6079,6106,6113,6147,6186,6234,6278,6279,6341,6365,6403,6456,6496,6591,6595,6621,6667,6701,6725,6779,6799,6816,6862,7020,7026,7060,7070,7092,7113,7237,7276,7324,7361,7440,7750,7765,7795,7823,7903,7920,7986,8059,8093,8100,8159,8227,8252,8273,8298,8312,8397,8401,8405,8578,8591,8665,8679,8732,8765,8828,8887,8907,8994,9e3,9037,9040,9154,9160,9183,9413,9442,9504,9554,9628,9873,9953],{84441:()=>{}},_=>{_.O(0,[8441,1255,7358],()=>_(_.s=84441)),_N_E=_.O()}]);

package/.next/static/chunks/app/tools/loading-1ba78d5ff6330abc.js

@@ -0,0 +1 @@
+(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[64,72,167,178,229,232,280,332,489,497,552,658,723,767,769,796,870,888,899,939,972,1053,1115,1177,1426,1523,1557,1562,1581,1672,1851,1990,2008,2139,2153,2162,2164,2175,2254,2334,2343,2433,2635,2640,2711,2726,2748,2837,2873,2889,2943,3033,3076,3159,3190,3203,3395,3437,3465,3492,3499,3554,3558,3577,3629,3630,3641,3659,3745,3756,3802,3839,3870,3886,3904,3905,3942,3975,3976,4094,4095,4104,4115,4190,4204,4209,4218,4229,4231,4269,4373,4410,4431,4475,4507,4519,4530,4537,4562,4662,4721,4819,4890,4999,5049,5085,5092,5098,5118,5120,5130,5169,5180,5207,5223,5289,5324,5331,5441,5520,5551,5588,5610,5689,5707,5722,5743,5794,5810,5850,5875,5887,5903,5906,6002,6079,6106,6113,6147,6186,6234,6278,6279,6341,6365,6403,6456,6496,6591,6595,6621,6667,6701,6725,6779,6799,6816,6862,7020,7026,7060,7070,7092,7113,7237,7276,7324,7361,7440,7750,7765,7795,7823,7903,7920,7986,8059,8093,8100,8159,8227,8252,8273,8298,8312,8397,8401,8405,8578,8591,8665,8679,8732,8765,8828,8887,8907,8994,9e3,9037,9040,9154,9160,9183,9413,9442,9504,9554,9628,9873,9953],{84441:()=>{}},_=>{_.O(0,[8441,1255,7358],()=>_(_.s=84441)),_N_E=_.O()}]);

package/.next/static/chunks/app/tools/page-1ba78d5ff6330abc.js

@@ -0,0 +1 @@
+(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[64,72,167,178,229,232,280,332,489,497,552,658,723,767,769,796,870,888,899,939,972,1053,1115,1177,1426,1523,1557,1562,1581,1672,1851,1990,2008,2139,2153,2162,2164,2175,2254,2334,2343,2433,2635,2640,2711,2726,2748,2837,2873,2889,2943,3033,3076,3159,3190,3203,3395,3437,3465,3492,3499,3554,3558,3577,3629,3630,3641,3659,3745,3756,3802,3839,3870,3886,3904,3905,3942,3975,3976,4094,4095,4104,4115,4190,4204,4209,4218,4229,4231,4269,4373,4410,4431,4475,4507,4519,4530,4537,4562,4662,4721,4819,4890,4999,5049,5085,5092,5098,5118,5120,5130,5169,5180,5207,5223,5289,5324,5331,5441,5520,5551,5588,5610,5689,5707,5722,5743,5794,5810,5850,5875,5887,5903,5906,6002,6079,6106,6113,6147,6186,6234,6278,6279,6341,6365,6403,6456,6496,6591,6595,6621,6667,6701,6725,6779,6799,6816,6862,7020,7026,7060,7070,7092,7113,7237,7276,7324,7361,7440,7750,7765,7795,7823,7903,7920,7986,8059,8093,8100,8159,8227,8252,8273,8298,8312,8397,8401,8405,8578,8591,8665,8679,8732,8765,8828,8887,8907,8994,9e3,9037,9040,9154,9160,9183,9413,9442,9504,9554,9628,9873,9953],{84441:()=>{}},_=>{_.O(0,[8441,1255,7358],()=>_(_.s=84441)),_N_E=_.O()}]);

package/.next/static/chunks/app/whatsapp/loading-1ba78d5ff6330abc.js

@@ -0,0 +1 @@
+(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[64,72,167,178,229,232,280,332,489,497,552,658,723,767,769,796,870,888,899,939,972,1053,1115,1177,1426,1523,1557,1562,1581,1672,1851,1990,2008,2139,2153,2162,2164,2175,2254,2334,2343,2433,2635,2640,2711,2726,2748,2837,2873,2889,2943,3033,3076,3159,3190,3203,3395,3437,3465,3492,3499,3554,3558,3577,3629,3630,3641,3659,3745,3756,3802,3839,3870,3886,3904,3905,3942,3975,3976,4094,4095,4104,4115,4190,4204,4209,4218,4229,4231,4269,4373,4410,4431,4475,4507,4519,4530,4537,4562,4662,4721,4819,4890,4999,5049,5085,5092,5098,5118,5120,5130,5169,5180,5207,5223,5289,5324,5331,5441,5520,5551,5588,5610,5689,5707,5722,5743,5794,5810,5850,5875,5887,5903,5906,6002,6079,6106,6113,6147,6186,6234,6278,6279,6341,6365,6403,6456,6496,6591,6595,6621,6667,6701,6725,6779,6799,6816,6862,7020,7026,7060,7070,7092,7113,7237,7276,7324,7361,7440,7750,7765,7795,7823,7903,7920,7986,8059,8093,8100,8159,8227,8252,8273,8298,8312,8397,8401,8405,8578,8591,8665,8679,8732,8765,8828,8887,8907,8994,9e3,9037,9040,9154,9160,9183,9413,9442,9504,9554,9628,9873,9953],{84441:()=>{}},_=>{_.O(0,[8441,1255,7358],()=>_(_.s=84441)),_N_E=_.O()}]);

package/.next/static/chunks/app/workflows/share/[caseId]/page-1ba78d5ff6330abc.js

@@ -0,0 +1 @@
+(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[64,72,167,178,229,232,280,332,489,497,552,658,723,767,769,796,870,888,899,939,972,1053,1115,1177,1426,1523,1557,1562,1581,1672,1851,1990,2008,2139,2153,2162,2164,2175,2254,2334,2343,2433,2635,2640,2711,2726,2748,2837,2873,2889,2943,3033,3076,3159,3190,3203,3395,3437,3465,3492,3499,3554,3558,3577,3629,3630,3641,3659,3745,3756,3802,3839,3870,3886,3904,3905,3942,3975,3976,4094,4095,4104,4115,4190,4204,4209,4218,4229,4231,4269,4373,4410,4431,4475,4507,4519,4530,4537,4562,4662,4721,4819,4890,4999,5049,5085,5092,5098,5118,5120,5130,5169,5180,5207,5223,5289,5324,5331,5441,5520,5551,5588,5610,5689,5707,5722,5743,5794,5810,5850,5875,5887,5903,5906,6002,6079,6106,6113,6147,6186,6234,6278,6279,6341,6365,6403,6456,6496,6591,6595,6621,6667,6701,6725,6779,6799,6816,6862,7020,7026,7060,7070,7092,7113,7237,7276,7324,7361,7440,7750,7765,7795,7823,7903,7920,7986,8059,8093,8100,8159,8227,8252,8273,8298,8312,8397,8401,8405,8578,8591,8665,8679,8732,8765,8828,8887,8907,8994,9e3,9037,9040,9154,9160,9183,9413,9442,9504,9554,9628,9873,9953],{84441:()=>{}},_=>{_.O(0,[8441,1255,7358],()=>_(_.s=84441)),_N_E=_.O()}]);

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to Madarx OS. Newest first.
 
 ## Unreleased
 
+## [2.22.0] - 2026-06-06
+
+### Fixed
+
+- **Image-gen (and any) goal no longer dead-ends after routing on the CLI engine.** The CLI engines execute `madarx-action` blocks post-hoc and never feed results back into the subprocess, so a turn that called only `route_goal` stalled — the model narrated "delegate once the roster comes back" and never emitted `run_agent` (no sub-agent, nothing in the activity panel). New `lib/cli-action-flow.js` classifies a route_goal-only turn and the stream route re-invokes the CLI once with the registry injected (the CLI-engine equivalent of the Anthropic loop's turn 2); the intent-without-action guard is widened to catch a persistent stall. Files: `lib/cli-action-flow.js`, `app/api/orchestrator/stream/route.js`. Tests: `tests/cli-action-flow.test.js`.
+- **Background-agent activity toolbar matched to the command center.** The topbar and the Operator Command Center each open their own SSE connection; a run that emitted no tool events (a sub-agent with no granted tool) and whose `agent_run_start` was missed on a reconnect vanished from the topbar while the command center showed it. The reducer (extracted to `app/components/dashboard/bg-agent-reducer.js`) now surfaces an agent from an `agent_run_complete`/`agent_tool_result` even without a prior start, and both panels seed "what's running now" from the new `GET /api/agents/active-runs` on mount and every (re)connect. Files: `app/components/app-topbar.jsx`, `app/components/dashboard/{bg-agent-reducer.js,use-bg-agents.js}`, `app/agents/agent-events-bus.js`, `app/api/agents/active-runs/route.js`, `lib/delegation.js`, `lib/active-runs.js`. Tests: `tests/bg-agent-reducer.test.js`, `tests/active-runs.test.js`.
+
+### Added
+
+- **Capability-matched routing — reuse the equipped specialist, don't spawn a tool-less duplicate.** `route_goal` now returns `needed_categories`, `recommended_specialists` (existing agents that already own the tools the goal needs, ranked by overlap), and `tools_for_goal` (the catalog tools + their owners), with a routing note that says PREFER delegating to the owner and, when creating, grant the listed tools. An image goal now surfaces the Visual Designer (owns `higgsfield_generate_image`) instead of spawning a bare "Art Director" that generates nothing. New `list_agents` core tool exposes the roster + each agent's tools + open-task load so the main agent checks before creating. Files: `lib/role-capability-map.js`, `lib/agent-routing.js`, `lib/orchestrator-tools.js`, `lib/agent-config.js`. Tests: `tests/agent-routing-capability.test.js`.
+- **Task-backed delegation + completion safety net.** Every chat-initiated `run_agent` is now filed as a tracked task on the `/tasks` board (assignee = the specialist), runs synchronously with persisted `agent_runs` (running→terminal), moves the task `in_progress → in_review` and auto-completes to `done` on the happy path; blocked/failed stay open. A recurring `task_sweep` heartbeat job (`lib/delegation.js::sweepTasks`, seeded idempotently) drives stalled tasks toward completion — dispatches never-woken assignments, re-wakes stuck/overdue tasks — guarded so it never double-dispatches or spams. `createTask` gains `suppress_wake` so the synchronous path tracks without double-running. Files: `lib/orchestrator-tools.js`, `lib/delegation.js`, `lib/heartbeat-worker.js`, `lib/seeds.js`, `lib/agent-config.js`. Tests: `tests/task-delegation.test.js`.
+
 ## [2.21.0] - 2026-06-06
 
 ### Added

package/app/agents/agent-events-bus.js

@@ -9,6 +9,10 @@
 // not just that something is running. Existing subscribers filter by
 // event.type, so the extra types are inert for them.
 const EVENT_TYPES = [
+  // `ready` fires on every (re)connect of the shared SSE channel. Subscribers
+  // use it to re-seed "what's running now" from /api/agents/active-runs, so a
+  // run whose agent_run_start landed before/across a reconnect still shows.
+  'ready',
   'agent_created',
   'agent_run_start',
   'agent_run_complete',

package/app/api/agents/active-runs/route.js

@@ -0,0 +1,59 @@
+import { listActiveAgentRuns } from '@/lib/delegation.js';
+import { listActiveRunIds } from '@/lib/active-runs.js';
+import { listAgents } from '@/lib/runtime.js';
+import { requireSession } from '@/lib/auth.js';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+// Snapshot of every background agent running RIGHT NOW. The activity panels
+// (topbar + Operator Command Center) fetch this on mount and on each SSE
+// (re)connect to seed their live view, so a run that started before the panel's
+// EventSource connected — or whose agent_run_start was missed on a reconnect —
+// still appears. Two sources, deduped by agent_id:
+//   - persisted agent_runs in an active status (delegated / task-backed runs)
+//   - the in-process manual-run registry (fire-and-forget runs with no DB row)
+export async function GET(req) {
+  try {
+    await requireSession(req);
+  } catch (err) {
+    if (err && typeof err === 'object' && err.status) {
+      return Response.json({ error: err.error || 'unauthorized' }, { status: err.status });
+    }
+    throw err;
+  }
+
+  const byId = new Map();
+
+  try {
+    for (const run of listActiveAgentRuns()) {
+      byId.set(run.agent_id, {
+        agent_id: run.agent_id,
+        agent_name: run.agent_name,
+        status: 'running',
+        triggered_by: run.triggered_by,
+        started_at: run.started_at ? new Date(run.started_at).getTime() : Date.now(),
+        task_id: run.task_id,
+        run_id: run.run_id,
+      });
+    }
+  } catch { /* agent_runs not ready — fall through to in-memory */ }
+
+  try {
+    const names = new Map(listAgents().map((a) => [a.id, a.name]));
+    for (const id of listActiveRunIds()) {
+      if (byId.has(id)) continue;
+      byId.set(id, {
+        agent_id: id,
+        agent_name: names.get(id) || id,
+        status: 'running',
+        triggered_by: 'manual',
+        started_at: Date.now(),
+        task_id: null,
+        run_id: null,
+      });
+    }
+  } catch { /* best-effort */ }
+
+  return Response.json({ agents: Array.from(byId.values()) });
+}

package/app/api/orchestrator/stream/route.js

@@ -5,7 +5,10 @@ import { executeTool, getTools } from '@/lib/orchestrator-tools.js';
 import { getSystemPrompt, getModel, getModels, currentDateInstruction } from '@/lib/agent-config.js';
 import { brandInstructionText } from '@/lib/brand.js';
 import { agentMemoryContext } from '@/lib/agent-memory-context.js';
-import { runOllamaAgent, runClaudeCodeAgent, runCodexAgent } from '@/lib/agent-engines.js';
+import { runOllamaAgent, runClaudeCodeAgent, runCodexAgent, agentSubprocessCwd } from '@/lib/agent-engines.js';
+import { getProject } from '@/lib/projects.js';
+import { DATA_DIR } from '@/lib/paths.js';
+import nodePath from 'node:path';
 import { thinkingBudgetTokens, getStreamVerbosity } from '@/lib/engine-verbosity.js';
 import {
   createChatSession,
@@ -20,6 +23,11 @@ import * as turnBroadcast from '@/lib/orchestrator-broadcast.js';
 import { buildAgentCreatedHtml } from '@/lib/agent-created-card.js';
 import { buildHiggsfieldMediaHtml } from '@/lib/higgsfield-media-card.js';
 import { INTENT_WITHOUT_ACTION_RE } from '@/lib/intent-without-action.js';
+import {
+  classifyCliTurn,
+  latestPlanningResult,
+  buildRouteGoalContinuationPrompt,
+} from '@/lib/cli-action-flow.js';
 import { looksFabricatedToolTranscript } from '@/lib/fabricated-tool-output.js';
 import { loadAttachments, attachmentsToContentBlocks, attachmentsToPromptText } from '@/lib/chat-uploads.js';
 
@@ -64,7 +72,7 @@ What you CAN do directly:
 - Quick factual web lookups — madarx-action blocks with web_search / web_fetch — for a single date, number, or definition that does not warrant a specialist. Results come back automatically.
 - Generate HTML pages, dashboards, reports, decks, UI — a complete self-contained HTML file in a \`\`\`html code fence. PRIMARY output channel for structured responses.
 - Write short conversational replies (≤ 2 sentences, no lists) — plain text.
-- Route + delegate via route_goal / run_agent / create_agent / request_capability madarx-action blocks.
+- Route + delegate via route_goal / run_agent / create_agent / request_capability madarx-action blocks. Use list_agents to see your existing workforce + what each can do BEFORE creating a new agent — reuse an equipped specialist, never spawn a duplicate. Every run_agent is filed as a tracked task on /tasks and its status is managed for you.
 
 ARTIFACT TEMPLATES (always emit a complete HTML page in a \`\`\`html fence — never paste structured data as markdown in chat):
 - news → "news feed" layout: stacked story cards with headline, source label, timestamp, 2-3 sentence dek, and a "Read source" link per card. Publication-style typography.
@@ -391,7 +399,7 @@ export async function POST(req) {
   // Thread tenancy so chat-initiated tool calls (e.g. mines_run_report →
   // runSingleReport → executeRegistryTool) attribute audit/approval rows to the
   // real acting user/org, not the 'local-user'/'personal-org' fallbacks.
-  const toolContext = { project_id: projectId, user_id: session.user_id, org_id: session.org_id };
+  const toolContext = { project_id: projectId, user_id: session.user_id, org_id: session.org_id, engine: activeEngine };
 
   // pending_approvals: [{ approval_id, tool_name }] — sent by the chat client
   // after the user clicks Approve in an inline tool-step. We inject
@@ -455,10 +463,20 @@ export async function POST(req) {
   const modelIdentityContext = isCliEngine
     ? ''
     : `\n\nActive model: ${activeModelMeta?.label || activeModel} (id: ${activeModel}). If the user asks which model you are, answer with this exact name. Do not guess from training-data priors.`;
+  // Project-Disk grounding. The owner's "project folder / my files" means the
+  // active project's Disk (data/disk/<slug>/, surfaced at /projects/<slug>),
+  // NOT the madarX source tree. Tell the agent to use the disk_* tools and never
+  // inspect the source code or parent directories for the owner's files.
+  let activeProjectMeta = null;
+  try { activeProjectMeta = getProject(projectId); } catch { /* unknown/personal scope */ }
+  const projectDiskContext = `\n\nPROJECT FILES — when the owner asks to "check my project", "my folder", "my files", or anything about ${activeProjectMeta ? `the "${activeProjectMeta.name}" project` : 'their project'}, that means the project's DISK (the files shown at /projects/<slug>), NOT the madarX source code. Active project: ${activeProjectMeta ? `name="${activeProjectMeta.name}", slug="${activeProjectMeta.slug}", id="${activeProjectMeta.id}"` : `id="${projectId}"`}.
+- Use disk_list_folders / disk_list_files / disk_read_file (and list_projects to resolve a project by name/slug). These read the owner's content.
+- NEVER answer a "my project/files" question by reading the madarX source tree (app/, lib/, tests/, CLAUDE.md) or any directory above it, and never via Bash/Read/Glob/file_read/directory_list. Those are the product's own code, not the owner's files.`;
+
   // Use `let` so the CLI fallback path can override to the Anthropic system prompt.
   let systemPrompt = isCliEngine
-    ? (buildCliSystemPrompt() + cliArtifactContext)
-    : getSystemPrompt() + agentMemoryContext(userText) + artifactContext + modelIdentityContext;
+    ? (buildCliSystemPrompt() + cliArtifactContext + projectDiskContext)
+    : getSystemPrompt() + agentMemoryContext(userText) + artifactContext + modelIdentityContext + projectDiskContext;
 
   const encoder = new TextEncoder();
   // The CLI subprocess can keep streaming chunks back via `cliOnChunk` even after
@@ -604,6 +622,12 @@ export async function POST(req) {
                 systemPrompt,
                 userMessage,
                 allowedTools: [],
+                // Boot the chat subprocess in a neutral runtime dir (workspace),
+                // not the madarX repo root, so a casual "list my files" can't
+                // wander the source tree or the parent dir's sibling repos. The
+                // owner's files come through the disk_* madarx-action tools.
+                cwd: agentSubprocessCwd(),
+                addDirs: [nodePath.join(DATA_DIR, 'disk')],
                 maxTurns: 5,
                 timeoutMs: Number(process.env.CLAUDE_CODE_CHAT_TIMEOUT_MS || 600000),
                 verbosity: getStreamVerbosity(),
@@ -641,6 +665,38 @@ export async function POST(req) {
           let actions = await executeCliActions(raw, { emit, context: toolContext });
           let cliHasHtml = extractCliArtifacts(raw).length > 0;
 
+          // route_goal continuation: route_goal is a PLANNING action whose result
+          // (the live roster) must drive a follow-up delegating action (run_agent /
+          // create_agent / request_capability). The CLI engine executes action
+          // blocks post-hoc and never feeds results back into the subprocess, so a
+          // turn that calls ONLY route_goal dead-ends — the model narrates "I'll
+          // delegate once the roster comes back" but no second turn exists, so no
+          // specialist is ever dispatched (no sub-agent run, nothing in the activity
+          // panel). Re-invoke the CLI ONCE with the route_goal registry injected so
+          // it can pick a ladder step and emit the real delegating action — the
+          // CLI-engine equivalent of the Anthropic loop's turn 2. Only fires when
+          // route_goal was the ONLY action and no HTML artifact was produced, so
+          // one-shot delegations and conversational answers are untouched.
+          if (classifyCliTurn(actions, { hasHtml: cliHasHtml }).needsRouteContinuation) {
+            const registry = latestPlanningResult(actions);
+            const routeNudge = buildRouteGoalContinuationPrompt(cliUserContent, registry);
+            emit('cli_stream', { text: 'Routing resolved — delegating…' });
+            let routeRetryRaw = null;
+            try {
+              routeRetryRaw = await invokeCliWithHeartbeat(routeNudge);
+            } catch (routeErr) {
+              if (process.env.MADARX_DEBUG) console.error('[madarx] route_goal continuation failed:', routeErr.message);
+            }
+            if (routeRetryRaw) {
+              const routeRetryActions = await executeCliActions(routeRetryRaw, { emit, context: toolContext });
+              if (routeRetryActions.length > 0 || extractCliArtifacts(routeRetryRaw).length > 0) {
+                raw = routeRetryRaw;
+                actions = routeRetryActions;
+                cliHasHtml = extractCliArtifacts(routeRetryRaw).length > 0;
+              }
+            }
+          }
+
           // Intent-without-action guard: the CLI narrated a task ("Started AI brief run.
           // Artifact lands on canvas when done.") but emitted NO ```madarx-action``` block,
           // so nothing actually ran — the user gets a promise + silence. Re-prompt the CLI
@@ -654,7 +710,12 @@ export async function POST(req) {
           // action. That blob has 0 real actions, so without this it would slip through and be
           // delivered as the answer. Detect it and re-prompt to dispatch the real action.
           const initialFabricated = looksFabricatedToolTranscript(raw);
-          if (actions.length === 0 && !cliHasHtml && (INTENT_WITHOUT_ACTION_RE.test(stripCliActions(raw)) || initialFabricated)) {
+          // A route_goal-only turn that survived the continuation above (the retry
+          // produced nothing actionable) is still an intent-without-action stall:
+          // the model routed a goal but never delegated. Treat it like a zero-action
+          // turn so the generic nudge fires as a last resort.
+          const routeGoalStalled = classifyCliTurn(actions, { hasHtml: cliHasHtml }).needsRouteContinuation;
+          if ((actions.length === 0 || routeGoalStalled) && !cliHasHtml && (INTENT_WITHOUT_ACTION_RE.test(stripCliActions(raw)) || initialFabricated || routeGoalStalled)) {
             const fabricationClause = initialFabricated
               ? ' You SIMULATED a tool run by writing <tool_call>/<tool_response> text with made-up results — that is fiction, nothing actually ran. Do NOT simulate or narrate tool output. To run another agent, emit a real run_agent madarx-action block with the target agent id; madarX will execute it and return the real artifact.'
               : '';

package/app/components/app-topbar.jsx

@@ -7,6 +7,7 @@ import { Search, Command, Activity } from 'lucide-react';
 import { subscribeAgentEvents } from '../agents/agent-events-bus.js';
 import { SpinnerIcon, CheckIcon, StepXIcon } from './dashboard/icons';
 import { toolStepDisplayName, toolStepSublabel } from './dashboard/tool-steps.js';
+import { reduceAgentEvent } from './dashboard/bg-agent-reducer.js';
 
 // Pathname prefix → human section label. Longest-prefix wins via order: list
 // more specific paths before their parents.
@@ -34,94 +35,9 @@ function sectionFor(pathname) {
   return hit ? hit[1] : 'madarX';
 }
 
-const STEP_CAP = 8;          // most recent tool steps kept per agent
-const LINGER_MS = 6000;      // keep a finished agent in the list briefly
+const LINGER_MS = 20000;     // keep a finished agent visible long enough to notice
 const ORPHAN_TTL_MS = 120000; // drop a "running" agent with no activity for 2m
 
-// Fold a single live event into the keyed-by-agent activity map. Mirrors the
-// dashboard's use-bg-agents reducer, kept inline here so the global topbar can
-// show background-agent detail on every page from the shared SSE bus.
-function reduceEvent(prev, event) {
-  const id = event.agent_id;
-  if (!id) return prev;
-  const existing = prev[id];
-
-  switch (event.type) {
-    case 'agent_run_start':
-      return {
-        ...prev,
-        [id]: {
-          agent_id: id,
-          agent_name: event.agent_name || id,
-          triggered_by: event.triggered_by || null,
-          status: 'running',
-          started_at: event.ts || Date.now(),
-          current_tool: null,
-          current_input: null,
-          last_activity: event.ts || Date.now(),
-          steps: existing?.steps?.slice(-4) ?? [],
-        },
-      };
-
-    case 'agent_tool_start': {
-      const base = existing || {
-        agent_id: id,
-        agent_name: event.agent_name || id,
-        triggered_by: null,
-        status: 'running',
-        started_at: Date.now(),
-        steps: [],
-      };
-      const ts = event.ts || Date.now();
-      return {
-        ...prev,
-        [id]: {
-          ...base,
-          agent_name: event.agent_name || base.agent_name,
-          status: 'running',
-          current_tool: event.tool,
-          current_input: event.input_summary ?? null,
-          last_activity: ts,
-          steps: [
-            ...base.steps,
-            { tool: event.tool, input: event.input_summary ?? null, status: 'running', ts },
-          ].slice(-STEP_CAP),
-        },
-      };
-    }
-
-    case 'agent_tool_result': {
-      if (!existing) return prev;
-      const steps = [...existing.steps];
-      for (let i = steps.length - 1; i >= 0; i--) {
-        if (steps[i].tool === event.tool && steps[i].status === 'running') {
-          steps[i] = { ...steps[i], status: event.isError ? 'error' : 'done' };
-          break;
-        }
-      }
-      return {
-        ...prev,
-        [id]: { ...existing, current_tool: null, last_activity: event.ts || Date.now(), steps },
-      };
-    }
-
-    case 'agent_run_complete':
-      if (!existing) return prev;
-      return {
-        ...prev,
-        [id]: {
-          ...existing,
-          status: event.isError ? 'failed' : 'complete',
-          finished_at: event.ts || Date.now(),
-          current_tool: null,
-        },
-      };
-
-    default:
-      return prev;
-  }
-}
-
 export default function AppTopbar() {
   const pathname = usePathname();
   const section = useMemo(() => sectionFor(pathname), [pathname]);
@@ -134,9 +50,39 @@ export default function AppTopbar() {
   const wrapRef = useRef(null);
 
   useEffect(() => {
-    return subscribeAgentEvents((event) => {
-      setAgents((cur) => reduceEvent(cur, event));
+    let cancelled = false;
+    // Seed "what's running now" from the persistent snapshot so a run that
+    // started before this connection — or whose start we missed on a reconnect —
+    // appears without waiting for the next live event. Never clobber a richer
+    // live entry (one already tracking tool steps).
+    async function seedActive() {
+      try {
+        const r = await fetch('/api/agents/active-runs');
+        if (!r.ok) return;
+        const { agents: active } = await r.json();
+        if (cancelled || !Array.isArray(active)) return;
+        setAgents((cur) => {
+          let next = cur;
+          for (const a of active) {
+            if (!a.agent_id || next[a.agent_id]) continue;
+            next = reduceAgentEvent(next, {
+              type: 'agent_run_start',
+              agent_id: a.agent_id,
+              agent_name: a.agent_name,
+              triggered_by: a.triggered_by,
+              ts: a.started_at,
+            });
+          }
+          return next;
+        });
+      } catch { /* offline / not ready — live events will catch up */ }
+    }
+    const unsub = subscribeAgentEvents((event) => {
+      if (event.type === 'ready') { seedActive(); return; }
+      setAgents((cur) => reduceAgentEvent(cur, event));
     });
+    seedActive();
+    return () => { cancelled = true; unsub(); };
   }, []);
 
   // Sweep: evict finished agents after a short linger, and orphaned "running"

package/app/components/dashboard/bg-agent-reducer.js

@@ -0,0 +1,125 @@
+// Pure reducer that folds a single live SSE event into the keyed-by-agent
+// background-activity map shown by the global topbar (app-topbar.jsx). Extracted
+// so the resilience rules can be unit-tested without a DOM.
+//
+// Resilience invariant: an entry must surface even when run_start was missed
+// (the two independent EventSource connections — toolbar bus vs command center —
+// can race on connect/reconnect). A sub-agent that ran but had no granted tool
+// emits ONLY run_start + run_complete; if the toolbar misses run_start it would
+// otherwise show nothing while the command center shows the run. So tool_result
+// and run_complete both create an entry when none exists, never silently drop.
+
+export const STEP_CAP = 8; // most recent tool steps kept per agent
+
+export function reduceAgentEvent(prev, event) {
+  const id = event.agent_id;
+  if (!id) return prev;
+  const existing = prev[id];
+
+  switch (event.type) {
+    case 'agent_run_start':
+      return {
+        ...prev,
+        [id]: {
+          agent_id: id,
+          agent_name: event.agent_name || id,
+          triggered_by: event.triggered_by || null,
+          status: 'running',
+          started_at: event.ts || Date.now(),
+          current_tool: null,
+          current_input: null,
+          last_activity: event.ts || Date.now(),
+          steps: existing?.steps?.slice(-4) ?? [],
+        },
+      };
+
+    case 'agent_tool_start': {
+      const base = existing || {
+        agent_id: id,
+        agent_name: event.agent_name || id,
+        triggered_by: null,
+        status: 'running',
+        started_at: Date.now(),
+        steps: [],
+      };
+      const ts = event.ts || Date.now();
+      return {
+        ...prev,
+        [id]: {
+          ...base,
+          agent_name: event.agent_name || base.agent_name,
+          status: 'running',
+          current_tool: event.tool,
+          current_input: event.input_summary ?? null,
+          last_activity: ts,
+          steps: [
+            ...base.steps,
+            { tool: event.tool, input: event.input_summary ?? null, status: 'running', ts },
+          ].slice(-STEP_CAP),
+        },
+      };
+    }
+
+    case 'agent_tool_result': {
+      // A tool result for an agent we never saw start (missed run_start on a
+      // late/reconnected SSE connection) must still surface the agent — create a
+      // running entry from the result rather than dropping it.
+      if (!existing) {
+        const ts = event.ts || Date.now();
+        return {
+          ...prev,
+          [id]: {
+            agent_id: id,
+            agent_name: event.agent_name || id,
+            triggered_by: null,
+            status: 'running',
+            started_at: ts,
+            current_tool: null,
+            last_activity: ts,
+            steps: [{ tool: event.tool, status: event.isError ? 'error' : 'done', ts }],
+          },
+        };
+      }
+      const steps = [...existing.steps];
+      for (let i = steps.length - 1; i >= 0; i--) {
+        if (steps[i].tool === event.tool && steps[i].status === 'running') {
+          steps[i] = { ...steps[i], status: event.isError ? 'error' : 'done' };
+          break;
+        }
+      }
+      return {
+        ...prev,
+        [id]: { ...existing, current_tool: null, last_activity: event.ts || Date.now(), steps },
+      };
+    }
+
+    case 'agent_run_complete': {
+      // Never silently drop a completion. If run_start was missed (reconnect
+      // race) and the run emitted no tool events — e.g. a sub-agent that ran but
+      // had no granted tool to call — this is the ONLY event we get for it.
+      // Without this, the toolbar shows nothing while the command center (whose
+      // connection caught run_start) shows the run. Create a finished entry so
+      // both panels agree.
+      const finishedAt = event.ts || Date.now();
+      const base = existing || {
+        agent_id: id,
+        agent_name: event.agent_name || id,
+        triggered_by: event.triggered_by || null,
+        started_at: finishedAt,
+        steps: [],
+      };
+      return {
+        ...prev,
+        [id]: {
+          ...base,
+          status: event.isError ? 'failed' : 'complete',
+          finished_at: finishedAt,
+          current_tool: null,
+        },
+      };
+    }
+
+    default:
+      return prev;
+  }
+}

package/app/components/dashboard/use-bg-agents.js

@@ -10,6 +10,39 @@ export function useBgAgents({ refresh, runs }) {
   useEffect(() => {
     if (typeof window === 'undefined' || !window.EventSource) return;
     const src = new EventSource('/api/events/stream');
+    let cancelled = false;
+
+    // Seed running agents from the persistent snapshot on mount and on every
+    // (re)connect, so a run in flight before this EventSource connected (or whose
+    // agent_run_start was missed on a reconnect) still shows. Never clobber a
+    // richer live entry already tracking tool steps.
+    async function seedActive() {
+      try {
+        const r = await fetch('/api/agents/active-runs');
+        if (!r.ok) return;
+        const { agents } = await r.json();
+        if (cancelled || !Array.isArray(agents)) return;
+        setBgAgents(prev => {
+          let changed = false;
+          const next = { ...prev };
+          for (const a of agents) {
+            if (!a.agent_id || next[a.agent_id]) continue;
+            next[a.agent_id] = {
+              agent_id: a.agent_id,
+              agent_name: a.agent_name || a.agent_id,
+              triggered_by: a.triggered_by || null,
+              status: 'running',
+              started_at: a.started_at || Date.now(),
+              steps: [],
+            };
+            changed = true;
+          }
+          return changed ? next : prev;
+        });
+      } catch { /* offline / not ready — live events will catch up */ }
+    }
+    seedActive();
+    src.addEventListener('ready', () => { seedActive(); });
 
     function applyToolStart(evt) {
       const id = evt.agent_id;
@@ -137,6 +170,7 @@ export function useBgAgents({ refresh, runs }) {
     src.onerror = () => { /* let browser auto-reconnect */ };
 
     return () => {
+      cancelled = true;
       src.close();
     };
   }, []);

package/app/projects/[slug]/page.js

@@ -6,6 +6,7 @@ import ProjectAlbum from './album-view.jsx';
 import ProjectDropZone from './project-drop-zone.jsx';
 import ProjectHeaderActions from './header-actions.jsx';
 import { ProjectAlbumProvider } from './project-album-context.jsx';
+import ProjectScopeSync from './project-scope-sync.jsx';
 import { isProjectsLiveDeltasEnabled } from '../../../lib/feature-flags.js';
 
 export const dynamic = 'force-dynamic';
@@ -43,6 +44,7 @@ export default async function ProjectPage({ params, searchParams }) {
       currentFolderId={currentFolderId}
       liveDeltasEnabled={isProjectsLiveDeltasEnabled()}
     >
+      <ProjectScopeSync projectId={project.id} />
       <AdminShell
         kicker="Project"
         title={project.name}

package/app/projects/[slug]/project-scope-sync.jsx

@@ -0,0 +1,26 @@
+'use client';
+
+import { useEffect } from 'react';
+
+/**
+ * Scope the chat to this project. The main dashboard chat reads its active
+ * project from localStorage (`madarx:selected-project`) on mount and sends it
+ * as `project_id` to /api/orchestrator/stream — which scopes the disk_* tools
+ * (disk_list_files / disk_read_file) and artifact destination. Viewing a
+ * project here marks it active so the next chat turn reads THIS project's Disk,
+ * not 'personal' or whatever was last selected.
+ *
+ * Render-null effect component; persistence only. Manual project switches in
+ * the dashboard overwrite this later, which is the intended last-touch-wins.
+ */
+export default function ProjectScopeSync({ projectId }) {
+  useEffect(() => {
+    if (!projectId) return;
+    try {
+      if (localStorage.getItem('madarx:selected-project') !== projectId) {
+        localStorage.setItem('madarx:selected-project', projectId);
+      }
+    } catch { /* storage disabled — chat falls back to last/default scope */ }
+  }, [projectId]);
+  return null;
+}

package/lib/active-runs.js

@@ -31,3 +31,8 @@ export function clearRunActive(agentId) {
 export function isRunActive(agentId) {
   return (counts.get(String(agentId || '')) || 0) > 0;
 }
+
+/** All agent ids with a live in-process manual run (count > 0). */
+export function listActiveRunIds() {
+  return Array.from(counts.keys()).filter((id) => (counts.get(id) || 0) > 0);
+}

package/lib/agent-config.js

@@ -18,11 +18,13 @@ You DELEGATE specialist work; you do not perform it yourself. Specialist domain
 
 For ANY request longer than a one-line factual reply, set the goal in one sentence, then call route_goal(goal) FIRST. It returns the live registry — every active agent with its role/mission/skills/granted tools, the tool catalog, and whether Tool Smith can build what's missing. Reason over it and pick exactly one ladder step:
   1. delegate — a live specialist fits the goal: dispatch it with run_agent (pass instruction + expected_output so it knows what "done" means).
-  2. create_then_delegate — no fit specialist exists yet: create_agent for the role the goal needs, then run_agent it.
+  2. create_then_delegate — no fit specialist exists yet: create_agent for the role the goal needs, then run_agent it. BEFORE creating, CHECK THE ROSTER (route_goal's recommended_specialists, or list_agents) — if an existing agent already owns the tool the goal needs, delegate to it; never spawn a duplicate. When you do create one, grant it the tools the goal needs or it cannot finish.
   3. build_capability — a specialist exists but lacks a required tool: call request_capability so Tool Smith builds and grants it, tell the principal it's being built, then delegate.
   4. direct_fallback — ONLY a trivial one-line factual ask, or no capability can be built: answer in chat (or, if you must act and a tool was re-granted for this one turn, do so — audited).
 This works for ANY goal, not a fixed list of domains — route_goal grounds the decision in real capabilities. fast_path_hint is a shortcut for obvious cases, never the whole answer. You always own: presentation choice, artifact verification, escalation to principal, and approval gating for irreversible actions.
 
+TASK TRACKING (automatic): every run_agent delegation is filed as a tracked task on the /tasks board (assignee = the specialist), runs to completion, and its status is updated for you (in_progress → in_review → done, or blocked on failure). A background sweep re-drives any task that stalls. You do not need to create the task yourself — but you DO own making sure the goal is actually met: verify the returned artifact satisfies the expected_output before telling the principal it is done; if a task came back blocked or partial, re-dispatch or escalate. Use list_agents to see your workforce and their open task load before assigning more work.
+
 TOOL_USE_DISCIPLINE
 - Never end a turn with a promise of future action. If you say you will do X, call the tool for X in the same response.
 - Keep calling tools until: (a) task complete, (b) result verified, (c) artifact on canvas or a one-line chat answer is appropriate.

package/lib/agent-engines.js

@@ -670,7 +670,7 @@ function isDir(p) {
   try { return Boolean(p) && fs.statSync(p).isDirectory(); } catch { return false; }
 }
 
-function agentSubprocessCwd() {
+export function agentSubprocessCwd() {
   for (const dir of [WORKSPACE, DATA_DIR, PROJECT_ROOT, process.cwd()]) {
     if (isDir(dir)) return dir;
   }