madarx 2.13.0 → 2.15.0

package/lib/cli/setup.js

@@ -1,10 +1,17 @@
 /**
  * `madarx setup` — interactive first-run wizard.
  *
- * Walks the operator through: data home, secrets-vault master key, the folder
- * permissions the bundled agent may read/write (MADARX_ALLOWED_ROOTS), optional
- * API keys (stored in the encrypted vault), the WhatsApp toggle, and the weekly
- * auto-update preference (consumed by T3's self-update).
+ * An arrow-key guided setup that decides the things that shape the whole
+ * install up front, then fills in credentials and preferences:
+ *
+ *   1. Usage mode      personal (local-only) vs team (Supabase shared layer)
+ *   2. Main agent      which model/engine the orchestrator runs on
+ *   3. Sub-agents      default model/engine new agents inherit
+ *   4. Secrets vault   master key (generated + persisted on first run)
+ *   5. API keys        Anthropic / OpenAI → encrypted vault
+ *   6. Folder grants   MADARX_ALLOWED_ROOTS (the agent's file/exec boundary)
+ *   7. WhatsApp        bridge on/off
+ *   8. Auto-update     weekly notify / hands-off / off
  *
  * Sets MADARX_DISABLE_INPROC_DAEMON=1 before importing the runtime — a setup run
  * must not spin up cron/heartbeat loops.
@@ -13,42 +20,33 @@
 import { createInterface } from 'node:readline/promises';
 import { applyHomeEnv } from './home.js';
 import { upsertEnvVar, removeEnvVar, readEnvFile } from './env-file.js';
-import { renderHeader } from './banner.js';
+import { renderHeader, _palette as P, fg, bold, dim } from './banner.js';
 import { readVersion } from './dispatch.js';
+import { select, confirm } from './prompt.js';
 
 function isInteractive() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
 
-/** readline with a muted variant for secret entry (echoes `*`). */
-function makeReader() {
-  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
-  rl.stdoutMuted = false;
-  rl._writeToOutput = function (str) {
-    if (rl.stdoutMuted) rl.output.write('*');
-    else rl.output.write(str);
-  };
-  return rl;
-}
-
-async function ask(rl, prompt, dflt = '') {
-  const suffix = dflt ? ` [${dflt}]` : '';
-  const ans = (await rl.question(`${prompt}${suffix}: `)).trim();
-  return ans || dflt;
-}
-
-async function askYesNo(rl, prompt, dfltYes = true) {
-  const ans = (await rl.question(`${prompt} ${dfltYes ? '[Y/n]' : '[y/N]'}: `)).trim().toLowerCase();
-  if (!ans) return dfltYes;
-  return ans === 'y' || ans === 'yes';
-}
+const h2 = (s) => console.log('\n' + bold(fg(P.platinum, s)));
+const note = (s) => console.log('  ' + dim(fg(P.muted, s)));
+const ok = (s) => console.log('  ' + fg(P.mars, '●') + ' ' + fg(P.bone, s));
 
-async function askSecret(rl, prompt) {
-  rl.stdoutMuted = true;
-  const val = (await rl.question(`${prompt}: `)).trim();
+/** Open an ephemeral readline for one text prompt, then close it (so it never
+ *  competes with the raw-mode arrow menus). `secret` echoes `*`. */
+async function ask(prompt, { dflt = '', secret = false } = {}) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
   rl.stdoutMuted = false;
-  rl.output.write('\n');
-  return val;
+  rl._writeToOutput = function (str) { rl.output.write(rl.stdoutMuted ? '*' : str); };
+  try {
+    rl.stdoutMuted = secret;
+    const suffix = dflt ? ` [${dflt}]` : '';
+    const ans = (await rl.question(`  ${fg(P.bone, prompt)}${dim(suffix)}: `)).trim();
+    if (secret) rl.output.write('\n');
+    return ans || dflt;
+  } finally {
+    rl.close();
+  }
 }
 
 export async function setup() {
@@ -57,87 +55,154 @@ export async function setup() {
     return 1;
   }
 
-  // Management command — never run the in-process daemons.
-  process.env.MADARX_DISABLE_INPROC_DAEMON = '1';
-
+  process.env.MADARX_DISABLE_INPROC_DAEMON = '1'; // management command — no daemons
   const layout = applyHomeEnv();
-  const rl = makeReader();
 
   try {
     console.log(renderHeader('setup', readVersion()));
-    console.log(`Data home: ${layout.home}`);
-    console.log('(override anytime with the MADARX_HOME env var)\n');
+    console.log(`Data home: ${fg(P.bone, layout.home)}`);
+    note('override anytime with the MADARX_HOME env var');
 
-    // 1. Master key — delegate to the canonical resolver (generates + persists
-    //    to $MADARX_HOME/.env.local on first run, prints the backup instruction).
-    console.log('1) Secrets vault');
-    const { resolveMasterKey } = await import('../master-key.js');
+    // Open the DB once so vault + config tables exist for the steps below.
     const { getDb } = await import('../db.js');
-    getDb(); // open/create the DB so the vault + config tables exist
-    resolveMasterKey({ allowGenerate: true });
-    console.log('   Master key ready.\n');
+    getDb();
+    const { setConfig } = await import('../config.js');
 
-    // 2. Folder permissions for the bundled agent.
-    console.log('2) Folder permissions');
-    console.log('   The agent can read/write/run commands ONLY inside roots you grant here.');
-    console.log('   (The repo root and workspace/ are always allowed. Leave blank to skip.)');
-    const existingRoots = readEnvFile(layout.envFile).MADARX_ALLOWED_ROOTS || '';
-    const roots = await ask(rl, '   Extra allowed roots (comma-separated absolute paths)', existingRoots);
-    if (roots) {
-      const cleaned = roots.split(',').map((r) => r.trim()).filter(Boolean).join(',');
-      upsertEnvVar(layout.envFile, 'MADARX_ALLOWED_ROOTS', cleaned);
-      console.log(`   Granted: ${cleaned}\n`);
+    // ── 1. Usage mode ────────────────────────────────────────────────────────
+    h2('1 · How will you use madarX?');
+    const mode = await select('Choose a setup', [
+      { label: 'Personal', value: 'local', tag: 'recommended', hint: 'local-only, everything on this machine' },
+      { label: 'Team', value: 'supabase', hint: 'shared with a team via Supabase (auth, orgs, sharing)' },
+    ], { default: 0 });
+
+    if (mode === 'supabase') {
+      setConfig('auth_mode', 'supabase');
+      note('Enter your Supabase project credentials (stored in ' + layout.envFile + ').');
+      const existing = readEnvFile(layout.envFile);
+      const url = await ask('Supabase URL', { dflt: existing.SUPABASE_URL || existing.NEXT_PUBLIC_SUPABASE_URL || '' });
+      const anon = await ask('Supabase anon key', { dflt: existing.SUPABASE_ANON_KEY || '' });
+      const service = await ask('Supabase service-role key', { secret: true });
+      if (url) { upsertEnvVar(layout.envFile, 'SUPABASE_URL', url); upsertEnvVar(layout.envFile, 'NEXT_PUBLIC_SUPABASE_URL', url); }
+      if (anon) { upsertEnvVar(layout.envFile, 'SUPABASE_ANON_KEY', anon); upsertEnvVar(layout.envFile, 'NEXT_PUBLIC_SUPABASE_ANON_KEY', anon); }
+      if (service) upsertEnvVar(layout.envFile, 'SUPABASE_SERVICE_ROLE_KEY', service);
+      ok('Team mode (Supabase) configured.');
+      note('Apply the cloud schema once: see supabase/README.md.');
+    } else {
+      setConfig('auth_mode', 'local');
+      ok('Personal mode — local-only.');
+    }
+
+    // ── Model catalog (probes installed CLIs + Ollama; Anthropic always listed) ─
+    const { getModels, setModel, getModel } = await import('../agent-config.js');
+    const { defaultModelForEngine } = await import('../agent-engines.js');
+    let models = [];
+    try { models = await getModels(); } catch { models = []; }
+    const recommendedId = models.find((m) => m.engine === 'claude-code') ? 'claude-code'
+      : (models.find((m) => m.id === 'claude-sonnet-4-6') ? 'claude-sonnet-4-6' : models[0]?.id);
+    const modelOption = (m) => ({
+      label: m.label,
+      value: { id: m.id, engine: m.engine },
+      hint: m.engine,
+      tag: m.id === recommendedId ? 'recommended' : undefined,
+    });
+    const orderedModels = [
+      ...models.filter((m) => m.id === recommendedId),
+      ...models.filter((m) => m.id !== recommendedId),
+    ];
+
+    // ── 2. Main agent model ──────────────────────────────────────────────────
+    h2('2 · Main agent model');
+    note('the orchestrator that plans your work and dispatches sub-agents');
+    const current = getModel();
+    const mainChoice = await select('Select the main agent model', [
+      ...orderedModels.map(modelOption),
+      { label: `Keep current (${current})`, value: { keep: true } },
+    ], { default: 0 });
+    if (!mainChoice.keep) { setModel(mainChoice.id); ok(`Main agent → ${mainChoice.id}`); }
+    else ok(`Main agent unchanged (${current})`);
+    const mainEngine = mainChoice.keep ? null : mainChoice.engine;
+
+    // ── 3. Sub-agent default model ───────────────────────────────────────────
+    h2('3 · Sub-agent default model');
+    note('what newly created agents inherit unless you pick another at creation');
+    const subChoice = await select('Select the default sub-agent model', [
+      { label: 'Same as main agent', value: { same: true }, tag: 'recommended' },
+      ...orderedModels.map(modelOption),
+    ], { default: 0 });
+    let subEngine, subModel;
+    if (subChoice.same) {
+      subEngine = mainEngine || (orderedModels.find((m) => m.id === current)?.engine) || 'claude-code';
+      subModel = mainChoice.keep ? current : mainChoice.id;
     } else {
-      console.log('   No extra roots granted.\n');
+      subEngine = subChoice.engine;
+      subModel = subChoice.engine === 'anthropic' ? subChoice.id : defaultModelForEngine(subChoice.engine);
     }
+    setConfig('default_agent_engine', subEngine);
+    setConfig('default_agent_model', subModel);
+    ok(`Sub-agents → ${subEngine}${subModel ? ' · ' + subModel : ''}`);
+
+    // ── 4. Secrets vault master key ──────────────────────────────────────────
+    h2('4 · Secrets vault');
+    const { resolveMasterKey } = await import('../master-key.js');
+    resolveMasterKey({ allowGenerate: true });
+    ok('Master key ready (AES-256-GCM).');
 
-    // 3. API keys → encrypted vault.
-    console.log('3) API keys (stored encrypted in the vault; press Enter to skip any)');
-    const { setSecret } = await import('../secrets.js');
+    // ── 5. API keys → encrypted vault ────────────────────────────────────────
+    h2('5 · API keys');
+    note('stored encrypted in the vault · press Enter to skip any');
+    const { setSecret, getSecret } = await import('../secrets.js');
+    const usesAnthropic = [mainEngine, subEngine].includes('anthropic');
     const keyPrompts = [
-      ['ANTHROPIC_API_KEY', 'Anthropic API key (Claude)'],
+      ['ANTHROPIC_API_KEY', 'Anthropic API key (Claude)' + (usesAnthropic ? ' — required for your selection' : '')],
       ['OPENAI_API_KEY', 'OpenAI API key (voice/realtime, optional)'],
     ];
     for (const [name, label] of keyPrompts) {
-      const val = await askSecret(rl, `   ${label}`);
+      let have = false;
+      try { have = Boolean(getSecret(name)); } catch { /* vault may be empty */ }
+      const val = await ask(label + (have ? ' (set — Enter to keep)' : ''), { secret: true });
       if (val) {
-        try { setSecret(name, val, { scope: 'global' }); console.log(`   Stored ${name}.`); }
-        catch (err) { console.error(`   Could not store ${name}: ${err.message}`); }
+        try { setSecret(name, val, { scope: 'global' }); ok(`Stored ${name}.`); }
+        catch (err) { console.error('  ' + fg(P.mars, '✗') + ` Could not store ${name}: ${err.message}`); }
       }
     }
-    console.log('');
-
-    // 4. WhatsApp bridge toggle.
-    console.log('4) WhatsApp bridge');
-    const enableWa = await askYesNo(rl, '   Run the WhatsApp bridge with `madarx`?', true);
-    if (enableWa) {
-      removeEnvVar(layout.envFile, 'MADARX_DISABLE_WHATSAPP');
-      console.log('   Enabled (idles until you pair a dedicated number).\n');
+
+    // ── 6. Folder permissions ────────────────────────────────────────────────
+    h2('6 · Folder permissions');
+    note('the agent can read/write/run ONLY inside roots you grant (repo + workspace/ always allowed)');
+    const existingRoots = readEnvFile(layout.envFile).MADARX_ALLOWED_ROOTS || '';
+    const roots = await ask('Extra allowed roots (comma-separated absolute paths)', { dflt: existingRoots });
+    if (roots) {
+      const cleaned = roots.split(',').map((r) => r.trim()).filter(Boolean).join(',');
+      upsertEnvVar(layout.envFile, 'MADARX_ALLOWED_ROOTS', cleaned);
+      ok(`Granted: ${cleaned}`);
     } else {
-      upsertEnvVar(layout.envFile, 'MADARX_DISABLE_WHATSAPP', '1');
-      console.log('   Disabled.\n');
+      note('no extra roots granted');
     }
 
-    // 5. Auto-update preference (consumed by T3 self-update).
-    console.log('5) Auto-update');
-    const weekly = await askYesNo(rl, '   Check weekly for updates?', true);
-    const { setConfig } = await import('../config.js');
-    if (weekly) {
-      const handsOff = await askYesNo(rl, '   Apply updates automatically (hands-off) instead of just notifying?', false);
+    // ── 7. WhatsApp bridge ───────────────────────────────────────────────────
+    h2('7 · WhatsApp bridge');
+    const enableWa = await confirm('Run the WhatsApp bridge with `madarx`?', { default: true });
+    if (enableWa) { removeEnvVar(layout.envFile, 'MADARX_DISABLE_WHATSAPP'); ok('Enabled — idles until you pair a dedicated number.'); }
+    else { upsertEnvVar(layout.envFile, 'MADARX_DISABLE_WHATSAPP', '1'); ok('Disabled.'); }
+
+    // ── 8. Auto-update ───────────────────────────────────────────────────────
+    h2('8 · Auto-update');
+    const upd = await select('How should madarX handle updates?', [
+      { label: 'Notify weekly', value: 'notify', tag: 'recommended', hint: 'check weekly, tell me — I apply' },
+      { label: 'Auto-apply weekly', value: 'auto', hint: 'hands-off, gated by the approval/trust tier' },
+      { label: 'Off', value: 'off', hint: 'I will run `madarx update` myself' },
+    ], { default: 0 });
+    if (upd === 'off') { setConfig('auto_update_mode', 'off'); ok('Auto-update off.'); }
+    else {
       setConfig('auto_update_mode', 'weekly');
-      setConfig('auto_update_apply', handsOff ? 'auto' : 'notify');
-      console.log(`   Weekly check on; updates will ${handsOff ? 'auto-apply (gated by the approval/trust tier)' : 'notify only'}.\n`);
-    } else {
-      setConfig('auto_update_mode', 'off');
-      console.log('   Auto-update off. Run `madarx update` manually.\n');
+      setConfig('auto_update_apply', upd === 'auto' ? 'auto' : 'notify');
+      ok(`Weekly check on — ${upd === 'auto' ? 'auto-apply' : 'notify only'}.`);
     }
 
-    console.log('Setup complete.  Start everything with:  madarx\n');
+    console.log('\n' + bold(fg(P.platinum, 'Setup complete.')) + '  Start everything with:  ' + fg(P.mars, 'madarx') + '\n');
     return 0;
   } catch (err) {
     console.error(`\nsetup failed: ${err?.stack || err}`);
     return 1;
-  } finally {
-    rl.close();
   }
 }

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": "" }
+            ]
           }
         ]
       },

package/lib/process/spec-validator.js

@@ -116,6 +116,46 @@ function validateAgentRun(stage, errors, prefix, opts, stageSlugs) {
   }
 }
 
+// Predicate operator sets (mirror lib/process/policy-predicates.js).
+const PREDICATE_LOGICAL_OPS = new Set(['and', 'or']);
+const PREDICATE_COMPARE_OPS = new Set(['eq', 'neq', 'lt', 'lte', 'gt', 'gte', 'in', 'nin']);
+const PREDICATE_MAX_DEPTH = 20;
+
+// Validate a JSON predicate tree structurally. Mirrors the evaluator so an
+// invalid predicate is rejected at authoring time, not at case run time.
+function validatePredicate(pred, errors, prefix, depth = 0) {
+  if (depth > PREDICATE_MAX_DEPTH) {
+    pushErr(errors, prefix, 'predicate nesting too deep');
+    return;
+  }
+  if (!isPlainObject(pred)) {
+    pushErr(errors, prefix, 'predicate must be an object');
+    return;
+  }
+  const op = pred.op;
+  if (PREDICATE_LOGICAL_OPS.has(op)) {
+    if (!Array.isArray(pred.rules) || pred.rules.length === 0) {
+      pushErr(errors, `${prefix}.rules`, `"${op}" requires a non-empty rules[] array`);
+    } else {
+      pred.rules.forEach((r, i) => validatePredicate(r, errors, `${prefix}.rules[${i}]`, depth + 1));
+    }
+  } else if (op === 'not') {
+    if (!isPlainObject(pred.rule)) pushErr(errors, `${prefix}.rule`, '"not" requires a rule object');
+    else validatePredicate(pred.rule, errors, `${prefix}.rule`, depth + 1);
+  } else if (PREDICATE_COMPARE_OPS.has(op)) {
+    if (typeof pred.path !== 'string' || !pred.path.trim()) {
+      pushErr(errors, `${prefix}.path`, 'required (non-empty string)');
+    }
+    if (!('value' in pred)) {
+      pushErr(errors, `${prefix}.value`, 'required');
+    } else if ((op === 'in' || op === 'nin') && !Array.isArray(pred.value)) {
+      pushErr(errors, `${prefix}.value`, `"${op}" requires an array value`);
+    }
+  } else {
+    pushErr(errors, `${prefix}.op`, `unknown predicate op "${op}"`);
+  }
+}
+
 function validatePolicyGate(stage, errors, prefix) {
   const config = stage.config || {};
   if (!Array.isArray(config.rules) || config.rules.length === 0) {
@@ -125,13 +165,18 @@ function validatePolicyGate(stage, errors, prefix) {
   config.rules.forEach((rule, i) => {
     const rpath = `${prefix}.config.rules[${i}]`;
     if (typeof rule === 'string') {
+      // Legacy string DSL (deprecated; accepted one release for migration).
       if (!rule.trim()) pushErr(errors, rpath, 'empty rule expression');
+    } else if (isPlainObject(rule) && typeof rule.op === 'string') {
+      // JSON predicate (canonical form).
+      validatePredicate(rule, errors, rpath);
     } else if (isPlainObject(rule)) {
+      // Legacy { expr, label } wrapper.
       if (!rule.expr || typeof rule.expr !== 'string' || !rule.expr.trim()) {
         pushErr(errors, `${rpath}.expr`, 'required (non-empty string)');
       }
     } else {
-      pushErr(errors, rpath, 'rule must be a string or { expr, label } object');
+      pushErr(errors, rpath, 'rule must be a JSON predicate, a string, or { expr, label }');
     }
   });
 }