madarx 2.18.0 → 2.21.0

package/lib/orchestrator-tools.js

@@ -40,6 +40,8 @@ import {
 import { resolveSafePath } from './tools/safety.js';
 import { executeRegistryTool, getEnabledToolSchemas, listMarketplaceTools, setToolEnabled } from './tools/registry.js';
 import { listMarketplaceItems } from './marketplace.js';
+import { buildRoutingContext } from './agent-routing.js';
+import { isSpecialistTool } from './role-capability-map.js';
 import { createTask, listTasks } from './delegation.js';
 import { runSingleReport } from './mines/diligence.js';
 import { getBridgeHealth, sendWhatsAppDocument, sendWhatsAppMessage } from './whatsapp.js';
@@ -1066,6 +1068,21 @@ export const CORE_TOOLS = [
       required: ['tool_name'],
     },
   },
+  {
+    name: 'route_goal',
+    description:
+      'CALL THIS FIRST for any non-trivial request, BEFORE attempting a specialist task yourself. It grounds your delegation decision: given the user goal, it returns the live capability registry — every active agent with its role, mission, skills, and granted tools; the enabled-tool catalog; whether Tool Smith is available to build missing capabilities — plus the fallback ladder. Reason over it and pick the path: delegate to a fit specialist (run_agent), create_then_delegate when none fits (create_agent), build_capability when a specialist exists but lacks a required tool (request_capability), or direct_fallback for a trivial one-line factual answer. Read-only, no side effects.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        goal: {
+          type: 'string',
+          description: 'The user goal in one sentence, e.g. "find a return flight DXB to London for May 18-25" or "draft a reply to this email".',
+        },
+      },
+      required: ['goal'],
+    },
+  },
   {
     name: 'request_capability',
     description:
@@ -1093,10 +1110,28 @@ export const CORE_TOOLS = [
 
 const HERMES_TOOL_NAMES = new Set(['send_to_hermes', 'start_hermes_job']);
 
+/**
+ * Names of enabled marketplace tools in a SPECIALIST-owned category. These are
+ * stripped from the MAIN agent's directly-callable catalog so specialist work
+ * must be delegated to an agent that owns the tool (the load-bearing
+ * delegation-first gate). Sub-agents still receive their granted specialist
+ * tools via getEnabledToolSchemasForAgent — the narrowing applies to the
+ * orchestrator catalog only. Kill-switch: MADARX_DELEGATION_ENFORCEMENT=off.
+ */
+function mainAgentDirectDenylist() {
+  if (process.env.MADARX_DELEGATION_ENFORCEMENT === 'off') return new Set();
+  try {
+    return new Set(listMarketplaceTools().filter(isSpecialistTool).map(t => t.name));
+  } catch {
+    return new Set();
+  }
+}
+
 export function getTools() {
   const hermesOk = isHermesAvailable();
   const coreTools = hermesOk ? CORE_TOOLS : CORE_TOOLS.filter(t => !HERMES_TOOL_NAMES.has(t.name));
-  return getEnabledToolSchemas(coreTools);
+  const denylist = mainAgentDirectDenylist();
+  return getEnabledToolSchemas(coreTools).filter(t => !denylist.has(t.name));
 }
 
 export const TOOLS = CORE_TOOLS;
@@ -1280,6 +1315,19 @@ export function clampToolResult(value) {
  * @returns {unknown}
  */
 export async function executeTool(toolName, input = {}, context = {}) {
+  // Load-bearing delegation-first gate (main-agent path, both Anthropic + CLI
+  // engines): specialist domain tools are not the orchestrator's to call. Block
+  // here so even a CLI engine emitting a raw madarx-action cannot bypass the
+  // catalog narrowing that hides them from the Anthropic schema. Sub-agents go
+  // through executeRegistryTool and are unaffected. Kill-switch via
+  // MADARX_DELEGATION_ENFORCEMENT=off (honored inside mainAgentDirectDenylist).
+  if (mainAgentDirectDenylist().has(toolName)) {
+    return clampToolResult({
+      ok: false,
+      error: 'delegate_required',
+      message: `"${toolName}" is a specialist tool you do not own directly. Call route_goal(goal), then delegate to the agent that owns it with run_agent — or request_capability if no agent has it.`,
+    });
+  }
   const result = await dispatchTool(toolName, input, context);
   return clampToolResult(result);
 }
@@ -1375,7 +1423,7 @@ async function dispatchTool(toolName, input = {}, context = {}) {
       return sendWhatsAppMessage(input.chat_id, input.text);
 
     case 'run_agent':
-      return runAgentOnDemand(input);
+      return runAgentOnDemand(input, context);
 
     case 'mines_run_report':
       // One-action mines report trigger from chat. The actual report tool call
@@ -1411,6 +1459,9 @@ async function dispatchTool(toolName, input = {}, context = {}) {
     case 'uninstall_tool':
       return uninstallToolHandler(input);
 
+    case 'route_goal':
+      return buildRoutingContext({ goal: input.goal, project_id: context.project_id || null });
+
     case 'request_capability':
       return requestCapabilityHandler(input, context);
 
@@ -1572,13 +1623,16 @@ function resolveAgentId({ agent_id, agent_name }) {
   return { ok: false, error: 'Pass either agent_id or agent_name.' };
 }
 
-async function runAgentOnDemand(input) {
+async function runAgentOnDemand(input, context = {}) {
   const resolved = resolveAgentId(input);
   if (!resolved.ok) return { ok: false, error: resolved.error };
   const agent = resolved.agent;
   const wake_reason = input.wake_reason || 'on-demand from main agent';
   const instruction = typeof input.instruction === 'string' && input.instruction.trim() ? input.instruction.trim() : null;
   const expected_output = typeof input.expected_output === 'string' && input.expected_output.trim() ? input.expected_output.trim() : null;
+  // Owner-granted inline approvals to inject into this sub-agent's matching tool
+  // calls (so an approved gate resumes instead of re-prompting).
+  const pending_approvals = Array.isArray(context.pending_approvals) ? context.pending_approvals : [];
   try {
     // Per-call overrides are auditable but NOT persisted onto the agent row —
     // they shape this single run's prompt only (see runAgentTick precedence).
@@ -1590,20 +1644,23 @@ async function runAgentOnDemand(input) {
         meta: { agent_id: agent.id, wake_reason, has_instruction: Boolean(instruction), has_expected_output: Boolean(expected_output) },
       });
     }
-    const run = await runAgentTick(agent.id, { triggered_by: 'main_agent', wake_reason, instruction, expected_output });
+    const run = await runAgentTick(agent.id, { triggered_by: 'main_agent', wake_reason, instruction, expected_output, pending_approvals });
     if (!run) return { ok: false, error: `runAgentTick returned null for ${agent.id}` };
     return {
       ok: true,
       agent_id: agent.id,
       agent_name: agent.name,
       run_id: run.id,
-      status: run.status || 'complete',
+      status: run.pending_approval ? 'awaiting_approval' : (run.status || 'complete'),
       title: run.artifact_title || run.title,
       preview: (run.preview || '').slice(0, 600),
       // Addressable artifact row (for pinning to the canvas). `artifact` stays
       // the file-path string for backward compatibility.
       artifact_id: run.artifact_id || null,
       artifact: run.artifact || null,
+      // Inline-approval surface: when the sub-agent paused on an owner-approval
+      // gate, this carries the approval the chat should render as Approve/Deny.
+      pending_approval: run.pending_approval || null,
     };
   } catch (err) {
     return { ok: false, error: err.message, agent_id: agent.id };

package/lib/public-url.js

@@ -0,0 +1,89 @@
+/**
+ * lib/public-url.js — the canonical public base URL of this install.
+ *
+ * Invite links and share links get COPIED and sent to other people, so they must
+ * point at a URL the recipient can actually reach — not `window.location.origin`
+ * of whoever generated them (which is `http://localhost:8787` in dev). This is
+ * the single source of truth for that base URL.
+ *
+ * Precedence:
+ *   config table  `public_base_url`   (UI-settable from Settings → Team)
+ *   → env  MADARX_PUBLIC_URL / MADARX_PUBLIC_SHARE_BASE_URL / NEXT_PUBLIC_SHARE_BASE_URL / NEXT_PUBLIC_SITE_URL
+ *   → ''   (callers fall back to the request origin)
+ *
+ * Server-only (reads the config table via lib/config.js). For client code, the
+ * value is surfaced through GET /api/auth/config.
+ */
+
+import { getConfig, setConfig } from './config.js';
+
+export const PUBLIC_BASE_URL_KEY = 'public_base_url';
+
+const ENV_KEYS = [
+  'MADARX_PUBLIC_URL',
+  'MADARX_PUBLIC_SHARE_BASE_URL',
+  'NEXT_PUBLIC_SHARE_BASE_URL',
+  'NEXT_PUBLIC_SITE_URL',
+];
+
+function clean(raw) {
+  if (!raw || !String(raw).trim()) return '';
+  const value = String(raw).trim().replace(/\/+$/, '');
+  return /^https?:\/\//i.test(value) ? value : '';
+}
+
+/** True for a syntactically valid http(s) URL. */
+export function isValidPublicUrl(raw) {
+  const v = clean(raw);
+  if (!v) return false;
+  try {
+    new URL(v);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The configured public base URL, or '' when none is set. Never trailing-slashed. */
+export function getPublicBaseUrl() {
+  try {
+    const stored = clean(getConfig(PUBLIC_BASE_URL_KEY, null));
+    if (stored) return stored;
+  } catch {
+    // config table not ready (very early boot) — fall through to env.
+  }
+  for (const key of ENV_KEYS) {
+    const v = clean(process.env[key]);
+    if (v) return v;
+  }
+  return '';
+}
+
+/**
+ * Persists the public base URL (UI-driven). Pass '' to clear it (fall back to
+ * env / request origin). Throws on a non-http(s) value.
+ */
+export function setPublicBaseUrl(raw) {
+  const trimmed = raw == null ? '' : String(raw).trim();
+  if (trimmed === '') {
+    setConfig(PUBLIC_BASE_URL_KEY, '');
+    return '';
+  }
+  if (!isValidPublicUrl(trimmed)) {
+    throw new Error('public app URL must be a valid http(s) URL, e.g. https://madarx.io');
+  }
+  const value = clean(trimmed);
+  setConfig(PUBLIC_BASE_URL_KEY, value);
+  return value;
+}
+
+/**
+ * Joins a path onto the public base URL. Returns the bare path when no base is
+ * configured, so callers can prepend the request origin as a fallback.
+ */
+export function publicUrl(path) {
+  const p = String(path || '');
+  const normalizedPath = p.startsWith('/') ? p : `/${p}`;
+  const base = getPublicBaseUrl();
+  return base ? `${base}${normalizedPath}` : normalizedPath;
+}

package/lib/role-capability-map.js

@@ -0,0 +1,89 @@
+/**
+ * Role ↔ capability hints for delegation-first routing.
+ *
+ * IMPORTANT: this file is a FAST-PATH HINT + SEED LIST, not the routing
+ * authority. The authoritative routing decision is the main agent reasoning
+ * over the live registry returned by lib/agent-routing.js::buildRoutingContext.
+ * A goal whose domain is absent from these maps still routes correctly via the
+ * grounded context + the fallback ladder — these maps only let obvious cases
+ * skip the reasoning round-trip and tell the seeder which specialists to plant.
+ *
+ * Keyed off the `category` field every MARKETPLACE_TOOLS entry already carries
+ * (lib/tools/registry.js), so adding a tool category here is the only manual
+ * step — no per-tool wiring.
+ */
+
+/**
+ * Tool categories that are SPECIALIST-OWNED: their tools are removed from the
+ * main agent's directly-callable catalog (see getTools() narrowing) and are
+ * reachable only by delegating to an agent that owns them.
+ *
+ * Scope note: the hard gate covers clear specialist WORK domains with low
+ * main-agent overlap. Deliberately NOT specialist (kept on the main agent):
+ *  - web        → web_search / web_fetch are the orchestrator's quick-fact allowance.
+ *  - voice      → voice_speak is how the main/voice agent talks — a mechanism, not a domain.
+ *  - browser    → browser_* is a main-agent mechanism (BROWSER_CONTROL contract).
+ *  - github     → heavy main-agent overlap (read context); routing + prompt steer
+ *                 engineering work to engineering_lead without a structural block (follow-up).
+ *  - authoring  → skill/composite/connector authoring belongs to the Tool Smith flow.
+ *  - workflow   → process-definition tools are orchestration.
+ *  - core/system/cli_generator → orchestration + presentation primitives.
+ *  - local_machine → file_read etc. used by the orchestrator for grounding.
+ */
+export const SPECIALIST_TOOL_CATEGORIES = new Set([
+  'travel',
+  'email',
+  'calendar',
+  'supabase',
+  'vercel',
+  'mines',
+]);
+
+/**
+ * Obvious-domain shortcut: tool category → the specialist role that owns it.
+ * Only a hint for fastPathHint(); never the sole basis of a routing decision.
+ */
+export const CATEGORY_TO_ROLE = {
+  travel: 'travel_concierge',
+  email: 'personal_assistant',
+  github: 'engineering_lead',
+  calendar: 'ops_manager',
+  supabase: 'web_ecommerce',
+  vercel: 'web_ecommerce',
+  browser: 'web_ecommerce',
+  voice: 'content_social',
+};
+
+/**
+ * Lightweight keyword → category guesses for fastPathHint(). Intentionally
+ * small: clear wins only. Anything not matched here falls through to the LLM
+ * reasoning over buildRoutingContext — which is the point.
+ */
+export const KEYWORD_CATEGORY_HINTS = [
+  [/\b(flight|flights|fly|airfare|airline|hotel|hotels|itinerary|trip|travel|book a (room|stay))\b/i, 'travel'],
+  [/\b(email|inbox|reply to .*(mail|message)|draft a (reply|mail|email)|gmail)\b/i, 'email'],
+  [/\b(pull request|\bpr\b|open an? issue|github|merge|commit|repo|repository)\b/i, 'github'],
+  [/\b(calendar|schedule a (meeting|call)|book (a )?(meeting|slot|30 ?min)|invite .* to)\b/i, 'calendar'],
+  [/\b(deploy|vercel|production build|ship the site)\b/i, 'vercel'],
+  [/\b(supabase|database row|insert into|update the table|sql)\b/i, 'supabase'],
+];
+
+/**
+ * Specialists to AUTO-SEED on first launch so the most common delegation
+ * targets exist out of the box. Kept minimal: every other domain is covered by
+ * the `create_then_delegate` ladder step at runtime. Each entry is an
+ * agent-templates.js slug; the seeder installs it idempotently.
+ */
+export const SEED_SPECIALISTS = [
+  'travel-concierge',
+];
+
+/** True when a marketplace tool belongs to a specialist-owned category. */
+export function isSpecialistTool(tool) {
+  return Boolean(tool && SPECIALIST_TOOL_CATEGORIES.has(tool.category));
+}
+
+/** Obvious role for a tool category, or null when there is no clear owner. */
+export function roleForCategory(category) {
+  return CATEGORY_TO_ROLE[category] || null;
+}

package/lib/runtime.js

@@ -1483,8 +1483,20 @@ function processesSnapshot(projectId) {
 
 // ── Chat sessions ─────────────────────────────────────────────────────────────
 
+// A live turn older than this is treated as stale (server crashed mid-turn
+// without clearing the flag), so the session reports idle and self-heals.
+const ACTIVE_TURN_TTL_MS = Number(process.env.MADARX_ACTIVE_TURN_TTL_MS) || 900000; // 15min
+
+function isActiveTurnFresh(startedAt) {
+  if (!startedAt) return false;
+  const started = Date.parse(startedAt);
+  if (Number.isNaN(started)) return false;
+  return (Date.now() - started) < ACTIVE_TURN_TTL_MS;
+}
+
 function rowToChatSession(row) {
   if (!row) return null;
+  const fresh = isActiveTurnFresh(row.active_turn_started_at);
   return {
     id: row.id,
     title: row.title,
@@ -1497,6 +1509,10 @@ function rowToChatSession(row) {
     total_cache_read_tokens: row.total_cache_read_tokens,
     total_cache_creation_tokens: row.total_cache_creation_tokens,
     last_context_tokens: row.last_context_tokens,
+    // Only surface the turn id while it is fresh — a stale flag reads as idle.
+    active_turn_id: fresh ? (row.active_turn_id || null) : null,
+    active_turn_started_at: fresh ? (row.active_turn_started_at || null) : null,
+    agent_working: fresh && Boolean(row.active_turn_id),
   };
 }
 
@@ -1613,6 +1629,28 @@ export function appendChatMessage(session_id, {
   return { id, session_id, role, at };
 }
 
+// Mark a chat session as having a live (streaming) turn in flight, or clear it.
+// Pass a turnId to begin, null to end. Idempotent and best-effort: a missing
+// session row is a no-op (it may have been deleted mid-turn).
+export function setSessionActiveTurn(session_id, turnId) {
+  if (!session_id) return { ok: false };
+  const db = getDb();
+  try {
+    if (turnId) {
+      db.prepare(
+        'UPDATE chat_sessions SET active_turn_id = ?, active_turn_started_at = ? WHERE id = ?'
+      ).run(String(turnId), nowIso(), session_id);
+    } else {
+      db.prepare(
+        'UPDATE chat_sessions SET active_turn_id = NULL, active_turn_started_at = NULL WHERE id = ?'
+      ).run(session_id);
+    }
+    return { ok: true };
+  } catch {
+    return { ok: false };
+  }
+}
+
 export function renameChatSession(id, title) {
   const db = getDb();
   const t = String(title || '').slice(0, 200);

package/lib/schema.js

@@ -516,7 +516,12 @@ CREATE TABLE IF NOT EXISTS chat_sessions (
   total_output_tokens INTEGER NOT NULL DEFAULT 0,
   total_cache_read_tokens INTEGER NOT NULL DEFAULT 0,
   total_cache_creation_tokens INTEGER NOT NULL DEFAULT 0,
-  last_context_tokens INTEGER NOT NULL DEFAULT 0
+  last_context_tokens INTEGER NOT NULL DEFAULT 0,
+  -- Live-turn continuity: set while an orchestrator turn is streaming for this
+  -- session, cleared when it finishes. active_turn_started_at gates a TTL so a
+  -- crashed turn self-heals to "idle" instead of pinning the flag forever.
+  active_turn_id TEXT,
+  active_turn_started_at TEXT
 );
 
 CREATE TABLE IF NOT EXISTS whatsapp_messages (

package/lib/seeds.js

@@ -5,6 +5,7 @@ import { ROOT } from './paths.js';
 import { seedMarketplaceItems } from './marketplace-seeds.js';
 import { ensureDefaultProject } from './projects.js';
 import { seedAgentTemplates, installAgentTemplate } from './agent-templates.js';
+import { SEED_SPECIALISTS } from './role-capability-map.js';
 import { ensureOpsAgent, createArtifact, migrateDefaultAgentSkills } from './runtime.js';
 import { renderChangelogHtml } from './artifact-format.js';
 import { migrateArtifactsToProjects } from './artifact-migration.js';
@@ -347,6 +348,28 @@ function seedToolSmithAgentIfMissing(db) {
   }
 }
 
+/**
+ * Auto-seed the minimal specialist set (lib/role-capability-map.js
+ * SEED_SPECIALISTS) on first launch so delegation-first routing always has the
+ * most common targets — e.g. a Travel Concierge — instead of forcing the main
+ * agent to create_then_delegate on the very first request.
+ *
+ * Idempotent per template via agent_template_installations; if the user deletes
+ * one it stays deleted. Every other domain is still covered at runtime by the
+ * create_then_delegate / build_capability ladder. Silent + non-fatal.
+ */
+function seedSpecialistAgentsIfMissing(db) {
+  for (const slug of SEED_SPECIALISTS) {
+    try {
+      const installed = db.prepare('SELECT agent_id FROM agent_template_installations WHERE template_slug = ? LIMIT 1').get(slug);
+      if (installed) continue;
+      installAgentTemplate(slug, 'personal', { seed: true });
+    } catch (err) {
+      console.warn(`[seeds] seedSpecialistAgentsIfMissing(${slug}) failed:`, err?.message || err);
+    }
+  }
+}
+
 /**
  * Fire-and-forget disk-encryption health check on each boot.
  *
@@ -537,6 +560,7 @@ export function seedDefaults(db) {
 
   // Auto-seed the Tool Smith agent so request_capability delegation has a target.
   seedToolSmithAgentIfMissing(db);
+  seedSpecialistAgentsIfMissing(db);
 
   // Refresh the business-default skills in existing default-shaped skills.md
   // files (no-op for fresh installs and user-customized agents). Idempotent.

package/lib/share-url.js

@@ -1,21 +1,13 @@
-const SHARE_BASE_ENV_KEYS = [
-  'MADARX_PUBLIC_SHARE_BASE_URL',
-  'NEXT_PUBLIC_SHARE_BASE_URL',
-  'NEXT_PUBLIC_SITE_URL',
-];
+/**
+ * lib/share-url.js — share-link URL builder.
+ *
+ * Thin back-compat wrapper over lib/public-url.js (the single source of truth
+ * for this install's public base URL, now UI-settable from Settings → Team).
+ * Kept so existing imports of `publicShareUrl` keep working.
+ */
 
-function normalizedBaseUrl() {
-  for (const key of SHARE_BASE_ENV_KEYS) {
-    const raw = process.env[key];
-    if (!raw || !String(raw).trim()) continue;
-    const value = String(raw).trim().replace(/\/+$/, '');
-    if (/^https?:\/\//i.test(value)) return value;
-  }
-  return '';
-}
+import { publicUrl } from './public-url.js';
 
 export function publicShareUrl(path) {
-  const normalizedPath = String(path || '').startsWith('/') ? String(path || '') : `/${path || ''}`;
-  const base = normalizedBaseUrl();
-  return base ? `${base}${normalizedPath}` : normalizedPath;
+  return publicUrl(path);
 }