madarx 2.12.1 → 2.14.0

package/lib/cli/run.js

@@ -17,7 +17,8 @@ import fs from 'node:fs';
 import { spawn } from 'node:child_process';
 import { applyHomeEnv } from './home.js';
 import { PKG_ROOT } from './dispatch.js';
-import { renderBanner } from './banner.js';
+import { renderBanner, renderHeroBanner } from './banner.js';
+import { readyPanel } from './splash.js';
 import { readUpdateCheck } from '../update-check.js';
 import { loadProjectEnv } from '../load-env.js';
 
@@ -157,25 +158,39 @@ export async function run({ flags = {} } = {}) {
     // Catalog counts: best-effort dynamic import so a count never blocks or
     // breaks boot. These modules build static catalogs at eval time and do NOT
     // open the database, so the supervisor stays DB-free.
-    let tools, skills;
+    let toolCats = [];
+    let toolCount;
+    let skillGroups = [];
+    let skillCount;
     try {
-      const [{ MARKETPLACE_TOOL_COUNT }, seeds] = await Promise.all([
+      const [{ MARKETPLACE_TOOL_COUNT, listToolCategories }, seeds] = await Promise.all([
         import('../tools/registry.js'),
         import('../marketplace-seeds.js'),
       ]);
-      tools = MARKETPLACE_TOOL_COUNT;
-      skills = (seeds.PHASE1_SKILL_SLUGS?.length || 0) + (seeds.OPEN_DESIGN_SKILL_SLUGS?.length || 0);
-    } catch { /* counts are optional */ }
+      toolCount = MARKETPLACE_TOOL_COUNT;
+      toolCats = listToolCategories();
+      // Showcase the business-default skill pack (research, comms, documents,
+      // data, web) grouped by category — what most teams need out of the box.
+      skillGroups = seeds.listDefaultSkillGroups ? seeds.listDefaultSkillGroups() : [];
+      skillCount = (seeds.DEFAULT_SKILL_SLUGS || []).length;
+    } catch { /* catalog is optional — banner still renders without it */ }
     const version = pkgVersion() || '0.0.0';
-    console.log(renderBanner({
+    const hero = process.env.MADARX_BANNER_LEGACY !== '1';
+    const render = hero ? renderHeroBanner : renderBanner;
+    console.log(render({
       version,
       home: layout.home,
       url: BASE_URL,
-      engine: process.env.MADARX_DEFAULT_ENGINE || 'claude-code (default)',
+      engine: process.env.MADARX_DEFAULT_ENGINE || 'claude-code',
+      commit: process.env.MADARX_COMMIT || undefined,
       latest: ledger?.latest || null,
       behind: Boolean(ledger?.latest && ledger.latest !== version && ledger?.behind),
-      tools,
-      skills,
+      toolCats,
+      toolCount,
+      skillGroups,
+      skillCount,
+      // legacy renderBanner still understands these:
+      tools: toolCount,
     }));
   } else {
     log(`data home: ${layout.home}`);
@@ -213,7 +228,14 @@ export async function run({ flags = {} } = {}) {
     // Health gate + browser open run alongside; never block shutdown on them.
     waitForHealth().then((ok) => {
       if (stopping) return;
-      if (ok) { log(`ready → ${BASE_URL}`); openBrowser(BASE_URL, flags); }
+      if (ok) {
+        if (!flags.quiet && process.env.MADARX_NO_BANNER !== '1') {
+          console.log('\n' + readyPanel({ version: pkgVersion() || undefined, url: BASE_URL }) + '\n');
+        } else {
+          log(`ready → ${BASE_URL}`);
+        }
+        openBrowser(BASE_URL, flags);
+      }
       else warn(`web tier did not answer on ${BASE_URL} within the timeout — it may still be starting.`);
     });
   });

package/lib/cli/splash.js

@@ -0,0 +1,120 @@
+/**
+ * Branded boot/install splash for the madarX OS CLI.
+ *
+ * Zero dependencies — node builtins + the ANSI primitives in ./banner.js only —
+ * so it is safe to import from the CLI supervisor (lib/cli/run.js) and from the
+ * postinstall script (scripts/postinstall-splash.mjs) without pulling in the
+ * runtime or opening the database.
+ *
+ * Look is the brand-guidelines v1.3 "Sovereign-Mono" splash (see preview.svg):
+ * the whole step list prints upfront — pending in Graphite, the active step
+ * carries the single live Mars spinner, settled steps resolve to a neutral
+ * Platinum ✓ (never green, so Mars never repeats on a settled surface). Closes
+ * on a Muted dateline. Degrades to a plain auditable record off-TTY.
+ */
+
+import { _palette as P, fg, bold, dim, wordmark, colorEnabled, visibleLength } from './banner.js';
+
+const ON = colorEnabled();
+const isTTY = ON && Boolean(process.stdout && process.stdout.isTTY);
+
+// Monospace-safe braille spinner — reads as motion without noise.
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+const GLYPH = {
+  done: fg(P.platinum, '✓'),
+  fail: fg(P.mars, '✗'),
+  pending: fg(P.graphite, '·'),
+  bead: fg(P.mars, '●'),
+};
+
+// ── cursor hygiene: hide during animation, always restore ─────────────────────
+let cursorHidden = false;
+function hideCursor() { if (isTTY && !cursorHidden) { process.stdout.write('\x1b[?25l'); cursorHidden = true; } }
+function showCursor() { if (cursorHidden) { process.stdout.write('\x1b[?25h'); cursorHidden = false; } }
+process.on('exit', showCursor);
+process.on('SIGINT', () => { showCursor(); process.exit(130); });
+
+// A step line at a given state. `state`: 'pending' | 'active' | 'done' | 'fail'.
+function lineFor(label, state, frame) {
+  if (state === 'pending') return `  ${GLYPH.pending} ${fg(P.graphite, label)}`;
+  if (state === 'active') return `  ${fg(P.mars, frame)} ${fg(P.bone, label)}`;
+  if (state === 'fail') return `  ${GLYPH.fail} ${fg(P.bone, label)}`;
+  return `  ${GLYPH.done} ${fg(P.bone, label)}`;
+}
+
+/**
+ * Run a list of boot steps, rendered the way preview.svg shows them: the whole
+ * list appears at once (pending/Graphite), then each step lights its Mars
+ * spinner while its real work runs and resolves to a Platinum ✓.
+ *
+ * @param {Array<{label: string, work: () => Promise<any>}>} steps
+ */
+export async function bootSequence(steps) {
+  if (!isTTY) {
+    // CI / piped / NO_COLOR: no animation, just the record an auditor would want.
+    for (const s of steps) {
+      try { await s.work(); process.stdout.write(lineFor(s.label, 'done') + '\n'); }
+      catch { process.stdout.write(lineFor(s.label, 'fail') + '\n'); }
+    }
+    return;
+  }
+
+  const n = steps.length;
+  hideCursor();
+  try {
+    // Paint the full list pending, then park the cursor below it.
+    for (const s of steps) process.stdout.write(lineFor(s.label, 'pending') + '\n');
+
+    // Redraw line `i` (0 = top) in place: jump up, clear, write, jump back down.
+    const redraw = (i, text) => {
+      const up = n - i;
+      process.stdout.write(`\x1b[${up}A\r\x1b[2K${text}\r\x1b[${up}B`);
+    };
+
+    for (let i = 0; i < n; i++) {
+      const s = steps[i];
+      let spinning = true, f = 0;
+      const anim = (async () => {
+        while (spinning) { redraw(i, lineFor(s.label, 'active', SPINNER[f++ % SPINNER.length])); await sleep(80); }
+      })();
+      try { await s.work(); spinning = false; await anim; redraw(i, lineFor(s.label, 'done')); }
+      catch { spinning = false; await anim; redraw(i, lineFor(s.label, 'fail')); }
+    }
+  } finally {
+    showCursor();
+  }
+}
+
+/** The dateline rule: a Muted mono `date · place · version` stamp. */
+export function dateline(version, place = 'Designed in UAE') {
+  const stamp = new Date().toISOString().slice(0, 10).replace(/-/g, '.');
+  const v = version ? `  ·  v${version}` : '';
+  return fg(P.muted, `${stamp}  ·  ${place}${v}`);
+}
+
+// ── optional framed panel (used by `madarx run` ready-state, not the splash) ──
+
+/** A framed panel. Graphite border; a single Mars bead leads the headline. */
+export function readyBox(lines) {
+  const pad = 2;
+  const inner = Math.max(...lines.map(visibleLength)) + pad * 2;
+  const top = fg(P.graphite, '╭' + '─'.repeat(inner) + '╮');
+  const bot = fg(P.graphite, '╰' + '─'.repeat(inner) + '╯');
+  const bar = fg(P.graphite, '│');
+  const body = lines.map((l) => {
+    const gap = inner - visibleLength(l) - pad * 2;
+    return `${bar}${' '.repeat(pad)}${l}${' '.repeat(pad + gap)}${bar}`;
+  });
+  return ['  ' + top, ...body.map((b) => '  ' + b), '  ' + bot].join('\n');
+}
+
+/** Standard "ready" panel for a booted instance (the `madarx run` close). */
+export function readyPanel({ version, url } = {}) {
+  const head = `${GLYPH.bead} ${bold(fg(P.platinum, 'madarX is ready'))}`;
+  const hint = `${fg(P.muted, 'run')} ${fg(P.mars, 'madarx')} ${fg(P.muted, '→ dashboard on')} ${fg(P.bone, url || 'http://127.0.0.1:8787')}`;
+  return [readyBox([head, hint]), '  ' + dateline(version)].join('\n');
+}
+
+export { GLYPH, isTTY as splashIsTTY };

package/lib/marketplace-seeds.js

@@ -161,6 +161,99 @@ const SKILL_SEEDS = [
   },
 ];
 
+// Business-default skill pack — the capabilities most teams reach for first, so
+// a fresh agent can do real work out of the box (research, comms, documents,
+// data, web). Each is a builtin skill catalog item backed by the default tools
+// (web/email/calendar/files/supabase/browser). These are what the banner
+// showcases; the design/QA skills above stay in the marketplace but are not the
+// default highlight reel.
+const BUSINESS_SKILL_SEEDS = [
+  {
+    slug: 'market-research', title: 'Market Research', category: 'research',
+    description: 'Research any market, company, or topic across the web and deliver a cited, structured brief.',
+    tools: ['web_search', 'web_fetch', 'file_write'], risk_summary: 'Read-only research; writes only the report file.',
+    tags: ['research', 'web', 'brief'], invocation: '/research',
+    trigger_examples: ['research this market', 'competitive landscape for X', 'brief me on company Y'],
+  },
+  {
+    slug: 'competitor-watch', title: 'Competitor Watch', category: 'research',
+    description: 'Track competitor pricing, features, and news on a schedule and alert you when something changes.',
+    tools: ['web_fetch', 'web_extract', 'email_send'], risk_summary: 'Read-only monitoring; sends a summary email.',
+    tags: ['research', 'monitoring', 'competitive'], invocation: '/watch',
+    trigger_examples: ['watch competitor pricing', 'alert me when X changes', 'track this page weekly'],
+  },
+  {
+    slug: 'inbox-triage', title: 'Inbox Triage', category: 'comms',
+    description: 'Summarize, prioritize, and draft replies across your inbox so you act on what matters first.',
+    tools: ['gmail_messages_list', 'gmail_thread_read', 'email_send'], risk_summary: 'Drafts replies; sending is approval-gated.',
+    tags: ['email', 'inbox', 'comms'], invocation: '/inbox',
+    trigger_examples: ['triage my inbox', 'summarize unread email', 'draft replies'],
+  },
+  {
+    slug: 'meeting-scheduler', title: 'Meeting Scheduler', category: 'comms',
+    description: 'Find times, schedule meetings, and send invites from your calendar and email.',
+    tools: ['calendar_events_list', 'calendar_event_read', 'email_send'], risk_summary: 'Proposes times; invites are approval-gated.',
+    tags: ['calendar', 'scheduling', 'comms'], invocation: '/schedule-meeting',
+    trigger_examples: ['schedule a meeting', 'find a time with X', 'book a call next week'],
+  },
+  {
+    slug: 'document-extract', title: 'Document Extraction', category: 'documents',
+    description: 'Pull structured data and key facts from PDFs, documents, and audio into clean, usable output.',
+    tools: ['file_read', 'transcribe_audio', 'file_write'], risk_summary: 'Read-only extraction; writes only the output file.',
+    tags: ['documents', 'extraction', 'pdf'], invocation: '/extract',
+    trigger_examples: ['extract data from this PDF', 'pull the numbers from these docs', 'transcribe this audio'],
+  },
+  {
+    slug: 'report-builder', title: 'Report Builder', category: 'documents',
+    description: 'Turn raw data and notes into a polished, formatted report or one-pager ready to share.',
+    tools: ['file_read', 'file_write'], risk_summary: 'Generates a document; no external writes.',
+    tags: ['documents', 'reporting', 'writing'], invocation: '/report',
+    trigger_examples: ['build a report from this data', 'write a one-pager', 'summarize into a deck outline'],
+  },
+  {
+    slug: 'database-query', title: 'Database Q&A', category: 'data',
+    description: 'Ask questions of your database in plain English and get answers, tables, and charts.',
+    tools: ['supabase_rest_select', 'supabase_sql'], risk_summary: 'Read-only queries by default; writes are approval-gated.',
+    tags: ['data', 'sql', 'analytics'], invocation: '/ask-data',
+    trigger_examples: ['how many orders last month', 'query the users table', 'top customers by revenue'],
+  },
+  {
+    slug: 'spreadsheet-analysis', title: 'Spreadsheet Analysis', category: 'data',
+    description: 'Clean, analyze, and summarize spreadsheets and CSVs — pivots, trends, and outliers.',
+    tools: ['file_read', 'file_write'], risk_summary: 'Local file analysis; no external writes.',
+    tags: ['data', 'spreadsheet', 'csv'], invocation: '/analyze-sheet',
+    trigger_examples: ['analyze this spreadsheet', 'summarize this CSV', 'find trends in this data'],
+  },
+  {
+    slug: 'web-automation', title: 'Web Automation', category: 'web',
+    description: 'Fill forms, extract data, and run repetitive flows in a real browser, end to end.',
+    tools: ['browser_open', 'browser_act', 'browser_extract'], risk_summary: 'Browser actions are bounded and audited.',
+    tags: ['web', 'automation', 'browser'], invocation: '/automate-web',
+    trigger_examples: ['automate this form', 'scrape this site', 'run this flow for each row'],
+  },
+];
+
+function buildBusinessSkillSeed(s) {
+  return {
+    slug: s.slug,
+    title: s.title,
+    description: s.description,
+    category: s.category,
+    author: 'madarx',
+    source_kind: 'builtin',
+    source_url: null,
+    version: null,
+    risk_summary: s.risk_summary,
+    tags: s.tags,
+    manifest: {
+      invocation: s.invocation,
+      default: true,
+      uses_tools: s.tools,
+      trigger_examples: s.trigger_examples,
+    },
+  };
+}
+
 const BUNDLE_SEEDS = [
   {
     slug: 'gstack',
@@ -240,10 +333,13 @@ function upsertItem(db, kind, seed) {
       new Date().toISOString(),
     );
 
+    // Default-on capabilities (manifest.default) seed as installed so the
+    // marketplace reflects what the agent ships with out of the box.
+    const installedDefault = seed?.manifest?.default ? 1 : 0;
     db.prepare(`
-      INSERT OR IGNORE INTO marketplace_installations (item_id, installed)
-      VALUES (?, 0)
-    `).run(id);
+      INSERT OR IGNORE INTO marketplace_installations (item_id, installed, installed_at)
+      VALUES (?, ?, ?)
+    `).run(id, installedDefault, installedDefault ? new Date().toISOString() : null);
   }
 }
 
@@ -288,6 +384,7 @@ const MINES_MODULE_SEED = {
 
 export function seedMarketplaceItems(db) {
   try {
+    for (const s of BUSINESS_SKILL_SEEDS) upsertItem(db, 'skill', buildBusinessSkillSeed(s));
     for (const seed of SKILL_SEEDS) upsertItem(db, 'skill', seed);
     for (const seed of BUNDLE_SEEDS) upsertItem(db, 'bundle', seed);
     for (const curated of OPEN_DESIGN_CURATED_SKILLS) {
@@ -302,6 +399,47 @@ export function seedMarketplaceItems(db) {
   }
 }
 
+// The default business skills, grouped by category for the CLI banner showcase.
+export const DEFAULT_SKILL_SLUGS = BUSINESS_SKILL_SEEDS.map(s => s.slug);
+const DEFAULT_SKILL_CATEGORY_ORDER = ['research', 'comms', 'documents', 'data', 'web'];
+export function listDefaultSkillGroups() {
+  const byCat = new Map();
+  for (const s of BUSINESS_SKILL_SEEDS) {
+    if (!byCat.has(s.category)) byCat.set(s.category, []);
+    byCat.get(s.category).push(s.slug);
+  }
+  return DEFAULT_SKILL_CATEGORY_ORDER
+    .filter(c => byCat.has(c))
+    .map(category => ({ category, count: byCat.get(category).length, names: byCat.get(category) }));
+}
+
+/**
+ * The default business skills rendered as a `skills.md` section — injected into
+ * an agent's skills file so the runtime (which reads skills.md) actually surfaces
+ * them. Grouped by category, with invocation, description, and the tools each
+ * leans on.
+ */
+export function defaultSkillsMarkdown() {
+  const titleCase = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+  const lines = [
+    '## Default skills',
+    '',
+    'You ship with these ready-to-use business skills. Reach for them by intent;',
+    'each is backed by your enabled tools and stays within the usual approval gates.',
+    '',
+  ];
+  for (const g of listDefaultSkillGroups()) {
+    lines.push(`### ${titleCase(g.category)}`);
+    for (const slug of g.names) {
+      const s = BUSINESS_SKILL_SEEDS.find((x) => x.slug === slug);
+      if (!s) continue;
+      lines.push(`- **${s.title}** (\`${s.invocation}\`) — ${s.description} _Tools: ${s.tools.join(', ')}._`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n').trimEnd() + '\n';
+}
+
 export const PHASE1_SKILL_SLUGS = SKILL_SEEDS.map(s => s.slug);
 export const PHASE1_BUNDLE_SLUGS = BUNDLE_SEEDS.map(s => s.slug);
 export const OPEN_DESIGN_SKILL_SLUGS = OPEN_DESIGN_CURATED_SKILLS.map(s => `open-design-${s.slug}`);

package/lib/process/artifacts.js

@@ -230,59 +230,12 @@ function htmlShell({ title, kicker, bodyHtml }) {
 
 // ── Renderers ───────────────────────────────────────────────────────────────
 
-export function renderIntakeFormHtml({ definition, schema, caseRow, settings = null, mode = 'preview', submit_endpoint = null, submit_token = null }) {
-  if (mode === 'interactive') {
-    return renderIntakeFormInteractiveHtml({ definition, schema, caseRow, settings, submit_endpoint, submit_token });
-  }
-  // Preview (Phase 1 / no flag) — read-only artifact.
-  const fields = Array.isArray(schema?.fields) ? schema.fields : [];
-  const fieldsHtml = fields
-    .map((f) => {
-      const req = f.required ? '<span class="req"></span>' : '';
-      const help = f.help ? `<p class="field-help">${escapeHtml(f.help)}</p>` : '';
-      let preview = '<em class="muted">Field will be captured at intake.</em>';
-      if (f.type === 'select' && Array.isArray(f.options)) {
-        preview = `<span class="muted">Choose one of:</span> ${f.options.map((o) => `<span class="pill">${escapeHtml(o)}</span>`).join(' ')}`;
-      } else if (f.type === 'shareholders') {
-        preview = '<span class="muted">Repeatable rows: shareholder name + percentage (must sum to 100).</span>';
-      } else if (f.placeholder) {
-        preview = `<span class="muted">${escapeHtml(f.placeholder)}</span>`;
-      } else if (f.type) {
-        preview = `<span class="muted">Type: ${escapeHtml(f.type)}</span>`;
-      }
-      return `
-        <div class="field">
-          <span class="field-label">${escapeHtml(f.label || f.name)}${req}</span>
-          ${help}
-          <div class="field-value">${preview}</div>
-        </div>`;
-    })
-    .join('');
-
-  const body = `
-    <h1>${escapeHtml(schema?.title || `${definition?.name || 'Process'} — intake`)}</h1>
-    <div class="meta">
-      <span><strong>Process:</strong>&nbsp;${escapeHtml(definition?.name || definition?.slug || '')}</span>
-      <span><strong>Case:</strong>&nbsp;${escapeHtml(caseRow?.title || '')}</span>
-      <span class="pill">awaiting submission</span>
-    </div>
-    ${schema?.description ? `<p class="muted">${escapeHtml(schema.description)}</p>` : ''}
-    <div class="note">
-      This artifact is the source-of-record intake page for case <code>${escapeHtml(caseRow?.id || '')}</code>.
-      Submit the live form via the workflows dashboard; on submit a companion <em>intake submission</em> artifact
-      is generated and linked to this case.
-    </div>
-    <h2>Fields</h2>
-    ${fieldsHtml || '<p class="muted">No fields configured.</p>'}
-    <div class="art-footer">
-      Generated by Madarx OS process engine · definition <code>${escapeHtml(definition?.slug || '')}</code>
-    </div>
-  `;
-  return htmlShell({
-    title: schema?.title || `Intake — ${definition?.name || ''}`,
-    kicker: 'Intake form · awaiting submission',
-    bodyHtml: body,
-  });
+// Renders the branded interactive intake form — a single self-contained HTML
+// document with REAL form controls that POSTs to `submit_endpoint`. This is the
+// only intake-form shape as of v2.14.0; the legacy read-only "preview" renderer
+// and its MADARX_BRANDED_INTAKE flag were removed.
+export function renderIntakeFormHtml({ definition, schema, caseRow, settings = null, submit_endpoint = null, submit_token = null }) {
+  return renderIntakeFormInteractiveHtml({ definition, schema, caseRow, settings, submit_endpoint, submit_token });
 }
 
 // ── Branded interactive renderer (Phase 2) ──────────────────────────────────
@@ -713,19 +666,18 @@ function safeCreate(opts) {
   }
 }
 
-export function createIntakeFormArtifact({ definition, schema, caseRow, settings = null, mode = 'preview', submit_endpoint = null, submit_token = null }) {
+export function createIntakeFormArtifact({ definition, schema, caseRow, settings = null, submit_endpoint = null, submit_token = null }) {
   if (!definition || !caseRow) return null;
-  const html = renderIntakeFormHtml({ definition, schema, caseRow, settings, mode, submit_endpoint, submit_token });
-  const modeSuffix = mode === 'interactive' ? ' (branded)' : '';
-  const title = `${definition.name || definition.slug || 'Process'} — intake form${modeSuffix} — ${caseRow.title || caseRow.id.slice(-8)}`;
+  const html = renderIntakeFormHtml({ definition, schema, caseRow, settings, submit_endpoint, submit_token });
+  const title = `${definition.name || definition.slug || 'Process'} — intake form — ${caseRow.title || caseRow.id.slice(-8)}`;
   return safeCreate({
     title,
     kind: 'html',
     content: html,
     project_id: caseRow.project_id,
-    // Dedupe keyed on case + mode so re-rendering with a fresh token (share-
-    // link mint) replaces rather than spawns a new artifact.
-    dedupe_key: `process_intake_form:${caseRow.id}:${mode}`,
+    // Dedupe keyed on case so re-rendering with a fresh token (share-link mint)
+    // replaces rather than spawns a new artifact.
+    dedupe_key: `process_intake_form:${caseRow.id}`,
   });
 }
 

package/lib/process/engine.js

@@ -104,20 +104,20 @@ function appendProcessAudit({ case_id, stage_id = null, action, status = 'succes
 
 // Render the case-level intake-form artifact at startCase time. Failure is
 // observation-only — engine state stays the source of truth and the case can
-// still progress without a presentation artifact. MADARX_BRANDED_INTAKE=1
-// switches to the interactive (in-document form) shape; off renders preview.
+// still progress without a presentation artifact. The artifact is always the
+// branded interactive (in-document form) shape; it posts to the stage submit
+// endpoint. (The legacy read-only "preview" shape and its MADARX_BRANDED_INTAKE
+// flag were removed in v2.14.0 — branded intake is the only start path.)
 function seedIntakeArtifact({ definition, firstStage, caseRow, snapshot }) {
   if (firstStage.kind !== 'intake_form') return null;
   try {
     const schema = parseIntakeFormSchema(definition);
-    const branded = process.env.MADARX_BRANDED_INTAKE === '1';
     return createIntakeFormArtifact({
       definition,
       schema,
       caseRow,
       settings: snapshot,
-      mode: branded ? 'interactive' : 'preview',
-      submit_endpoint: branded ? `/api/processes/${caseRow.id}/stages/${firstStage.slug}/submit` : null,
+      submit_endpoint: `/api/processes/${caseRow.id}/stages/${firstStage.slug}/submit`,
     });
   } catch { return null; }
 }

package/lib/process/policy-predicates.js

@@ -0,0 +1,116 @@
+// lib/process/policy-predicates.js — JSON predicate evaluator for policy_gate.
+//
+// Replaces the hand-rolled string DSL (`stages/policy-dsl-legacy.js`) with a
+// declarative predicate tree. No tokenizer, no parser, no escaping bugs — a
+// predicate is plain JSON that the spec-validator can validate structurally
+// and an agent can author without learning an expression grammar.
+//
+// Shape:
+//   { "op": "and",  "rules": [ <predicate>, ... ] }
+//   { "op": "or",   "rules": [ <predicate>, ... ] }
+//   { "op": "not",  "rule":  <predicate> }
+//   { "op": "eq",   "path": "intake.country", "value": "US" }
+//   { "op": "gte",  "path": "prior_stage.kyc-risk.risk_score", "value": 0.3 }
+//   { "op": "in",   "path": "intake.type", "value": ["MSA", "SOW", "NDA"] }
+//
+// Path resolution (read-only):
+//   intake.<field…>            → case intake payload
+//   prior_stage.<slug>.<field…> → that stage's accumulated context output
+//   context.<field…>            → raw context bag
+//   <bare>                      → resolved against the whole ctx object
+//
+// Equality (`eq`/`neq`) is intentionally loose (`==`/`!=`) so a `neq null`
+// check treats a missing path the same as an explicit null — matching the
+// "field must be provided" idiom the legacy DSL expressed as `x != null`.
+
+const MAX_DEPTH = 20;
+
+export const LOGICAL_OPS = new Set(['and', 'or', 'not']);
+export const COMPARE_OPS = new Set(['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'in', 'nin']);
+
+const COMPARATORS = {
+  eq: (a, b) => a == b, // eslint-disable-line eqeqeq
+  neq: (a, b) => a != b, // eslint-disable-line eqeqeq
+  lt: (a, b) => Number(a) < Number(b),
+  lte: (a, b) => Number(a) <= Number(b),
+  gt: (a, b) => Number(a) > Number(b),
+  gte: (a, b) => Number(a) >= Number(b),
+  in: (a, b) => Array.isArray(b) && b.some((v) => v === a),
+  nin: (a, b) => Array.isArray(b) && !b.some((v) => v === a),
+};
+
+function isPlainObject(v) {
+  return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function readDeep(obj, path) {
+  if (!path) return obj;
+  return path.split('.').reduce((acc, key) => (acc == null ? acc : acc[key]), obj);
+}
+
+// Resolve a `path` string against the evaluation context. `ctx` carries
+// `intake` and `context` (the accumulated per-stage output bag).
+export function resolvePath(path, ctx) {
+  if (typeof path !== 'string' || !path) return undefined;
+  const dot = path.indexOf('.');
+  const head = dot === -1 ? path : path.slice(0, dot);
+  const rest = dot === -1 ? '' : path.slice(dot + 1);
+  if (head === 'intake') return readDeep(ctx?.intake, rest);
+  if (head === 'context') return readDeep(ctx?.context, rest);
+  if (head === 'prior_stage') {
+    const slugDot = rest.indexOf('.');
+    const slug = slugDot === -1 ? rest : rest.slice(0, slugDot);
+    const field = slugDot === -1 ? '' : rest.slice(slugDot + 1);
+    return readDeep(ctx?.context?.[slug], field);
+  }
+  return readDeep(ctx, path);
+}
+
+// True when a rule entry is a JSON predicate (vs a legacy string / { expr }).
+export function isPredicateRule(rule) {
+  return isPlainObject(rule) && typeof rule.op === 'string';
+}
+
+// Evaluate a predicate tree against { intake, context }. Throws on a malformed
+// predicate so the caller can surface the error in the gate trace.
+export function evaluatePredicate(pred, ctx, depth = 0) {
+  if (depth > MAX_DEPTH) throw new Error('policy-predicate: maximum nesting depth exceeded');
+  if (!isPlainObject(pred)) throw new Error('policy-predicate: predicate must be an object');
+  const op = pred.op;
+  if (op === 'and' || op === 'or') {
+    if (!Array.isArray(pred.rules)) throw new Error(`policy-predicate: "${op}" requires a rules[] array`);
+    const results = pred.rules.map((r) => evaluatePredicate(r, ctx, depth + 1));
+    return op === 'and' ? results.every(Boolean) : results.some(Boolean);
+  }
+  if (op === 'not') {
+    if (!isPlainObject(pred.rule)) throw new Error('policy-predicate: "not" requires a rule object');
+    return !evaluatePredicate(pred.rule, ctx, depth + 1);
+  }
+  const cmp = COMPARATORS[op];
+  if (!cmp) throw new Error(`policy-predicate: unknown op "${op}"`);
+  if (typeof pred.path !== 'string' || !pred.path) {
+    throw new Error(`policy-predicate: "${op}" requires a path`);
+  }
+  const left = resolvePath(pred.path, ctx);
+  return Boolean(cmp(left, pred.value));
+}
+
+// Non-throwing wrapper mirroring the legacy `evaluateRule` return shape.
+export function evaluatePredicateSafe(pred, ctx) {
+  try {
+    return { result: Boolean(evaluatePredicate(pred, ctx)), error: null };
+  } catch (err) {
+    return { result: false, error: err?.message || String(err) };
+  }
+}
+
+// Short human-readable label for a predicate when the author supplied none.
+export function describePredicate(pred) {
+  if (!isPlainObject(pred)) return String(pred);
+  if (pred.label) return pred.label;
+  if (pred.op === 'and' || pred.op === 'or') {
+    return `(${(pred.rules || []).map(describePredicate).join(` ${pred.op} `)})`;
+  }
+  if (pred.op === 'not') return `not ${describePredicate(pred.rule)}`;
+  return `${pred.path} ${pred.op} ${JSON.stringify(pred.value)}`;
+}

package/lib/process/seeds/specs/mine-project-intake.json

@@ -64,12 +64,20 @@
       "config": {
         "rules": [
           {
-            "expr": "intake.project_name != null && intake.project_slug != null",
-            "label": "Project name and slug must be provided"
+            "label": "Project name and slug must be provided",
+            "op": "and",
+            "rules": [
+              { "op": "neq", "path": "intake.project_name", "value": null },
+              { "op": "neq", "path": "intake.project_slug", "value": null }
+            ]
           },
           {
-            "expr": "intake.data_directory_path != null && intake.data_directory_path != ''",
-            "label": "Data directory path must be non-empty"
+            "label": "Data directory path must be non-empty",
+            "op": "and",
+            "rules": [
+              { "op": "neq", "path": "intake.data_directory_path", "value": null },
+              { "op": "neq", "path": "intake.data_directory_path", "value": "" }
+            ]
           }
         ]
       },

package/lib/process/seeds/specs/mine-valuation.json

@@ -50,8 +50,12 @@
       "config": {
         "rules": [
           {
-            "expr": "intake.project_id != null && intake.project_id != ''",
-            "label": "Project ID must be provided"
+            "label": "Project ID must be provided",
+            "op": "and",
+            "rules": [
+              { "op": "neq", "path": "intake.project_id", "value": null },
+              { "op": "neq", "path": "intake.project_id", "value": "" }
+            ]
           }
         ]
       },