@a-company/paradigm 3.46.0 → 5.3.3

package/dist/{migrate-FQVGQNXZ.js → migrate-LS45DNEV.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/migrate/index.ts
 import * as fs4 from "fs";
@@ -486,7 +486,7 @@ var refreshHooks = {
   async apply(rootDir, opts) {
     if (opts.dryRun) return { status: "skipped", message: "Would reinstall hooks" };
     try {
-      const { hooksInstallCommand } = await import("./hooks-TCUHQMPF.js");
+      const { hooksInstallCommand } = await import("./hooks-HFWSCGPV.js");
       await hooksInstallCommand({ force: true });
       return { status: "applied", message: "Hooks reinstalled" };
     } catch (err) {

package/dist/{migrate-assessments-JP6Q5KME.js → migrate-assessments-RGH4O6IX.js}

@@ -2,8 +2,8 @@
 import {
   normalizeLoreEntry,
   recordLore
-} from "./chunk-QIOCFXDQ.js";
-import "./chunk-ZXMDA7VB.js";
+} from "./chunk-EKGMAM62.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/lore/migrate-assessments.ts
 import chalk from "chalk";

package/dist/nomination-engine-Q4XSXFKT.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import {
+  adjustAttentionFromFeedback,
+  applySurfacingRules,
+  autoPromoteJournalEntries,
+  detectDebates,
+  emitAndProcess,
+  engageNomination,
+  forwardNominationsToRelay,
+  getNominationStats,
+  init_nomination_engine,
+  loadDebates,
+  loadNominations,
+  loadSurfacingConfig,
+  persistNominations,
+  processEvent,
+  processPendingEvents,
+  resolveDebate
+} from "./chunk-GGMI6C2L.js";
+import "./chunk-A2L4TSLZ.js";
+import "./chunk-MCMOGQMU.js";
+import "./chunk-7N7GSU6K.js";
+init_nomination_engine();
+export {
+  adjustAttentionFromFeedback,
+  applySurfacingRules,
+  autoPromoteJournalEntries,
+  detectDebates,
+  emitAndProcess,
+  engageNomination,
+  forwardNominationsToRelay,
+  getNominationStats,
+  loadDebates,
+  loadNominations,
+  loadSurfacingConfig,
+  persistNominations,
+  processEvent,
+  processPendingEvents,
+  resolveDebate
+};

package/dist/notebook-YWIYGEHV.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import "./chunk-PDX44BCA.js";
+
+// src/commands/notebook/index.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import chalk from "chalk";
+import * as yaml from "js-yaml";
+var GLOBAL_NOTEBOOKS_DIR = path.join(os.homedir(), ".paradigm", "notebooks");
+var PROJECT_NOTEBOOKS_DIR = ".paradigm/notebooks";
+var NOTEBOOK_PREFIX = "nb-";
+var NOTEBOOK_EXT = ".yaml";
+async function notebookListCommand(options = {}) {
+  const cwd = process.cwd();
+  const tracker = log.command("notebook-list").start("Listing notebook entries", { cwd });
+  const agentId = options.agent || "all";
+  const entries = loadEntries(cwd, agentId === "all" ? void 0 : agentId);
+  if (options.json) {
+    console.log(JSON.stringify({ count: entries.length, entries: entries.map(summarize) }, null, 2));
+    tracker.success(`Found ${entries.length} entries`);
+    return;
+  }
+  console.log(chalk.blue("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  console.log(chalk.blue("\u2502") + chalk.white.bold("  paradigm notebook list                           ") + chalk.blue("\u2502"));
+  console.log(chalk.blue("\u2502") + chalk.gray(`  Agent: ${agentId}`.padEnd(50)) + chalk.blue("\u2502"));
+  console.log(chalk.blue("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n"));
+  if (entries.length === 0) {
+    console.log(chalk.yellow("  No notebook entries found."));
+    console.log(chalk.gray("  Add entries via paradigm_notebook_add or paradigm_notebook_promote.\n"));
+    tracker.success("No entries found");
+    return;
+  }
+  for (const e of entries) {
+    const concepts = e.concepts.join(", ") || chalk.gray("none");
+    const applied = e.appliedCount > 0 ? chalk.green(`${e.appliedCount}x applied`) : chalk.gray("unused");
+    console.log(`  ${chalk.white.bold(e.id)}`);
+    console.log(`    ${chalk.gray(e.context.slice(0, 80))}`);
+    console.log(`    Concepts: ${concepts}  |  ${applied}  |  Confidence: ${(e.confidence * 100).toFixed(0)}%`);
+    console.log("");
+  }
+  tracker.success(`Listed ${entries.length} entries`);
+}
+async function notebookShowCommand(id, options = {}) {
+  const cwd = process.cwd();
+  const tracker = log.command("notebook-show").start(`Showing notebook ${id}`, { cwd });
+  const entries = loadEntries(cwd, options.agent);
+  const entry = entries.find((e) => e.id === id);
+  if (!entry) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: `Entry "${id}" not found` }));
+    } else {
+      console.log(chalk.red(`
+  Entry "${id}" not found.
+`));
+    }
+    tracker.error(`Entry ${id} not found`);
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(entry, null, 2));
+    tracker.success(`Showed entry ${id}`);
+    return;
+  }
+  console.log(chalk.blue(`
+  Notebook Entry: ${id}
+`));
+  console.log(`  ${chalk.white.bold("Context:")} ${entry.context}`);
+  console.log(`  ${chalk.white.bold("Concepts:")} ${entry.concepts.join(", ")}`);
+  console.log(`  ${chalk.white.bold("Tags:")} ${entry.tags.join(", ") || "(none)"}`);
+  console.log(`  ${chalk.white.bold("Confidence:")} ${(entry.confidence * 100).toFixed(0)}%`);
+  console.log(`  ${chalk.white.bold("Applied:")} ${entry.appliedCount} times`);
+  console.log(`  ${chalk.white.bold("Provenance:")} ${entry.provenance.source}${entry.provenance.loreEntryId ? ` (${entry.provenance.loreEntryId})` : ""}`);
+  console.log(`  ${chalk.white.bold("Created:")} ${entry.created}`);
+  console.log(`  ${chalk.white.bold("Updated:")} ${entry.updated}`);
+  console.log(`
+  ${chalk.white.bold("Snippet:")}`);
+  console.log(chalk.gray("  \u2500".repeat(25)));
+  for (const line of entry.snippet.split("\n")) {
+    console.log(`  ${line}`);
+  }
+  console.log(chalk.gray("  \u2500".repeat(25)));
+  console.log("");
+  tracker.success(`Showed entry ${id}`);
+}
+async function notebookExportCommand(options = {}) {
+  const cwd = process.cwd();
+  const tracker = log.command("notebook-export").start("Exporting notebook entries", { cwd });
+  const entries = loadEntries(cwd, options.agent);
+  const format = options.format || "yaml";
+  if (format === "json") {
+    console.log(JSON.stringify(entries, null, 2));
+  } else {
+    console.log(yaml.dump(entries, { lineWidth: 120, noRefs: true }));
+  }
+  tracker.success(`Exported ${entries.length} entries as ${format}`);
+}
+function loadEntries(rootDir, agentId) {
+  const entries = [];
+  const dirs = [];
+  if (agentId) {
+    dirs.push(path.join(GLOBAL_NOTEBOOKS_DIR, agentId));
+    dirs.push(path.join(rootDir, PROJECT_NOTEBOOKS_DIR, agentId));
+  } else {
+    for (const base of [GLOBAL_NOTEBOOKS_DIR, path.join(rootDir, PROJECT_NOTEBOOKS_DIR)]) {
+      if (fs.existsSync(base)) {
+        try {
+          const agentDirs = fs.readdirSync(base, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path.join(base, d.name));
+          dirs.push(...agentDirs);
+        } catch {
+        }
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) continue;
+    try {
+      const files = fs.readdirSync(dir).filter(
+        (f) => f.startsWith(NOTEBOOK_PREFIX) && f.endsWith(NOTEBOOK_EXT)
+      );
+      for (const file of files) {
+        try {
+          const content = fs.readFileSync(path.join(dir, file), "utf-8");
+          const entry = yaml.load(content);
+          if (entry?.id && !seen.has(entry.id)) {
+            seen.add(entry.id);
+            entries.push(entry);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return entries.sort((a, b) => b.appliedCount - a.appliedCount);
+}
+function summarize(e) {
+  return {
+    id: e.id,
+    context: e.context.slice(0, 100),
+    concepts: e.concepts,
+    appliedCount: e.appliedCount,
+    confidence: e.confidence,
+    provenance: e.provenance.source
+  };
+}
+export {
+  notebookExportCommand,
+  notebookListCommand,
+  notebookShowCommand
+};

package/dist/{orchestrate-A226N6FC.js → orchestrate-XZA33TJC.js}

@@ -2,15 +2,14 @@
 import {
   BackgroundOrchestrator,
   Orchestrator
-} from "./chunk-QWA26UNO.js";
-import "./chunk-J4E6K5MG.js";
+} from "./chunk-WQITYKHM.js";
+import "./chunk-LSRABQIY.js";
 import "./chunk-PBHIFAL4.js";
-import "./chunk-FS3WTUHY.js";
+import "./chunk-TXESEO7Y.js";
 import "./chunk-6QC3YGB6.js";
 import {
   loadAgentsManifest
 } from "./chunk-PMXRGPRQ.js";
-import "./chunk-MW5DMGBB.js";
 import {
   formatCost,
   formatTokens
@@ -18,7 +17,8 @@ import {
 import "./chunk-ZGUAAVMA.js";
 import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-YMDLDELF.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/team/orchestrate.ts
 import * as path from "path";

package/dist/{peers-RFQCWVLV.js → peers-DEOUIZM6.js}

@@ -4,7 +4,7 @@ import {
   loadPeers,
   revokePeer
 } from "./chunk-KVDYJLTC.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/symphony/peers.ts
 import chalk from "chalk";

package/dist/persona-UHAHIVST.js

@@ -0,0 +1,390 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/commands/persona/index.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import * as yaml from "js-yaml";
+function personasDir(rootDir) {
+  return path.join(rootDir, ".paradigm", "personas");
+}
+function loadAllPersonas(rootDir) {
+  const dir = personasDir(rootDir);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir).filter((f) => f.endsWith(".persona")).sort().map((f) => {
+    try {
+      const content = fs.readFileSync(path.join(dir, f), "utf8");
+      return yaml.load(content);
+    } catch {
+      return null;
+    }
+  }).filter((p) => p !== null && !!p.id);
+}
+function loadPersona(rootDir, id) {
+  const filePath = path.join(personasDir(rootDir), `${id}.persona`);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return yaml.load(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function loadIndex(rootDir) {
+  const indexPath = path.join(personasDir(rootDir), "index.yaml");
+  if (!fs.existsSync(indexPath)) return null;
+  try {
+    return yaml.load(fs.readFileSync(indexPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function personaListCommand(options) {
+  const cwd = process.cwd();
+  let personas = loadAllPersonas(cwd);
+  if (personas.length === 0) {
+    console.log(chalk.yellow("\n  No personas found. Create one with paradigm_persona_create.\n"));
+    return;
+  }
+  if (options.tag) {
+    personas = personas.filter((p) => p.tags?.includes(options.tag));
+  }
+  if (options.trigger) {
+    personas = personas.filter((p) => p.trigger.type === options.trigger);
+  }
+  if (options.gate) {
+    personas = personas.filter((p) => p.journey.some((s) => s.gates.includes(options.gate)));
+  }
+  if (options.json) {
+    console.log(JSON.stringify(personas.map((p) => ({
+      id: p.id,
+      name: p.name,
+      trigger: p.trigger.type,
+      steps: p.journey.length,
+      tags: p.tags || [],
+      gates: [...new Set(p.journey.flatMap((s) => s.gates))]
+    })), null, 2));
+    return;
+  }
+  console.log(chalk.blue(`
+  Personas (${personas.length})
+`));
+  for (const p of personas) {
+    const gates = [...new Set(p.journey.flatMap((s) => s.gates))];
+    const triggerColor = p.trigger.type === "root" ? chalk.green : chalk.cyan;
+    console.log(`  ${chalk.white.bold(p.id)} \u2014 ${p.name}`);
+    console.log(`    ${triggerColor(p.trigger.type)} trigger, ${p.journey.length} steps, ${gates.length} gates`);
+    if (p.tags?.length) {
+      console.log(`    ${chalk.gray(p.tags.map((t) => `[${t}]`).join(" "))}`);
+    }
+    if (p.description) {
+      console.log(`    ${chalk.gray(p.description)}`);
+    }
+    console.log();
+  }
+}
+async function personaShowCommand(id, options) {
+  const cwd = process.cwd();
+  const persona = loadPersona(cwd, id);
+  if (!persona) {
+    console.log(chalk.red(`Persona "${id}" not found.`));
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify(persona, null, 2));
+    return;
+  }
+  console.log(chalk.blue(`
+  Persona: ${chalk.white.bold(persona.name)}
+`));
+  console.log(`  ID:       ${persona.id}`);
+  console.log(`  Trigger:  ${persona.trigger.type}`);
+  if (persona.trigger.spawned_by) console.log(`  Spawned:  by ${persona.trigger.spawned_by}`);
+  if (persona.description) console.log(`  Desc:     ${persona.description}`);
+  if (persona.tags?.length) console.log(`  Tags:     ${persona.tags.join(", ")}`);
+  if (persona.traits && Object.keys(persona.traits).length) {
+    console.log(chalk.cyan("\n  Traits:"));
+    for (const [k, v] of Object.entries(persona.traits)) {
+      console.log(`    ${k}: ${chalk.white(String(v))}`);
+    }
+  }
+  if (persona.fixtures && Object.keys(persona.fixtures).length) {
+    console.log(chalk.cyan("\n  Fixtures:"));
+    for (const [k, v] of Object.entries(persona.fixtures)) {
+      console.log(`    ${k}: ${chalk.gray(v)}`);
+    }
+  }
+  console.log(chalk.cyan(`
+  Journey (${persona.journey.length} steps):`));
+  for (let i = 0; i < persona.journey.length; i++) {
+    const step = persona.journey[i];
+    const gateStr = step.gates.map((g) => chalk.yellow(g)).join(", ");
+    console.log(`    ${chalk.gray(`${i + 1}.`)} ${chalk.white(step.id)} \u2014 ${step.route}`);
+    console.log(`       Gates: ${gateStr}  Expect: ${step.expect.status}`);
+    if (step.flow) console.log(`       Flow: ${chalk.magenta(step.flow)}`);
+    if (step.produces) console.log(`       Produces: ${Object.keys(step.produces).join(", ")}`);
+    if (step.spawns?.length) console.log(`       Spawns: ${step.spawns.map((s) => s.persona).join(", ")}`);
+    if (step.signals?.length) console.log(`       Signals: ${step.signals.join(", ")}`);
+  }
+  console.log();
+}
+async function personaValidateCommand(id, options) {
+  const cwd = process.cwd();
+  const personas = id ? [loadPersona(cwd, id)].filter(Boolean) : loadAllPersonas(cwd);
+  if (personas.length === 0) {
+    console.log(chalk.yellow(id ? `Persona "${id}" not found.` : "No personas found."));
+    return;
+  }
+  let portalGates = [];
+  const portalPath = path.join(cwd, "portal.yaml");
+  if (fs.existsSync(portalPath)) {
+    try {
+      const portal = yaml.load(fs.readFileSync(portalPath, "utf8"));
+      portalGates = Object.keys(portal?.gates || {}).map((g) => g.startsWith("^") ? g : `^${g}`);
+    } catch {
+    }
+  }
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  const results = [];
+  for (const persona of personas) {
+    const errors = [];
+    const warnings = [];
+    if (!persona.id) errors.push("Missing required field: id");
+    if (!persona.name) errors.push("Missing required field: name");
+    if (!persona.journey || persona.journey.length === 0) errors.push("Journey must have at least 1 step");
+    const stepIds = /* @__PURE__ */ new Set();
+    for (const step of persona.journey || []) {
+      if (!step.id) errors.push("Step missing id");
+      if (stepIds.has(step.id)) errors.push(`Duplicate step id: ${step.id}`);
+      stepIds.add(step.id);
+      if (!step.route) errors.push(`Step ${step.id}: missing route`);
+      if (!step.gates || step.gates.length === 0) errors.push(`Step ${step.id}: gates[] required`);
+      if (!step.expect?.status) errors.push(`Step ${step.id}: expect.status required`);
+      if (portalGates.length > 0) {
+        for (const gate of step.gates || []) {
+          if (!portalGates.includes(gate)) {
+            warnings.push(`Step ${step.id}: gate ${gate} not in portal.yaml`);
+          }
+        }
+      }
+      for (const spawn of step.spawns || []) {
+        const target = loadPersona(cwd, spawn.persona);
+        if (!target) warnings.push(`Step ${step.id}: spawns ${spawn.persona} but that persona doesn't exist`);
+      }
+    }
+    totalErrors += errors.length;
+    totalWarnings += warnings.length;
+    results.push({ id: persona.id, errors, warnings });
+  }
+  if (options?.json) {
+    console.log(JSON.stringify({ results, totalErrors, totalWarnings }, null, 2));
+    return;
+  }
+  console.log(chalk.blue(`
+  Persona Validation (${personas.length} persona(s))
+`));
+  for (const r of results) {
+    if (r.errors.length === 0 && r.warnings.length === 0) {
+      console.log(`  ${chalk.green("\u2713")} ${r.id}`);
+    } else {
+      if (r.errors.length > 0) {
+        console.log(`  ${chalk.red("\u2717")} ${r.id} \u2014 ${r.errors.length} error(s)`);
+        for (const e of r.errors) console.log(`    ${chalk.red("\u2022")} ${e}`);
+      }
+      if (r.warnings.length > 0) {
+        console.log(`  ${chalk.yellow("\u26A0")} ${r.id} \u2014 ${r.warnings.length} warning(s)`);
+        for (const w of r.warnings) console.log(`    ${chalk.yellow("\u2022")} ${w}`);
+      }
+    }
+  }
+  console.log();
+  if (totalErrors === 0 && totalWarnings === 0) {
+    console.log(chalk.green("  All personas valid."));
+  } else {
+    console.log(`  ${chalk.red(`${totalErrors} error(s)`)}, ${chalk.yellow(`${totalWarnings} warning(s)`)}`);
+  }
+  console.log();
+}
+async function personaCoverageCommand(options) {
+  const cwd = process.cwd();
+  const index = loadIndex(cwd);
+  if (!index) {
+    console.log(chalk.yellow("\n  No persona index found. Run paradigm_reindex first.\n"));
+    return;
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      gate_coverage: index.gate_coverage || {},
+      route_coverage: index.route_coverage || {},
+      uncovered_routes: index.uncovered_routes || []
+    }, null, 2));
+    return;
+  }
+  console.log(chalk.blue("\n  Persona Coverage Report\n"));
+  const gateCov = index.gate_coverage || {};
+  if (Object.keys(gateCov).length > 0) {
+    console.log(chalk.cyan("  Gate Coverage:"));
+    for (const [gate, personas] of Object.entries(gateCov)) {
+      console.log(`    ${chalk.yellow(gate)} \u2014 ${personas.join(", ")}`);
+    }
+    console.log();
+  }
+  const routeCov = index.route_coverage || {};
+  if (Object.keys(routeCov).length > 0) {
+    console.log(chalk.cyan("  Route Coverage:"));
+    for (const [route, personas] of Object.entries(routeCov)) {
+      console.log(`    ${chalk.white(route)} \u2014 ${personas.join(", ")}`);
+    }
+    console.log();
+  }
+  const uncovered = index.uncovered_routes || [];
+  if (uncovered.length > 0) {
+    console.log(chalk.red(`  Uncovered Routes (${uncovered.length}):`));
+    for (const route of uncovered) {
+      console.log(`    ${chalk.red("\u2022")} ${route}`);
+    }
+    console.log();
+  } else {
+    console.log(chalk.green("  All portal.yaml routes have persona coverage."));
+    console.log();
+  }
+}
+async function personaRunCommand(id, options) {
+  const cwd = process.cwd();
+  const persona = loadPersona(cwd, id);
+  if (!persona) {
+    console.log(chalk.red(`Persona "${id}" not found.`));
+    return;
+  }
+  if (options.dryRun) {
+    console.log(chalk.blue(`
+  Dry Run: ${persona.name}
+`));
+    for (let i = 0; i < persona.journey.length; i++) {
+      const step = persona.journey[i];
+      console.log(`  ${chalk.gray(`${i + 1}.`)} ${step.route}`);
+      console.log(`     Gates: ${step.gates.join(", ")}`);
+      console.log(`     Expect: ${step.expect.status}`);
+      if (step.produces) console.log(`     Produces: ${Object.keys(step.produces).join(", ")}`);
+    }
+    console.log(chalk.gray("\n  (dry run \u2014 no HTTP requests made)\n"));
+    return;
+  }
+  console.log(chalk.blue(`
+  Running: ${persona.name} \u2192 ${options.baseUrl}
+`));
+  const scope = {
+    fixtures: persona.fixtures || {},
+    produces: {},
+    context: persona.trigger.context || {},
+    env: process.env
+  };
+  let passed = 0;
+  let failed = 0;
+  for (const step of persona.journey) {
+    const url = `${options.baseUrl}${step.route.split(" ").pop()}`;
+    const method = step.route.split(" ")[0];
+    let payload;
+    if (step.payload) {
+      payload = JSON.stringify(step.payload).replace(/\{\{(\w+)\.(\w+)\}\}/g, (_, ns, key) => {
+        const nsObj = scope[ns];
+        return nsObj?.[key] !== void 0 ? String(nsObj[key]) : `{{${ns}.${key}}}`;
+      });
+    }
+    process.stdout.write(`  ${chalk.gray(`${step.id}:`)} ${method} ${url} ... `);
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        ...step.headers || {}
+      };
+      const res = await fetch(url, {
+        method,
+        headers,
+        body: payload
+      });
+      if (res.status === step.expect.status) {
+        console.log(chalk.green(`${res.status} \u2713`));
+        passed++;
+        if (step.produces) {
+          try {
+            const body = await res.json();
+            for (const [key, jsonPath] of Object.entries(step.produces)) {
+              const value = jsonPath.split(".").reduce((obj, k) => obj?.[k], body);
+              scope.produces[key] = value;
+            }
+          } catch {
+          }
+        }
+      } else {
+        console.log(chalk.red(`${res.status} \u2717 (expected ${step.expect.status})`));
+        failed++;
+      }
+    } catch (err) {
+      console.log(chalk.red(`ERROR: ${err.message}`));
+      failed++;
+    }
+  }
+  console.log();
+  console.log(`  ${chalk.green(`${passed} passed`)}, ${failed > 0 ? chalk.red(`${failed} failed`) : chalk.green("0 failed")}`);
+  console.log();
+}
+async function personaAffectedCommand(symbol, options) {
+  const cwd = process.cwd();
+  const personas = loadAllPersonas(cwd);
+  const affected = [];
+  for (const p of personas) {
+    const matchingSteps = p.journey.filter(
+      (s) => s.gates.includes(symbol) || s.flow === symbol || s.signals?.includes(symbol)
+    );
+    if (matchingSteps.length > 0) {
+      affected.push({ id: p.id, name: p.name, steps: matchingSteps.map((s) => s.id) });
+    }
+  }
+  if (options.json) {
+    console.log(JSON.stringify({ symbol, affected }, null, 2));
+    return;
+  }
+  if (affected.length === 0) {
+    console.log(chalk.gray(`
+  No personas reference ${symbol}.
+`));
+    return;
+  }
+  console.log(chalk.blue(`
+  Personas affected by ${chalk.yellow(symbol)}:
+`));
+  for (const a of affected) {
+    console.log(`  ${chalk.white.bold(a.id)} \u2014 ${a.name}`);
+    console.log(`    Steps: ${a.steps.join(", ")}`);
+  }
+  console.log();
+}
+async function personaDeleteCommand(id) {
+  const cwd = process.cwd();
+  const filePath = path.join(personasDir(cwd), `${id}.persona`);
+  if (!fs.existsSync(filePath)) {
+    console.log(chalk.red(`Persona "${id}" not found.`));
+    return;
+  }
+  const allPersonas = loadAllPersonas(cwd);
+  const referencedBy = allPersonas.filter(
+    (p) => p.id !== id && p.journey.some((s) => s.spawns?.some((sp) => sp.persona === id))
+  );
+  if (referencedBy.length > 0) {
+    console.log(chalk.yellow(`
+  Warning: ${id} is spawned by: ${referencedBy.map((p) => p.id).join(", ")}`));
+    console.log(chalk.yellow("  Deleting it will break their spawn chains.\n"));
+  }
+  fs.unlinkSync(filePath);
+  console.log(chalk.green(`  Deleted persona "${id}".`));
+}
+export {
+  personaAffectedCommand,
+  personaCoverageCommand,
+  personaDeleteCommand,
+  personaListCommand,
+  personaRunCommand,
+  personaShowCommand,
+  personaValidateCommand
+};

package/dist/{pipeline-3G2FRAKM.js → pipeline-L4HCSBGN.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/pipeline/index.ts
 import chalk from "chalk";