madarx 2.19.0 → 2.21.0

package/CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to Madarx OS. Newest first.
 
 ## Unreleased
 
+## [2.21.0] - 2026-06-06
+
+### Added
+
+- **Higgsfield AI generation — native tools, easy connect, results on the canvas.** Three approval-gated registry tools (`higgsfield_generate_image` — Soul text-to-image, `higgsfield_product_photoshoot` — image-conditioned product imagery, `higgsfield_generate_video` — DoP image-to-video) backed by one async submit-then-poll adapter (`lib/tools/adapters/higgsfield.js`; base `platform.higgsfield.ai`, `Authorization: Key <id>:<secret>`, egress-logged, credentials never echoed; risk `high`, `enabled_default:false`). A new `kind:'connection'` (`higgsfield`, api_key: `HIGGSFIELD_KEY_ID` + `HIGGSFIELD_KEY_SECRET`) plus a `verifyHiggsfield` path lets a user paste a key once and use it. The marketplace bundle (`higgsfield`, 4 skills) is now **actually installable** — `setItemInstalled` installs each referenced item + surfaces a `requires_connection` hint (replacing the Phase-2 "deferred" stub). Generated media renders **directly on the canvas**: main-agent runs emit a branded media card (`lib/higgsfield-media-card.js`), and delegated sub-agent runs build an embedded gallery artifact (image shown inline, markdown spec preserved as `source_md`) instead of a link-only document. Files: `lib/tools/adapters/higgsfield.js`, `lib/higgsfield-media-card.js`, `lib/tools/registry.js`, `lib/connection-seeds.js`, `lib/marketplace-seeds.js`, `lib/marketplace.js`, `lib/agent-runner.js`. Tests: `tests/marketplace-listing.test.js`, `tests/marketplace-api.test.js`.
+- **Connect-to-unlock: a verified connection auto-enables its tools.** On successful verify, `enableUnlockedTools` flips every registry tool the connection declares in `manifest.unlocks_tool_slugs` to enabled — so a freshly connected service is callable from chat without a separate `/tools` toggle. Generic across all connections; guarded to real registry tools; audited (`connection.tools.auto_enabled`). Enabling only makes a tool *callable* — `high`/`irreversible_external` tiers still hit the approval gate at execution, so consent is never bypassed. File: `app/api/connections/[service]/verify/route.js`.
+- **Inline sub-agent approvals in chat (no approvals page).** When a delegated sub-agent pauses on an owner-approval gate, the chat thread now shows an **Approve / Deny** card instead of sending the owner to the approvals page and losing the activity feed. Approve **re-dispatches the exact delegation** (captured on the approval payload) with the granted `approval_id` injected so the gated tool consumes it and runs — result pins to the canvas, live tool events show in the activity toolbar. `runAgentTick` gains `pending_approvals` injection + `created_approvals` reporting + resume-context persistence; `run_agent` threads approvals through; the orchestrator emits an `agent_approval` SSE event; a new `POST /api/agents/resume-approval` performs the approve-and-re-dispatch (security-checked — `consumeApprovalRequest` requires `approved` status). Files: `lib/agent-runner.js`, `lib/orchestrator-tools.js`, `app/api/orchestrator/stream/route.js`, `app/api/agents/resume-approval/route.js`, `app/components/dashboard/{apply-stream-event.js,use-stream-command.js,chat-panel.jsx}`.
+
+## [2.20.0] - 2026-06-06
+
+### Added
+
+- **Delegation-first goal enforcement (route → delegate → build-if-missing → verify).** The main agent now turns a request into a goal and routes it to the dedicated specialist that owns the tools, instead of doing specialist work itself. Enforcement is **structural, not prompt-only**: specialist domain tools (travel, email, calendar, supabase, vercel, mines) are stripped from the main agent's directly-callable catalog (`getTools()` narrowing) and blocked at the `executeTool` entry with `delegate_required` — so neither the Anthropic loop nor a CLI engine emitting a raw `madarx-action` can bypass it; sub-agents still receive their granted tools via `getEnabledToolSchemasForAgent`. Routing is **LLM-reasoned over a live capability registry, not a keyword table**: the new `route_goal` core tool returns every active agent (role/mission/skills/granted tools), the tool catalog, and whether Tool Smith can build what's missing, plus the exhaustive fallback ladder `delegate → create_then_delegate → build_capability → direct_fallback` — so any goal resolves to a path, including novel domains absent from the hint map. A **Travel Concierge** specialist is auto-seeded on first launch (idempotent, mirrors the Tool Smith seed) so the most common delegation target exists out of the box. Specialist sub-agents that hit a missing tool emit a `madarx-escalate` block; `runAgentTick` files a Tool Smith build task on their behalf and ends the run **blocked** (no half-answer, no new sub-agent privilege — `request_capability` stays orchestrator-only). `CORE_CONTRACTS` (`ORCHESTRATOR_MODE`, reconciled `LIVE_DATA_RESEARCH_RULE`, new `GOAL_COMPLETION_RULE`) and the CLI prompt are rewritten to the route→delegate→verify contract. Kill-switch: `MADARX_DELEGATION_ENFORCEMENT=off`. Spec: `specs/active/delegation-first-goal-enforcement.md`. Files: `lib/role-capability-map.js`, `lib/agent-routing.js`, `lib/orchestrator-tools.js`, `lib/agent-runner.js`, `lib/agent-config.js`, `lib/agent-templates.js`, `lib/seeds.js`, `app/api/orchestrator/stream/route.js`. Tests: `tests/delegation-routing.test.js`.
+
 ## [2.19.0] - 2026-06-06
 
 ### Added

package/app/api/agents/resume-approval/route.js

@@ -0,0 +1,102 @@
+// Resume a delegated sub-agent run after the owner approves its tool inline in chat.
+//
+// POST /api/agents/resume-approval  body: { approval_id }
+//   1. Approve the pending request (decideApprovalRequest 'approved').
+//   2. Re-dispatch the EXACT delegation captured on the approval payload
+//      (payload.resume = { agent_id, instruction, expected_output }), injecting
+//      the now-approved approval_id so the sub-agent's gated tool consumes it
+//      instead of re-prompting.
+//   3. Return the produced artifact so the chat pins it to the canvas.
+//
+// This keeps the owner in the chat — they never visit the approvals page, and the
+// re-dispatch publishes live tool events so the activity toolbar shows the work.
+
+import { getApprovalRequest, decideApprovalRequest } from '@/lib/approvals.js';
+import { requireSession } from '@/lib/auth.js';
+import { runAgentTick } from '@/lib/agent-runner.js';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+function requireAdmin(session) {
+  if (session.role !== 'admin' && session.role !== 'owner') {
+    throw { status: 403, error: 'forbidden' };
+  }
+}
+
+export async function POST(req) {
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return Response.json({ ok: false, error: 'invalid_json' }, { status: 400 });
+  }
+  const approvalId = typeof body?.approval_id === 'string' ? body.approval_id.trim() : '';
+  if (!approvalId) return Response.json({ ok: false, error: 'missing_approval_id' }, { status: 400 });
+
+  try {
+    const session = await requireSession(req);
+    requireAdmin(session);
+
+    const approval = getApprovalRequest(approvalId);
+    if (!approval) return Response.json({ ok: false, error: 'not_found' }, { status: 404 });
+
+    const resume = approval.payload?.resume || null;
+    const toolName = approval.payload?.tool_name
+      || (typeof approval.action_type === 'string' ? approval.action_type.split(':').pop() : null);
+
+    if (!resume || !resume.agent_id) {
+      // No captured delegation context — approve so a later main-agent re-delegation
+      // can consume it, but we cannot auto-resume here.
+      decideApprovalRequest(approvalId, 'approved', { approved_by: session.user_id || 'owner' });
+      return Response.json({
+        ok: true,
+        resumed: false,
+        reason: 'Approved, but no delegation context to auto-resume. Re-send your request and it will continue.',
+      });
+    }
+
+    // Approve first so the re-dispatched tool call consumes it.
+    decideApprovalRequest(approvalId, 'approved', { approved_by: session.user_id || 'owner' });
+
+    const run = await runAgentTick(resume.agent_id, {
+      triggered_by: 'approval_resume',
+      wake_reason: 'owner approved tool inline in chat',
+      instruction: resume.instruction || null,
+      expected_output: resume.expected_output || null,
+      pending_approvals: toolName ? [{ approval_id: approvalId, tool_name: toolName }] : [],
+      acting_on_behalf_of_user_id: session.user_id || null,
+    });
+
+    if (!run) {
+      return Response.json({ ok: false, error: 'resume_dispatch_failed', agent_id: resume.agent_id }, { status: 500 });
+    }
+
+    // If the sub-agent paused AGAIN (e.g. a second gated tool), surface that.
+    if (run.pending_approval?.approval_id) {
+      return Response.json({
+        ok: true,
+        resumed: true,
+        status: 'awaiting_approval',
+        agent_name: resume.agent_name || run.agent || null,
+        pending_approval: run.pending_approval,
+      });
+    }
+
+    return Response.json({
+      ok: true,
+      resumed: true,
+      status: run.status || 'complete',
+      agent_name: resume.agent_name || run.agent || null,
+      run_id: run.id || null,
+      artifact_id: run.artifact_id || null,
+      title: run.artifact_title || run.title || null,
+      preview: (run.preview || '').slice(0, 600),
+    });
+  } catch (err) {
+    if (err && typeof err === 'object' && err.status) {
+      return Response.json({ ok: false, error: err.error || 'unauthorized' }, { status: err.status });
+    }
+    return Response.json({ ok: false, error: String(err?.message || err) }, { status: 500 });
+  }
+}

package/app/api/connections/[service]/verify/route.js

@@ -21,6 +21,7 @@ import { summarizeConnection, fingerprintLast4 } from '../../../../../lib/connec
 import { setSecret } from '../../../../../lib/secrets.js';
 import { wrapFetch } from '../../../../../lib/egress.js';
 import { getDb, nowIso, newId } from '../../../../../lib/db.js';
+import { setToolEnabled, listMarketplaceTools } from '../../../../../lib/tools/registry.js';
 import { getBridgeHealth } from '../../../../../lib/whatsapp.js';
 import { getHermesStatus, resolveHermesDir } from '../../../../../lib/hermes.js';
 import fs from 'node:fs';
@@ -43,6 +44,39 @@ function friendly(reason) {
   return FRIENDLY_ERRORS[reason] || "We couldn't reach the service. Check the value and try again.";
 }
 
+/**
+ * Enable the registry tools a connection declares in `unlocks_tool_slugs`, so a
+ * freshly verified service is callable from chat without a manual /tools toggle.
+ * Only slugs that resolve to real registry tools are enabled; connector/skill
+ * slugs (which are not in MARKETPLACE_TOOLS) are skipped. Best-effort.
+ *
+ * @returns {string[]} the slugs that were enabled.
+ */
+function enableUnlockedTools(connection) {
+  const slugs =
+    connection?.connection?.unlocks_tool_slugs ||
+    connection?.manifest?.unlocks_tool_slugs ||
+    [];
+  if (!Array.isArray(slugs) || slugs.length === 0) return [];
+  let registryNames;
+  try {
+    registryNames = new Set(listMarketplaceTools().map((t) => t.name));
+  } catch {
+    return [];
+  }
+  const enabled = [];
+  for (const slug of slugs) {
+    if (typeof slug !== 'string' || !registryNames.has(slug)) continue;
+    try {
+      setToolEnabled(slug, true);
+      enabled.push(slug);
+    } catch {
+      // best-effort — one bad slug never blocks verification
+    }
+  }
+  return enabled;
+}
+
 function writeAudit(type, meta, status = 'ok', summary = '') {
   try {
     getDb().prepare(`
@@ -296,6 +330,40 @@ async function verifySupabase(creds) {
   }
 }
 
+async function verifyHiggsfield(creds) {
+  const keyId = creds.HIGGSFIELD_KEY_ID;
+  const keySecret = creds.HIGGSFIELD_KEY_SECRET;
+  if (!keyId) return { ok: false, reason: 'missing_field', field: 'HIGGSFIELD_KEY_ID' };
+  if (!keySecret) return { ok: false, reason: 'missing_field', field: 'HIGGSFIELD_KEY_SECRET' };
+  // Live probe against the platform with the Key id:secret header. We treat an
+  // explicit auth rejection (401/403) as a hard failure, but accept other
+  // statuses (the public REST surface is thin and a probe path may 404) so a
+  // valid key is never blocked by an endpoint guess.
+  try {
+    const fetchFn = wrapFetch('connection.verify.higgsfield', null, fetch);
+    const res = await fetchFn('https://platform.higgsfield.ai/v1/job-sets?limit=1', {
+      method: 'GET',
+      headers: { authorization: `Key ${keyId}:${keySecret}`, accept: 'application/json' },
+    });
+    if (res.status === 401 || res.status === 403) return { ok: false, reason: 'unauthorized' };
+    return {
+      ok: true,
+      account_label: 'Higgsfield AI',
+      last_4: fingerprintLast4(keySecret),
+      summary: { key_id_last_4: fingerprintLast4(keyId), live_probe_status: res.status },
+    };
+  } catch {
+    // Network/endpoint uncertainty: save the credentials rather than reject a
+    // possibly-valid key. Generation calls will surface a clear auth error if wrong.
+    return {
+      ok: true,
+      account_label: 'Higgsfield AI',
+      last_4: fingerprintLast4(keySecret),
+      summary: { key_id_last_4: fingerprintLast4(keyId), saved_without_live_verify: true },
+    };
+  }
+}
+
 async function verifyWhatsapp() {
   try {
     const health = await getBridgeHealth();
@@ -378,6 +446,7 @@ const VERIFIERS = {
   kimi: { fn: verifyKimi, persist: ['KIMI_API_KEY'] },
   github: { fn: verifyGithub, persist: ['GITHUB_TOKEN'] },
   resend: { fn: verifyResend, persist: ['RESEND_API_KEY', 'RESEND_FROM_EMAIL'] },
+  higgsfield: { fn: verifyHiggsfield, persist: ['HIGGSFIELD_KEY_ID', 'HIGGSFIELD_KEY_SECRET'] },
   supabase: {
     fn: verifySupabase,
     persist: ['SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY', 'SUPABASE_ANON_KEY', 'SUPABASE_ACCESS_TOKEN'],
@@ -558,6 +627,19 @@ export async function POST(request, context) {
     }
   }
 
+  // Step 3c: auto-enable the registry tools this connection unlocks, so a freshly
+  // connected service is usable from chat without a separate /tools toggle.
+  // Enabling only makes a tool callable — risky tiers (high / irreversible_external)
+  // still hit the approval gate at execution time, so this never bypasses consent.
+  // Best-effort and idempotent; non-registry unlocks (e.g. connector slugs) are skipped.
+  const enabledTools = enableUnlockedTools(connection);
+  if (enabledTools.length) {
+    writeAudit('connection.tools.auto_enabled', {
+      service_key: service,
+      tools: enabledTools,
+    }, 'ok', `Auto-enabled ${enabledTools.length} tool(s) for ${service}`);
+  }
+
   writeAudit('connection.verify.succeeded', {
     service_key: service,
     scope: scopeTuple.scope,
@@ -565,6 +647,7 @@ export async function POST(request, context) {
     agent_id: scopeTuple.agent_id,
     account_label: result.account_label || null,
     last_4: result.last_4 || null,
+    auto_enabled_tools: enabledTools,
   }, 'ok', `Verify succeeded: ${service} (${scopeTuple.scope})`);
 
   const next = getConnection(service);

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

@@ -18,6 +18,7 @@ import {
 import { publishLiveEvent } from '@/lib/live-events.js';
 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 { looksFabricatedToolTranscript } from '@/lib/fabricated-tool-output.js';
 import { loadAttachments, attachmentsToContentBlocks, attachmentsToPromptText } from '@/lib/chat-uploads.js';
@@ -44,15 +45,26 @@ function buildCliSystemPrompt() {
   const brand = brandInstructionText();
   return `${currentDateInstruction()}
 
-You are the madarX Main Agent — local-first AI orchestrator. You report to the owner as a chief of staff reports to a chairman: bring back the actual answer, not a list of places they could go to find it.
+You are the madarX Main Agent — local-first AI orchestrator. You report to the owner as a chief of staff reports to a chairman: bring back the actual answer, not a list of places they could go to find it. You DELEGATE specialist work to the agents that own the tools; you do not perform it yourself.
 
 madarX is a VISUAL workspace, not a chatbot. The chat bubble exists only for short conversational exchanges. Anything that would make the reader scroll, scan, or compare belongs in a designed HTML artifact rendered on the canvas — never as a long markdown blob in chat.
 
-What you CAN do:
-- Search the web and fetch live data — use madarx-action blocks with web_search or web_fetch. Results come back automatically so you can synthesize a direct answer.
-- Generate HTML pages, landing pages, dashboards, news feeds, reports, decks, and UI — output a complete self-contained HTML file in a \`\`\`html code fence. This is the PRIMARY output channel for any structured response.
-- Write short conversational replies (≤ 2 sentences, no lists) — reply in plain text.
-- Create agents for recurring/scheduled work only — output a madarx-action block.
+DELEGATION-FIRST (non-negotiable): for any request beyond a one-line factual reply, set the goal in one sentence and route it FIRST:
+\`\`\`madarx-action
+{"tool":"route_goal","input":{"goal":"<one-sentence goal>"}}
+\`\`\`
+route_goal returns the live roster (every agent's role/skills/granted tools), the tool catalog, and whether Tool Smith can build what's missing. Reason over it and pick ONE ladder step:
+  - delegate → an existing specialist fits: run it with run_agent (pass an instruction + expected_output).
+  - create_then_delegate → none fits: create_agent for the role the goal needs, then run_agent it.
+  - build_capability → a specialist lacks a tool: request_capability (Tool Smith builds + grants), tell the owner it's building, then delegate.
+  - direct_fallback → trivial one-line factual ask only: answer in chat.
+Specialist domain tools (flights, hotels, email, GitHub writes, calendar, database, deploys) are NOT in your toolset — they belong to specialists. Do not attempt them directly; they will be refused with "delegate_required". This routing works for ANY goal, not a fixed domain list.
+
+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.
 
 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.
@@ -71,64 +83,31 @@ DECISION RULE (non-negotiable):
 - Anything else (any list of 3+ items, any comparison, any news/report/document/page/dashboard, any response > 2 sentences) → emit a \`\`\`html ... \`\`\` artifact FIRST, then a 1-2 sentence chat summary describing what you built.
 - Never paste a markdown response with bullet links into the chat. If you find yourself writing "## Sources" or a bulleted list outside an HTML artifact, stop and move it into the artifact.
 
-LIVE DATA WORKFLOW (non-negotiable for flights, hotels, prices, addresses, schedules, any factual lookup):
-  1) web_search to identify the 2-4 most authoritative sources (operator/booking sites, official pages, named publications).
-  2) web_fetch each chosen source to extract concrete values — prices, dates, times, addresses, ratings, names, distances.
-  3) Present the result as a comparison TABLE or structured list with real values in cells. Cite sources at the bottom as a short "Sources" list.
-
-NEVER deliver a response that is just "Results for X" sections of search titles and snippets. That is not an answer. If a value cannot be extracted after fetching, put "Not listed" in the cell and continue — do not pad with snippets.
+SPECIALIST DATA (flights, hotels, prices behind booking sites, email, calendar, repos, deploys): DELEGATE — do not run those tools yourself. route_goal, then run_agent the owning specialist. The specialist brings back concrete values; you verify they meet the goal and present them as a designed artifact.
 
+QUICK FACTUAL LOOKUP (a single date, number, or definition that does not warrant a specialist): you may search directly.
 Web search:
 \`\`\`madarx-action
 {"tool":"web_search","input":{"query":"<search query>","count":5}}
 \`\`\`
-
 Fetch a specific URL:
 \`\`\`madarx-action
 {"tool":"web_fetch","input":{"url":"<url>"}}
 \`\`\`
+NEVER deliver a response that is just "Results for X" sections of search titles and snippets — that is not an answer.
 
-You can emit multiple action blocks in one response. Combine them: search broadly first, then fetch the strongest URLs that came back.
-
-Example — user asks "find flights DXB to London May 18-25 and hotels in Kensington":
-Turn 1 — discovery searches:
-\`\`\`madarx-action
-{"tool":"web_search","input":{"query":"Emirates DXB to LHR May 18 2026 return May 25 economy fare","count":5}}
-\`\`\`
-\`\`\`madarx-action
-{"tool":"web_search","input":{"query":"4 star hotels South Kensington London 7 nights May 18 2026 price","count":5}}
-\`\`\`
-Turn 2 — after seeing results, fetch the actual booking/operator pages:
+Example — user asks "find flights DXB to London May 18-25":
+Turn 1 — route the goal:
 \`\`\`madarx-action
-{"tool":"web_fetch","input":{"url":"https://www.emirates.com/.../dxb-to-lhr"}}
+{"tool":"route_goal","input":{"goal":"find a return flight DXB to London, 18-25 May, economy"}}
 \`\`\`
+Turn 2 — the roster shows a Travel Concierge that owns flight_search → delegate to it:
 \`\`\`madarx-action
-{"tool":"web_fetch","input":{"url":"https://www.tripadvisor.com/Hotels-South-Kensington-London"}}
+{"tool":"run_agent","input":{"agent_name":"Travel Concierge","instruction":"Return flight DXB→London 18 May, back 25 May, economy — compare 3 options with real fares/times.","expected_output":"A comparison table of 3+ flights with airline, route, times, cabin, price, and source links.","wake_reason":"owner requested flights via chat"}}
 \`\`\`
-Turn 3 — produce the final answer as a structured artifact:
-
-# Trip plan: Dubai → London, 18–25 May 2026
-
-## Flight options
-| Airline | Route | Outbound | Return | Cabin | Price (AED) | Notes |
-|---|---|---|---|---|---|---|
-| Emirates | DXB → LHR | 18 May 02:40 | 25 May 14:25 | Economy Flex | 4,250 | Direct, 7h 50m |
-| British Airways | DXB → LHR | 18 May 09:15 | 25 May 21:30 | Economy | 3,890 | Direct, 7h 55m |
-| Etihad | AUH → LHR | 18 May 02:25 | 25 May 14:10 | Economy | 3,520 | 1h transfer at AUH |
-
-## Hotel shortlist (South Kensington, 7 nights)
-| Hotel | Stars | Nightly (£) | 7-night total (£) | Walk to Tube | Source |
-|---|---|---|---|---|---|
-| The Milestone | 5 | 612 | 4,284 | 3 min (High St Ken) | Booking.com |
-| Number Sixteen | 5 | 478 | 3,346 | 4 min (South Ken) | Hotel site |
-| The Cranley | 4 | 295 | 2,065 | 2 min (Gloucester Rd) | Tripadvisor |
-
-## Sources
-1. Emirates fare search (link)
-2. British Airways fare search (link)
-3. Tripadvisor South Kensington (link)
-
-AGENT CREATION — only for recurring or scheduled tasks (daily monitoring, weekly reports):
+Turn 3 — the specialist produced the itinerary artifact; confirm in one line. If no Travel Concierge existed, create_agent one first (create_then_delegate); if it lacked flight_search, request_capability (build_capability) and tell the owner it's being built.
+
+AGENT CREATION — for recurring/scheduled work, OR to create a specialist that route_goal showed is missing (create_then_delegate):
 \`\`\`madarx-action
 {"tool":"create_agent","input":{"name":"Agent Name","mission":"...","engine":"anthropic","schedule":"daily 08:00","tools":["web-search","browser"]}}
 \`\`\`
@@ -425,6 +404,10 @@ export async function POST(req) {
         .map(p => ({ approval_id: String(p.approval_id), tool_name: String(p.tool_name), used: false }))
     : [];
 
+  // Forward owner-granted approvals into delegated sub-agents (run_agent → runAgentTick)
+  // so an inline-approved sub-agent tool resumes instead of re-prompting.
+  toolContext.pending_approvals = pendingApprovals.map(p => ({ approval_id: p.approval_id, tool_name: p.tool_name }));
+
   // Mirror of REFUNDABLE_ERRORS in lib/tools/registry.js — when the adapter
   // errors with one of these codes, the registry refunds the approval, so we
   // must not mark the pending entry as used either.
@@ -898,6 +881,22 @@ Rules (non-negotiable):
               .map(a => a.result);
             const ranAgentLines = [];
             for (const r of ranAgents) {
+              // Sub-agent paused on an owner-approval gate: surface an inline
+              // Approve/Deny card in chat instead of sending the owner to the
+              // approvals page. Approving re-dispatches the same delegation.
+              if (r.pending_approval?.approval_id) {
+                emit('agent_approval', {
+                  approval_id: r.pending_approval.approval_id,
+                  tool_name: r.pending_approval.tool_name,
+                  agent_id: r.pending_approval.agent_id || r.agent_id,
+                  agent_name: r.pending_approval.agent_name || r.agent_name,
+                  summary: r.pending_approval.summary || `${r.agent_name} needs approval to run ${r.pending_approval.tool_name}.`,
+                });
+                ranAgentLines.push(
+                  `**${r.agent_name}** is ready but needs your approval to spend credits / act. Approve below to continue.`
+                );
+                continue;
+              }
               const artId = r.artifact_id || r.artifact?.artifact_id || r.artifact?.id || null;
               if (artId) {
                 emit('artifacts', { created: [{ title: r.title || r.agent_name, artifact_id: artId }] });
@@ -1167,6 +1166,28 @@ Rules (non-negotiable):
                  tool.name === 'send_to_hermes' || tool.name === 'start_hermes_job')) {
               artifactCreated = true;
             }
+            if (!isError &&
+                (tool.name === 'higgsfield_generate_image' ||
+                 tool.name === 'higgsfield_generate_video' ||
+                 tool.name === 'higgsfield_product_photoshoot') &&
+                output?.ok && output?.url) {
+              try {
+                const mediaKind = tool.name === 'higgsfield_generate_video' ? 'video' : 'image';
+                const html = buildHiggsfieldMediaHtml(output, {
+                  kind: mediaKind,
+                  prompt: tool.input?.prompt || '',
+                });
+                const card = createArtifact({
+                  title: `Higgsfield ${mediaKind === 'video' ? 'Video' : 'Image'}`,
+                  kind: 'html',
+                  content: html,
+                  project_id: projectId,
+                });
+                emit('artifacts', { created: [{ title: `Higgsfield ${mediaKind}`, artifact_id: card.artifact_id }] });
+                emit('session_artifact', { artifact_id: card.artifact_id });
+                artifactCreated = true;
+              } catch { /* non-fatal — fall through to normal tool_result emission */ }
+            }
             if (!isError && tool.name === 'create_agent' && output?.agent) {
               try {
                 const html = buildAgentCreatedHtml(output.agent, output.files ?? []);

package/app/components/dashboard/apply-stream-event.js

@@ -119,6 +119,21 @@ export function applyStreamEvent(eventName, payload, ctx) {
     refresh();
   } else if (eventName === 'usage') {
     setUsage(payload);
+  } else if (eventName === 'agent_approval' && payload?.approval_id) {
+    // A delegated sub-agent paused on an owner-approval gate. Surface an inline
+    // Approve/Deny card in the chat thread (see chat-panel) so the owner stays in
+    // the conversation instead of opening the approvals page.
+    ctx.setAgentApprovals?.(list => {
+      if (list.some(x => x.approval_id === payload.approval_id)) return list;
+      return [...list, {
+        approval_id: payload.approval_id,
+        tool_name: payload.tool_name || null,
+        agent_id: payload.agent_id || null,
+        agent_name: payload.agent_name || 'Agent',
+        summary: payload.summary || '',
+        status: 'pending',
+      }];
+    });
   } else if (eventName === 'pending_approvals' && Array.isArray(payload?.approvals)) {
     for (const a of payload.approvals) {
       if (a?.approval_id && a?.tool_name) {

package/app/components/dashboard/chat-panel.jsx

@@ -94,6 +94,8 @@ function ChatPanel() {
   const command = mainAgent.command;
   const stop = mainAgent.stop;
   const decideApproval = mainAgent.decideApproval;
+  const agentApprovals = mainAgent.agentApprovals || [];
+  const resumeAgentApproval = mainAgent.resumeAgentApproval;
   const hideChat = useCallback(() => setChatHidden(true), [setChatHidden]);
   const onOpenVoice = useCallback(() => setVoiceOpen(true), [setVoiceOpen]);
   const composerRef = useRef(null);
@@ -503,6 +505,60 @@ function ChatPanel() {
         )}
       </div>
     )}
+    {agentApprovals.length > 0 && (
+      <div className="agent-approvals">
+        {agentApprovals.map(card => {
+          const pending = card.status === 'pending';
+          const resuming = card.status === 'resuming';
+          const done = card.status === 'done' || card.status === 'approved';
+          const denied = card.status === 'denied';
+          const errored = card.status === 'error';
+          return (
+            <div
+              key={card.approval_id}
+              className="agent-approval-card"
+              style={{
+                margin: '8px 0', padding: '12px 14px', borderRadius: 12,
+                border: '1px solid rgba(17,19,24,.12)', background: '#fff',
+                display: 'flex', flexDirection: 'column', gap: 8,
+              }}
+            >
+              <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+                <span style={{ display: 'inline-block', width: 8, height: 8, borderRadius: 4, background: pending ? '#c2452a' : done ? '#2f9e44' : '#9a968d' }} />
+                <strong style={{ font: '600 13px/1.3 ui-sans-serif,system-ui' }}>
+                  {card.agent_name} needs your approval
+                </strong>
+              </div>
+              <div style={{ font: '400 12.5px/1.45 ui-sans-serif,system-ui', color: '#5b606b' }}>
+                {card.summary || `Approve to run ${card.tool_name}.`}
+              </div>
+              {pending && (
+                <div style={{ display: 'inline-flex', gap: 6 }}>
+                  <button
+                    type="button"
+                    onClick={() => resumeAgentApproval(card.approval_id, 'approved')}
+                    style={{ appearance: 'none', border: 0, background: '#c2452a', color: '#fff', padding: '6px 14px', borderRadius: 999, font: '600 12px/1 ui-sans-serif,system-ui', cursor: 'pointer' }}
+                  >
+                    Approve &amp; continue
+                  </button>
+                  <button
+                    type="button"
+                    onClick={() => resumeAgentApproval(card.approval_id, 'denied')}
+                    style={{ appearance: 'none', border: '1px solid rgba(17,19,24,.16)', background: '#fff', color: '#313740', padding: '6px 14px', borderRadius: 999, font: '600 12px/1 ui-sans-serif,system-ui', cursor: 'pointer' }}
+                  >
+                    Deny
+                  </button>
+                </div>
+              )}
+              {resuming && <div style={{ font: '500 12px/1 ui-sans-serif,system-ui', color: '#c2452a' }}>Running…</div>}
+              {done && <div style={{ font: '500 12px/1 ui-sans-serif,system-ui', color: '#2f9e44' }}>Approved — done.</div>}
+              {denied && <div style={{ font: '500 12px/1 ui-sans-serif,system-ui', color: '#9a968d' }}>Denied.</div>}
+              {errored && <div style={{ font: '500 12px/1 ui-sans-serif,system-ui', color: '#c2452a' }}>Couldn’t continue: {String(card.error || 'error')}</div>}
+            </div>
+          );
+        })}
+      </div>
+    )}
     {busy && liveSteps.length === 0 && !liveStatus && !(liveThinking && liveThinking.trim()) && <div className="typing-indicator"><span /><span /><span /></div>}
     {!busy && agentWorkingRemote && (
       <div className="agent-resume-banner" aria-live="polite">

package/app/components/dashboard/use-stream-command.js

@@ -40,6 +40,10 @@ export function useStreamCommand({
   // Drained into pending_approvals on the next outgoing request so the server
   // can inject approval_id into the retried tool call.
   const pendingApprovalsRef = useRef([]);
+  // Inline approval cards for delegated sub-agents (run_agent paused on an owner
+  // gate). Rendered in the chat thread with Approve/Deny so the owner never
+  // leaves the conversation. Approving re-dispatches the sub-agent.
+  const [agentApprovals, setAgentApprovals] = useState([]);
   const abortRef = useRef(null);
   const stoppedRef = useRef(false);
   const feedRef = useRef(null);
@@ -130,7 +134,7 @@ export function useStreamCommand({
         setChat, setLiveText, setAgentPhase, setLiveTool, setLiveSteps,
         setUsage, setSessionId, setSessionArtifactId,
         setLiveThinking, setLiveStatus,
-        pendingApprovalsRef,
+        pendingApprovalsRef, setAgentApprovals,
         bringToFront, refresh,
         onSession: (id) => { saveLastSessionId(id); sessionIdRef.current = id; },
       };
@@ -262,7 +266,7 @@ export function useStreamCommand({
 
     const EVENTS = ['session', 'text', 'cli_stream', 'cli_thinking', 'cli_status',
       'tool_start', 'tool_result', 'artifacts', 'agent_created', 'session_artifact',
-      'artifact_updated', 'usage', 'pending_approvals', 'error', 'done'];
+      'artifact_updated', 'usage', 'pending_approvals', 'agent_approval', 'error', 'done'];
     for (const name of EVENTS) {
       es.addEventListener(name, (ev) => {
         let payload;
@@ -307,6 +311,57 @@ export function useStreamCommand({
     }
   }
 
+  // Decide an inline sub-agent approval card. Approve → re-dispatch the sub-agent
+  // (server consumes the approval + generates), pinning the result to the canvas,
+  // all without leaving the chat. Deny → mark the request denied.
+  async function resumeAgentApprovalImpl(approvalId, decision) {
+    if (!approvalId) return;
+    if (decision === 'denied') {
+      setAgentApprovals(a => a.map(x => x.approval_id === approvalId ? { ...x, status: 'denied' } : x));
+      try {
+        await fetch(`/api/approvals/${approvalId}`, {
+          method: 'PATCH', headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ decision: 'denied' }),
+        });
+      } catch { /* best-effort */ }
+      return;
+    }
+    setAgentApprovals(a => a.map(x => x.approval_id === approvalId ? { ...x, status: 'resuming' } : x));
+    try {
+      const res = await fetch('/api/agents/resume-approval', {
+        method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ approval_id: approvalId }),
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok || !data.ok) {
+        setAgentApprovals(a => a.map(x => x.approval_id === approvalId ? { ...x, status: 'error', error: data.error || res.status } : x));
+        setChat(c => [...c, { role: 'agent', text: `Could not continue: ${data.error || res.status}` }]);
+        return;
+      }
+      // A second gate surfaced — mark this one approved and add the next card.
+      if (data.status === 'awaiting_approval' && data.pending_approval?.approval_id) {
+        setAgentApprovals(a => [
+          ...a.map(x => x.approval_id === approvalId ? { ...x, status: 'approved' } : x),
+          {
+            approval_id: data.pending_approval.approval_id,
+            tool_name: data.pending_approval.tool_name,
+            agent_id: data.pending_approval.agent_id || null,
+            agent_name: data.pending_approval.agent_name || data.agent_name || 'Agent',
+            summary: data.pending_approval.summary || '',
+            status: 'pending',
+          },
+        ]);
+        return;
+      }
+      setAgentApprovals(a => a.map(x => x.approval_id === approvalId ? { ...x, status: 'done', artifact_id: data.artifact_id || null } : x));
+      if (data.artifact_id) { setSessionArtifactId(data.artifact_id); bringToFront(data.artifact_id); }
+      await refresh();
+      setChat(c => [...c, { role: 'agent', text: `${data.agent_name || 'Agent'} finished${data.title ? ` — "${data.title}"` : ''}.` }]);
+    } catch (err) {
+      setAgentApprovals(a => a.map(x => x.approval_id === approvalId ? { ...x, status: 'error', error: err.message } : x));
+    }
+  }
+
   function stopImpl() {
     if (!busy) return;
     stoppedRef.current = true;
@@ -317,6 +372,8 @@ export function useStreamCommand({
   stopRef.current = stopImpl;
   const decideApprovalRef = useRef(null);
   decideApprovalRef.current = decideApprovalImpl;
+  const resumeAgentApprovalRef = useRef(null);
+  resumeAgentApprovalRef.current = resumeAgentApprovalImpl;
   const attachRef = useRef(null);
   attachRef.current = attachImpl;
   const command = useCallback((text, attachments) => commandRef.current(text, attachments), []);
@@ -325,6 +382,10 @@ export function useStreamCommand({
     (id, decision, toolName) => decideApprovalRef.current(id, decision, toolName),
     [],
   );
+  const resumeAgentApproval = useCallback(
+    (id, decision) => resumeAgentApprovalRef.current(id, decision),
+    [],
+  );
   const attach = useCallback((id) => attachRef.current(id), []);
 
   // Close any live re-attach when this hook unmounts (page navigation).
@@ -349,5 +410,7 @@ export function useStreamCommand({
     command,
     stop,
     decideApproval,
+    agentApprovals,
+    resumeAgentApproval,
   };
 }