@topce/pizx 0.1.0 → 0.4.0

package/dist/cli.js

@@ -11,6 +11,11 @@ import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:f
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
 
+// src/utils.ts
+function getErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
 // src/load-pi-settings.ts
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -88,46 +93,21 @@ function loadPiAuth() {
         }
       }
     } catch (err) {
-      console.warn(`pizx: failed to parse ${path}: ${err instanceof Error ? err.message : err}`);
+      console.warn(`pizx: failed to parse ${path}: ${getErrorMessage(err)}`);
     }
   }
 }
 
 // src/patterns/types.ts
-import { completeSimple, getEnvApiKey, getModels, getProviders } from "@earendil-works/pi-ai";
-var PatternOutput = class {
-  constructor(text, startTime = Date.now(), endTime = Date.now()) {
-    this.text = text;
-    this.startTime = startTime;
-    this.endTime = endTime;
-  }
-  text;
-  startTime;
-  endTime;
-  /** Duration in milliseconds */
-  get duration() {
-    return this.endTime - this.startTime;
-  }
-  toString() {
-    return this.text;
-  }
-  valueOf() {
-    return this.text;
-  }
-  [Symbol.toPrimitive]() {
-    return this.text;
-  }
-};
-var PatternPromise = class extends Promise {
-};
-function build(pieces, args) {
-  let s = "";
-  for (let i = 0; i < pieces.length; i++) {
-    s += pieces[i];
-    if (i < args.length) s += String(args[i]);
-  }
-  return s.trim();
-}
+import { createInterface } from "node:readline";
+import { completeSimple } from "@earendil-works/pi-ai";
+
+// src/model-picker.ts
+import {
+  getEnvApiKey,
+  getModels,
+  getProviders
+} from "@earendil-works/pi-ai";
 var _piSettings;
 function getPiDefaults() {
   if (_piSettings === void 0) {
@@ -171,7 +151,8 @@ function pickModel(preferred) {
     if (hit) return hit;
   }
   if (settings.defaultProvider) {
-    const providerModels = getModels(settings.defaultProvider);
+    const provider = settings.defaultProvider;
+    const providerModels = getModels(provider);
     if (providerModels && providerModels.length > 0) {
       const configured = new Set(getConfiguredProviders());
       if (configured.has(settings.defaultProvider)) {
@@ -197,23 +178,261 @@ function pickModel(preferred) {
   }
   return models[0];
 }
+
+// src/skill-loader.ts
+import { readFile } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+var SKILL_PATHS = [
+  ".pi/skills",
+  ".agents/skills",
+  "skills",
+  join3(homedir3(), ".pi", "agent", "skills"),
+  join3(homedir3(), ".codewhale", "skills"),
+  join3(homedir3(), ".claude", "skills")
+];
+async function loadSkillContent(name) {
+  for (const base of SKILL_PATHS) {
+    const candidate = join3(base, name, "SKILL.md");
+    try {
+      return await readFile(candidate, "utf-8");
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function loadSkillContents(names) {
+  const map = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const content = await loadSkillContent(name);
+    if (content) map.set(name, content);
+  }
+  return map;
+}
+
+// src/patterns/types.ts
+var PatternOutput = class {
+  constructor(text, startTime = Date.now(), endTime = Date.now()) {
+    this.text = text;
+    this.startTime = startTime;
+    this.endTime = endTime;
+  }
+  text;
+  startTime;
+  endTime;
+  /** Execution trace: one entry per LLM call within this pattern run. Populated by createPatternTag. */
+  trace = [];
+  /** Structured phase log: key phases during execution, populated by each pattern. */
+  phaseLog = [];
+  /** Duration in milliseconds */
+  get duration() {
+    return this.endTime - this.startTime;
+  }
+  /** Total input tokens across all calls */
+  get inputTokens() {
+    return this.trace.reduce((s, t) => s + t.inputTokens, 0);
+  }
+  /** Total output tokens across all calls */
+  get outputTokens() {
+    return this.trace.reduce((s, t) => s + t.outputTokens, 0);
+  }
+  /** Total tokens (input + output) across all calls */
+  get totalTokens() {
+    return this.trace.reduce((s, t) => s + t.totalTokens, 0);
+  }
+  /** Total cost in USD across all calls */
+  get totalCost() {
+    return this.trace.reduce((s, t) => s + t.cost, 0);
+  }
+  /** Number of LLM calls made during this pattern execution */
+  get callCount() {
+    return this.trace.length;
+  }
+  toString() {
+    return this.text;
+  }
+  valueOf() {
+    return this.text;
+  }
+  [Symbol.toPrimitive]() {
+    return this.text;
+  }
+};
+var PatternPromise = class extends Promise {
+};
+var _trace = null;
+function beginTrace() {
+  _trace = [];
+}
+function collectTrace() {
+  const t = _trace ?? [];
+  _trace = null;
+  return t;
+}
+function pushTrace(entry) {
+  if (_trace) _trace.push(entry);
+}
+function createPatternTag(defaults17, execute17) {
+  function make(opts = {}) {
+    const merged = { ...defaults17, ...opts };
+    const fn = ((pieces, ...args) => {
+      if (!Array.isArray(pieces)) {
+        return make({ ...merged, ...pieces });
+      }
+      beginTrace();
+      return new PatternPromise((resolve, reject) => {
+        execute17(pieces, args, merged).then(
+          (output) => {
+            output.trace = collectTrace();
+            resolve(output);
+          },
+          (err) => {
+            collectTrace();
+            reject(err);
+          }
+        );
+      });
+    });
+    let _quiet;
+    Object.defineProperty(fn, "quiet", {
+      get() {
+        if (!_quiet) _quiet = make({ ...merged, quiet: true });
+        return _quiet;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    return fn;
+  }
+  return make();
+}
+function build(pieces, args) {
+  let s = "";
+  for (let i = 0; i < pieces.length; i++) {
+    s += pieces[i];
+    if (i < args.length) s += String(args[i]);
+  }
+  return s.trim();
+}
+function mergeSystem(userSystem, patternSystem) {
+  if (!userSystem) return patternSystem;
+  return `${userSystem}
+
+${patternSystem}`;
+}
+async function confirmPhase(description, opts) {
+  if (!opts.confirm) return true;
+  if (!opts.quiet) {
+    process.stderr.write(`
+  \u2500\u2500 Confirm \u2500\u2500
+  ${description}
+  Proceed? [Y/n] `);
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  const answer = await new Promise((resolve) => {
+    rl.question("", (ans) => resolve(ans));
+  });
+  rl.close();
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === "" || trimmed === "y" || trimmed === "yes") return true;
+  return false;
+}
 async function ask(prompt, opts = {}) {
   const model = pickModel(opts.model);
   if (!model) throw new Error("pizx/patterns: No AI models configured. Run `pi auth login` first.");
+  let systemPrompt = opts.system;
+  if (opts.skills && opts.skills.length > 0) {
+    const skillMap = await loadSkillContents(opts.skills);
+    if (skillMap.size > 0) {
+      const skillBlocks = [];
+      for (const [name, content] of skillMap) {
+        skillBlocks.push(`Skill context (${name}):
+${content}`);
+      }
+      const skillContext = skillBlocks.join("\n\n");
+      systemPrompt = systemPrompt ? `${systemPrompt}
+
+${skillContext}` : skillContext;
+    }
+  }
+  const t0 = Date.now();
   const result = await completeSimple(
     model,
     {
-      systemPrompt: opts.system,
+      systemPrompt,
       messages: [{ role: "user", content: prompt, timestamp: Date.now() }]
     },
     {
       maxTokens: opts.maxTokens ?? 4096,
-      reasoning: opts.thinkingLevel ?? "medium"
+      reasoning: opts.thinkingLevel ?? "medium",
+      thinkingBudgets: opts.thinkingBudgets,
+      timeoutMs: opts.timeoutMs,
+      maxRetries: opts.maxRetries
     }
   );
+  const durationMs = Date.now() - t0;
+  if (!result.content || !Array.isArray(result.content)) {
+    throw new Error("pizx/patterns: Unexpected response format from AI model.");
+  }
   const text = result.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+  if (_trace !== null) {
+    pushTrace({
+      call: _trace.length + 1,
+      modelId: result.model,
+      promptPreview: prompt.slice(0, 200),
+      outputPreview: text.slice(0, 200),
+      inputTokens: result.usage.input,
+      outputTokens: result.usage.output,
+      cacheReadTokens: result.usage.cacheRead,
+      cacheWriteTokens: result.usage.cacheWrite,
+      totalTokens: result.usage.totalTokens,
+      cost: result.usage.cost.total,
+      durationMs
+    });
+  }
   return text.trim();
 }
+var QUALITY_REVIEW_SYSTEM = `You are a quality assurance reviewer. Evaluate the final deliverable against the original request.
+
+Output format:
+SCORE: 0.XX (quality score from 0.0 to 1.0)
+ASSESSMENT: (1-2 sentences \u2014 is the output complete, consistent, and actionable?)
+RECOMMENDATION: (1 sentence \u2014 what would improve this output?)`;
+async function runQualityReview(originalRequest, finalOutput, opts) {
+  if (!opts.qualityCheck) return void 0;
+  const reviewText = await ask(
+    `Original request:
+${originalRequest}
+
+Final deliverable:
+${finalOutput}
+
+Evaluate the quality.`,
+    {
+      model: opts.plannerModel ?? opts.model,
+      maxTokens: 512,
+      thinkingLevel: "high",
+      timeoutMs: opts.timeoutMs,
+      maxRetries: opts.maxRetries,
+      system: QUALITY_REVIEW_SYSTEM
+    }
+  );
+  const scoreMatch = reviewText.match(/SCORE:\s*([\d.]+)/i);
+  const assessMatch = reviewText.match(/ASSESSMENT:\s*(.+)/i);
+  const recMatch = reviewText.match(/RECOMMENDATION:\s*(.+)/i);
+  const result = {
+    score: scoreMatch ? parseFloat(scoreMatch[1]) : 0.5,
+    assessment: assessMatch?.[1]?.trim() ?? "(no assessment)",
+    recommendation: recMatch?.[1]?.trim() ?? "(no recommendation)"
+  };
+  if (!opts.quiet) {
+    process.stderr.write(`      Quality score: ${result.score.toFixed(2)}
+`);
+    process.stderr.write(`      ${result.assessment.slice(0, 80)}...
+`);
+  }
+  return result;
+}
 
 // src/patterns/adaptive.ts
 var defaults = {
@@ -277,10 +496,10 @@ async function execute(pieces, args, opts) {
   }
   if (!opts.quiet) process.stderr.write("  \u2192 Planning...\n");
   const planText = await ask(goal, {
+    ...opts,
     model: plannerModel,
-    maxTokens: opts.maxTokens,
     thinkingLevel: "high",
-    system: PLAN_SYSTEM
+    system: mergeSystem(opts.system, PLAN_SYSTEM)
   });
   const planLines = planText.split("\n");
   const plannedSteps = [];
@@ -310,10 +529,9 @@ async function execute(pieces, args, opts) {
       process.stderr.write(`  \u2192 Step ${executionStep}: ${currentStep.slice(0, 60)}...
 `);
     const result = await ask(currentStep, {
+      ...opts,
       model: workerModel,
-      maxTokens: opts.maxTokens,
-      thinkingLevel: opts.thinkingLevel,
-      system: EXECUTE_SYSTEM
+      system: mergeSystem(opts.system, EXECUTE_SYSTEM)
     });
     const evaluation = await ask(
       `Goal: ${goal}
@@ -322,10 +540,11 @@ Result: ${result}
 
 Evaluate the result.`,
       {
+        ...opts,
         model: plannerModel,
         maxTokens: 512,
         thinkingLevel: "high",
-        system: EVALUATE_SYSTEM
+        system: mergeSystem(opts.system, EVALUATE_SYSTEM)
       }
     );
     const scoreMatch = evaluation.match(/SCORE:\s*([\d.]+)/i);
@@ -348,8 +567,7 @@ Evaluate the result.`,
       break;
     }
     const adaptUpper = adaptation.toUpperCase();
-    if (adaptUpper.startsWith("REFINE")) {
-    } else if (adaptUpper.startsWith("SKIP_NEXT")) {
+    if (adaptUpper.startsWith("SKIP_NEXT")) {
       stepIndex += 2;
     } else if (adaptUpper.startsWith("ADD")) {
       const newStep = adaptation.replace(/^ADD\s*/i, "");
@@ -368,36 +586,76 @@ Evaluate the result.`,
   ).join("\n\n");
   return new AdaptiveOutput(summary, finalResult, adaptiveSteps, executionStep, t0, t1);
 }
-function makeAdaptive(opts = {}) {
-  const merged = { ...defaults, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeAdaptive({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeAdaptive({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
-}
-var \u0391 = makeAdaptive();
+var \u0391 = createPatternTag(defaults, execute);
 
-// src/patterns/broadcast.ts
-var defaults2 = {
-  maxTokens: 4096,
-  thinkingLevel: "medium",
-  workers: 4
+// src/patterns/role-sets.ts
+var DEBATE_ROLE_SETS = {
+  2: [
+    "Optimist \u2014 advocate for the most ambitious approach",
+    "Pessimist \u2014 identify risks and failure modes"
+  ],
+  3: [
+    "Optimist \u2014 advocate the benefits and opportunities",
+    "Pessimist \u2014 identify risks, costs, and failure modes",
+    "Pragmatist \u2014 focus on practical trade-offs and implementation"
+  ],
+  4: [
+    "Optimist \u2014 argue for the best-case potential",
+    "Pessimist \u2014 highlight worst-case risks and downsides",
+    "Pragmatist \u2014 balance pros/cons with practical constraints",
+    "Innovator \u2014 propose creative alternatives and novel approaches"
+  ],
+  5: [
+    "Optimist",
+    "Pessimist",
+    "Pragmatist",
+    "Innovator",
+    "User Advocate \u2014 focus on end-user experience and accessibility"
+  ]
+};
+var MEMORY_ROLE_SETS = {
+  2: ["Analyst \u2014 deep analysis of core aspects", "Reviewer \u2014 check for gaps and blind spots"],
+  3: [
+    "Analyst \u2014 deep analysis of core aspects",
+    "Reviewer \u2014 check for gaps, edge cases, and blind spots",
+    "Strategist \u2014 connect findings to actionable insights"
+  ],
+  4: [
+    "Analyst",
+    "Reviewer",
+    "Strategist",
+    "Innovator \u2014 propose novel angles and creative solutions"
+  ],
+  5: [
+    "Analyst",
+    "Reviewer",
+    "Strategist",
+    "Innovator",
+    "Skeptic \u2014 challenge assumptions and stress-test conclusions"
+  ]
 };
-var ROLE_SETS = {
+var THREAD_ROLE_SETS = {
+  2: ["Proposer \u2014 advocate the best approach", "Critic \u2014 identify weaknesses and gaps"],
+  3: [
+    "Proposer \u2014 suggest the best approach",
+    "Critic \u2014 identify weaknesses, risks, and missing pieces",
+    "Synthesizer \u2014 combine the best ideas into a practical plan"
+  ],
+  4: [
+    "Proposer \u2014 advocate a bold solution",
+    "Critic \u2014 identify risks and weaknesses",
+    "Pragmatist \u2014 focus on practical implementation",
+    "Innovator \u2014 propose creative alternatives"
+  ],
+  5: [
+    "Proposer",
+    "Critic",
+    "Pragmatist",
+    "Innovator",
+    "Devil's Advocate \u2014 challenge every assumption"
+  ]
+};
+var BROADCAST_ROLE_SETS = {
   2: [
     "Technical Expert \u2014 evaluate technical feasibility",
     "Business Expert \u2014 evaluate business viability"
@@ -421,6 +679,13 @@ var ROLE_SETS = {
     "Innovation Expert \u2014 suggest novel approaches and alternatives"
   ]
 };
+
+// src/patterns/broadcast.ts
+var defaults2 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  workers: 4
+};
 var BroadcastResponse = class {
   constructor(role, response, success, error) {
     this.role = role;
@@ -434,13 +699,15 @@ var BroadcastResponse = class {
   error;
 };
 var BroadcastOutput = class extends PatternOutput {
-  constructor(text, synthesis, responses, startTime, endTime) {
+  constructor(text, synthesis, responses, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.synthesis = synthesis;
     this.responses = responses;
+    this.qualityReview = qualityReview;
   }
   synthesis;
   responses;
+  qualityReview;
 };
 var WORKER_PROMPT = `You are a {role}.
 
@@ -455,7 +722,7 @@ async function execute2(pieces, args, opts) {
   const question = build(pieces, args);
   const t0 = Date.now();
   const workerCount = opts.workers ?? 4;
-  const roles = opts.roles ?? ROLE_SETS[workerCount] ?? ROLE_SETS[4] ?? [];
+  const roles = opts.roles ?? BROADCAST_ROLE_SETS[workerCount] ?? BROADCAST_ROLE_SETS[4] ?? [];
   const plannerModel = opts.plannerModel ?? opts.model;
   const workerModel = opts.workerModel ?? opts.model;
   if (!opts.quiet) {
@@ -470,11 +737,7 @@ async function execute2(pieces, args, opts) {
   const broadcastResults = await Promise.allSettled(
     roles.map(async (role) => {
       const prompt = WORKER_PROMPT.replace("{role}", role).replace("{question}", question);
-      const text = await ask(prompt, {
-        model: workerModel,
-        maxTokens: opts.maxTokens,
-        thinkingLevel: opts.thinkingLevel
-      });
+      const text = await ask(prompt, { ...opts, model: workerModel });
       return new BroadcastResponse(role, text, true);
     })
   );
@@ -499,40 +762,21 @@ ${responsesText}
 
 Synthesize a cohesive, actionable recommendation.`,
     {
+      ...opts,
       model: plannerModel,
-      maxTokens: opts.maxTokens,
       thinkingLevel: "high",
-      system: SYNTHESIS_SYSTEM
+      system: mergeSystem(opts.system, SYNTHESIS_SYSTEM)
     }
   );
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityReview = await runQualityReview(question, synthesis, opts);
   const t1 = Date.now();
   const summary = responses.map(
     (wr) => `[${wr.role}]: ${wr.response.slice(0, 150)}${wr.response.length > 150 ? "..." : ""}`
   ).join("\n");
-  return new BroadcastOutput(summary, synthesis, responses, t0, t1);
-}
-function makeBroadcast(opts = {}) {
-  const merged = { ...defaults2, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeBroadcast({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute2(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeBroadcast({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+  return new BroadcastOutput(summary, synthesis, responses, t0, t1, qualityReview);
 }
-var \u0392 = makeBroadcast();
+var \u0392 = createPatternTag(defaults2, execute2);
 
 // src/patterns/chi.ts
 var defaults3 = {
@@ -552,15 +796,17 @@ var LearningInsight = class {
   confidence;
 };
 var ChiOutput = class extends PatternOutput {
-  constructor(text, insights, summary, suggestedChanges, startTime, endTime) {
+  constructor(text, insights, summary, suggestedChanges, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.insights = insights;
     this.summary = summary;
     this.suggestedChanges = suggestedChanges;
+    this.qualityReview = qualityReview;
   }
   insights;
   summary;
   suggestedChanges;
+  qualityReview;
 };
 var ANALYSIS_SYSTEM = `You are an agent team performance analyst. Review a multi-agent execution and extract structured learnings.
 
@@ -629,12 +875,13 @@ async function execute3(pieces, args, opts) {
 `);
   }
   const response = await ask(input, {
+    ...opts,
     model: plannerModel,
-    maxTokens: opts.maxTokens,
-    thinkingLevel: opts.thinkingLevel,
-    system: ANALYSIS_SYSTEM
+    system: mergeSystem(opts.system, ANALYSIS_SYSTEM)
   });
   const { insights, summary, suggestedChanges } = parseInsights(response);
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityReview = await runQualityReview(input, response, opts);
   const t1 = Date.now();
   const text = [
     `Insights: ${insights.length} extracted`,
@@ -646,30 +893,9 @@ Summary: ${summary}`,
     `
 Changes: ${suggestedChanges}`
   ].join("\n");
-  return new ChiOutput(text, insights, summary, suggestedChanges, t0, t1);
-}
-function makeChi(opts = {}) {
-  const merged = { ...defaults3, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeChi({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute3(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeChi({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+  return new ChiOutput(text, insights, summary, suggestedChanges, t0, t1, qualityReview);
 }
-var \u03A7 = makeChi();
+var \u03A7 = createPatternTag(defaults3, execute3);
 
 // src/patterns/critique.ts
 var defaults4 = {
@@ -724,12 +950,7 @@ async function execute4(pieces, args, opts) {
   for (let r = 0; r < rounds; r++) {
     if (r === 0) {
       if (!opts.quiet) process.stderr.write("  \u2192 Generating initial content...\n");
-      currentContent = await ask(prompt, {
-        model: workerModel,
-        maxTokens: opts.maxTokens,
-        thinkingLevel: opts.thinkingLevel,
-        system: void 0
-      });
+      currentContent = await ask(prompt, { ...opts, model: workerModel, system: opts.system });
     } else {
       if (!opts.quiet) process.stderr.write(`  \u2192 Improving (round ${r + 1})...
 `);
@@ -744,21 +965,15 @@ Content to improve:
 ${currentContent}
 
 Revise the content based on the critique.`,
-        {
-          model: workerModel,
-          maxTokens: opts.maxTokens,
-          thinkingLevel: opts.thinkingLevel,
-          system: IMPROVE_SYSTEM
-        }
+        { ...opts, model: workerModel, system: mergeSystem(opts.system, IMPROVE_SYSTEM) }
       );
     }
     if (!opts.quiet) process.stderr.write(`  \u2192 Critiquing (round ${r + 1})...
 `);
     const critique = await ask(currentContent, {
+      ...opts,
       model: plannerModel,
-      maxTokens: opts.maxTokens,
-      thinkingLevel: opts.thinkingLevel,
-      system: CRITIQUE_SYSTEM
+      system: mergeSystem(opts.system, CRITIQUE_SYSTEM)
     });
     critiqueRounds.push(new CritiqueRound(currentContent, critique, r));
   }
@@ -771,28 +986,7 @@ Critique: ${cr.critique.slice(0, 200)}${cr.critique.length > 200 ? "..." : ""}`
   ).join("\n\n");
   return new CritiqueOutput(summary, finalContent, critiqueRounds, t0, t1);
 }
-function makeCritique(opts = {}) {
-  const merged = { ...defaults4, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeCritique({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute4(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeCritique({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
-}
-var \u03A8 = makeCritique();
+var \u03A8 = createPatternTag(defaults4, execute4);
 
 // src/patterns/debate.ts
 var defaults5 = {
@@ -801,30 +995,6 @@ var defaults5 = {
   perspectives: 3,
   rounds: 1
 };
-var ROLE_SETS2 = {
-  2: [
-    "Optimist \u2014 advocate for the most ambitious approach",
-    "Pessimist \u2014 identify risks and failure modes"
-  ],
-  3: [
-    "Optimist \u2014 advocate the benefits and opportunities",
-    "Pessimist \u2014 identify risks, costs, and failure modes",
-    "Pragmatist \u2014 focus on practical trade-offs and implementation"
-  ],
-  4: [
-    "Optimist \u2014 argue for the best-case potential",
-    "Pessimist \u2014 highlight worst-case risks and downsides",
-    "Pragmatist \u2014 balance pros/cons with practical constraints",
-    "Innovator \u2014 propose creative alternatives and novel approaches"
-  ],
-  5: [
-    "Optimist",
-    "Pessimist",
-    "Pragmatist",
-    "Innovator",
-    "User Advocate \u2014 focus on end-user experience and accessibility"
-  ]
-};
 var DebatePerspective = class {
   constructor(role, argument, round = 1) {
     this.role = role;
@@ -836,15 +1006,17 @@ var DebatePerspective = class {
   round;
 };
 var DebateOutput = class extends PatternOutput {
-  constructor(text, conclusion, perspectives, rounds, startTime, endTime) {
+  constructor(text, conclusion, perspectives, rounds, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.conclusion = conclusion;
     this.perspectives = perspectives;
     this.rounds = rounds;
+    this.qualityReview = qualityReview;
   }
   conclusion;
   perspectives;
   rounds;
+  qualityReview;
 };
 var PERSPECTIVE_SYSTEM = (role) => `You are a debater with the role: ${role}. Analyze the question from your perspective. Be thorough and specific. Provide evidence and reasoning for your position.`;
 var REBUTTAL_SYSTEM = (role) => `You are a debater with the role: ${role}. Review the debate so far \u2014 including arguments from all other perspectives \u2014 and refine your position. Address counter-arguments directly. Challenge weak points in opposing views. Strengthen your original position with rebuttals. Be specific and responsive.`;
@@ -854,7 +1026,7 @@ async function execute5(pieces, args, opts) {
   const t0 = Date.now();
   const count = opts.perspectives ?? 3;
   const totalRounds = opts.rounds ?? 1;
-  const roles = opts.roles ?? ROLE_SETS2[count] ?? ROLE_SETS2[3] ?? [];
+  const roles = opts.roles ?? DEBATE_ROLE_SETS[count] ?? DEBATE_ROLE_SETS[3] ?? [];
   const plannerModel = opts.plannerModel ?? opts.model;
   const workerModel = opts.workerModel ?? opts.model;
   if (!opts.quiet) {
@@ -872,10 +1044,9 @@ async function execute5(pieces, args, opts) {
   const round1Results = await Promise.allSettled(
     roles.map(
       (role) => ask(question, {
+        ...opts,
         model: workerModel,
-        maxTokens: opts.maxTokens,
-        thinkingLevel: opts.thinkingLevel,
-        system: PERSPECTIVE_SYSTEM(role)
+        system: mergeSystem(opts.system, PERSPECTIVE_SYSTEM(role))
       }).then((text) => new DebatePerspective(role, text, 1))
     )
   );
@@ -909,10 +1080,9 @@ ${othersText}
 
 Refine your position. Address the counter-arguments directly. Strengthen your argument with rebuttals.`;
         return ask(prompt, {
+          ...opts,
           model: workerModel,
-          maxTokens: opts.maxTokens,
-          thinkingLevel: opts.thinkingLevel,
-          system: REBUTTAL_SYSTEM(role)
+          system: mergeSystem(opts.system, REBUTTAL_SYSTEM(role))
         }).then((text) => new DebatePerspective(role, text, round));
       })
     );
@@ -936,37 +1106,26 @@ Refine your position. Address the counter-arguments directly. Strengthen your ar
 
 Synthesize a balanced conclusion from the full debate above. Weigh the evidence from all rounds.`,
     {
+      ...opts,
       model: plannerModel,
-      maxTokens: opts.maxTokens,
       thinkingLevel: "high",
-      system: SYNTHESIS_SYSTEM2
+      system: mergeSystem(opts.system, SYNTHESIS_SYSTEM2)
     }
   );
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityReview = await runQualityReview(question, conclusion, opts);
   const t1 = Date.now();
-  return new DebateOutput(conclusion, conclusion, allPerspectives, totalRounds, t0, t1);
-}
-function makeDebate(opts = {}) {
-  const merged = { ...defaults5, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeDebate({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute5(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeDebate({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+  return new DebateOutput(
+    conclusion,
+    conclusion,
+    allPerspectives,
+    totalRounds,
+    t0,
+    t1,
+    qualityReview
+  );
 }
-var \u0394 = makeDebate();
+var \u0394 = createPatternTag(defaults5, execute5);
 
 // src/patterns/fleet.ts
 var defaults6 = {
@@ -987,11 +1146,13 @@ var FleetMemberOutput = class {
   error;
 };
 var FleetOutput = class extends PatternOutput {
-  constructor(text, members, startTime, endTime) {
+  constructor(text, members, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.members = members;
+    this.qualityReview = qualityReview;
   }
   members;
+  qualityReview;
   /** Number of successful members */
   get successCount() {
     return this.members.filter((m) => m.success).length;
@@ -1011,20 +1172,30 @@ function parseTasks(template, explicitTasks) {
   if (lines.length > 1) return lines;
   return [template];
 }
+function describeTask(task) {
+  if (typeof task === "function") return "(composed pattern)";
+  return task;
+}
 var FLEET_SYSTEM = `You are a focused task specialist. Complete the assigned task concisely and accurately. Output only the result \u2014 no commentary about being an AI.`;
 async function executeTask(task, opts, workerModel) {
+  if (typeof task === "function") {
+    try {
+      const text = await task("");
+      return new FleetMemberOutput("(composed pattern)", text, true);
+    } catch (err) {
+      return new FleetMemberOutput("(composed pattern)", "", false, getErrorMessage(err));
+    }
+  }
   const model = workerModel ?? opts.model;
   try {
     const text = await ask(task, {
+      ...opts,
       model,
-      maxTokens: opts.maxTokens,
-      thinkingLevel: opts.thinkingLevel,
-      system: opts.system ?? FLEET_SYSTEM
+      system: mergeSystem(opts.system, FLEET_SYSTEM)
     });
     return new FleetMemberOutput(task, text, true);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return new FleetMemberOutput(task, "", false, msg);
+    return new FleetMemberOutput(task, "", false, getErrorMessage(err));
   }
 }
 async function execute6(pieces, args, opts) {
@@ -1036,11 +1207,16 @@ async function execute6(pieces, args, opts) {
     process.stderr.write(`\u03A6: Fleet executing ${tasks.length} task(s) in parallel
 `);
     for (let i = 0; i < tasks.length; i++) {
-      const t = tasks[i];
+      const t = describeTask(tasks[i]);
       process.stderr.write(`  [${i + 1}] ${t.slice(0, 60)}${t.length > 60 ? "..." : ""}
 `);
     }
   }
+  const taskSummary = `Execute ${tasks.length} fleet task(s)?
+    ${tasks.map((t, i) => `${i + 1}. ${describeTask(t).slice(0, 80)}`).join("\n    ")}`;
+  if (!await confirmPhase(taskSummary, opts)) {
+    throw new Error("pizx/\u03A6: Execution cancelled by user.");
+  }
   const results = [];
   const concurrency = opts.concurrency ?? 5;
   for (let i = 0; i < tasks.length; i += concurrency) {
@@ -1052,7 +1228,9 @@ async function execute6(pieces, args, opts) {
       if (r.status === "fulfilled") {
         results.push(r.value);
       } else {
-        results.push(new FleetMemberOutput(batch[idx], "", false, r.reason?.toString()));
+        results.push(
+          new FleetMemberOutput(describeTask(batch[idx]), "", false, r.reason?.toString())
+        );
       }
     });
   }
@@ -1064,30 +1242,11 @@ async function execute6(pieces, args, opts) {
   const header = `Fleet Results: ${results.filter((r) => r.success).length}/${results.length} succeeded
 
 `;
-  return new FleetOutput(header + summary, results, t0, t1);
-}
-function makeFleet(opts = {}) {
-  const merged = { ...defaults6, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeFleet({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute6(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeFleet({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityReview = await runQualityReview(template, header + summary, opts);
+  return new FleetOutput(header + summary, results, t0, t1, qualityReview);
 }
-var \u03A6 = makeFleet();
+var \u03A6 = createPatternTag(defaults6, execute6);
 
 // src/patterns/graph.ts
 var defaults7 = {
@@ -1107,13 +1266,15 @@ var GraphNodeResult = class {
   success;
 };
 var GraphOutput = class extends PatternOutput {
-  constructor(text, finalOutput, nodeResults, startTime, endTime) {
+  constructor(text, finalOutput, nodeResults, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.finalOutput = finalOutput;
     this.nodeResults = nodeResults;
+    this.qualityReview = qualityReview;
   }
   finalOutput;
   nodeResults;
+  qualityReview;
 };
 function parseGraph(template, separator) {
   const sep = separator ?? "\u2192";
@@ -1209,10 +1370,9 @@ Your task: ${node.task}`;
           }
         }
         const text = await ask(context, {
+          ...opts,
           model: workerModel,
-          maxTokens: opts.maxTokens,
-          thinkingLevel: opts.thinkingLevel,
-          system: NODE_SYSTEM
+          system: mergeSystem(opts.system, NODE_SYSTEM)
         });
         return { nodeId, task: node.task, text, success: true };
       })
@@ -1230,34 +1390,15 @@ Your task: ${node.task}`;
   const lastBatch = batches[batches.length - 1] ?? [];
   const finalNodeResults = lastBatch.map((id) => results.get(id)).filter(Boolean);
   const finalOutput = finalNodeResults.length > 0 ? finalNodeResults.join("\n\n") : "";
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityReview = await runQualityReview(template, finalOutput, opts);
   const summary = nodeResults.map(
     (nr) => `[${nr.nodeId}] ${nr.task.slice(0, 80)}...
   ${nr.output.slice(0, 200)}${nr.output.length > 200 ? "..." : ""}`
   ).join("\n\n");
-  return new GraphOutput(summary, finalOutput, nodeResults, t0, t1);
-}
-function makeGraph(opts = {}) {
-  const merged = { ...defaults7, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeGraph({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute7(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeGraph({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+  return new GraphOutput(summary, finalOutput, nodeResults, t0, t1, qualityReview);
 }
-var \u0393 = makeGraph();
+var \u0393 = createPatternTag(defaults7, execute7);
 
 // src/patterns/memory.ts
 var defaults8 = {
@@ -1266,27 +1407,6 @@ var defaults8 = {
   agents: 3,
   rounds: 1
 };
-var ROLE_SETS3 = {
-  2: ["Analyst \u2014 deep analysis of core aspects", "Reviewer \u2014 check for gaps and blind spots"],
-  3: [
-    "Analyst \u2014 deep analysis of core aspects",
-    "Reviewer \u2014 check for gaps, edge cases, and blind spots",
-    "Strategist \u2014 connect findings to actionable insights"
-  ],
-  4: [
-    "Analyst",
-    "Reviewer",
-    "Strategist",
-    "Innovator \u2014 propose novel angles and creative solutions"
-  ],
-  5: [
-    "Analyst",
-    "Reviewer",
-    "Strategist",
-    "Innovator",
-    "Skeptic \u2014 challenge assumptions and stress-test conclusions"
-  ]
-};
 var MemoryEntry = class {
   constructor(role, round, content) {
     this.role = role;
@@ -1298,13 +1418,15 @@ var MemoryEntry = class {
   content;
 };
 var MemoryOutput = class extends PatternOutput {
-  constructor(text, synthesis, entries, startTime, endTime) {
+  constructor(text, synthesis, entries, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.synthesis = synthesis;
     this.entries = entries;
+    this.qualityReview = qualityReview;
   }
   synthesis;
   entries;
+  qualityReview;
 };
 var WRITER_PROMPT = `You are a specialist with role: {role}.
 
@@ -1325,7 +1447,7 @@ async function execute8(pieces, args, opts) {
   const t0 = Date.now();
   const agentCount = opts.agents ?? 3;
   const totalRounds = opts.rounds ?? 1;
-  const roles = opts.roles ?? ROLE_SETS3[agentCount] ?? ROLE_SETS3[3] ?? [];
+  const roles = opts.roles ?? MEMORY_ROLE_SETS[agentCount] ?? MEMORY_ROLE_SETS[3] ?? [];
   const plannerModel = opts.plannerModel ?? opts.model;
   const workerModel = opts.workerModel ?? opts.model;
   if (!opts.quiet) {
@@ -1342,11 +1464,7 @@ async function execute8(pieces, args, opts) {
     const roundResults = await Promise.allSettled(
       roles.map(async (role) => {
         const prompt = buildWriterPrompt(role, topic, blackboard);
-        const text = await ask(prompt, {
-          model: workerModel,
-          maxTokens: opts.maxTokens,
-          thinkingLevel: opts.thinkingLevel
-        });
+        const text = await ask(prompt, { ...opts, model: workerModel });
         return { role, text };
       })
     );
@@ -1368,40 +1486,21 @@ ${blackboard}
 
 Consolidate into a comprehensive, structured synthesis.`,
     {
+      ...opts,
       model: plannerModel,
-      maxTokens: opts.maxTokens,
       thinkingLevel: "high",
-      system: CONSOLIDATOR_SYSTEM
+      system: mergeSystem(opts.system, CONSOLIDATOR_SYSTEM)
     }
   );
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityReview = await runQualityReview(topic, synthesis, opts);
   const t1 = Date.now();
   const summary = entries.map(
     (e) => `[${e.role}] Round ${e.round}: ${e.content.slice(0, 150)}${e.content.length > 150 ? "..." : ""}`
   ).join("\n");
-  return new MemoryOutput(summary, synthesis, entries, t0, t1);
-}
-function makeMemory(opts = {}) {
-  const merged = { ...defaults8, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeMemory({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute8(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeMemory({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+  return new MemoryOutput(summary, synthesis, entries, t0, t1, qualityReview);
 }
-var \u039C = makeMemory();
+var \u039C = createPatternTag(defaults8, execute8);
 
 // src/patterns/nu.ts
 var defaults9 = {
@@ -1421,19 +1520,21 @@ var NuRole = class {
   goal;
 };
 var NuOutput = class extends PatternOutput {
-  constructor(text, negotiatedRoles, workflow, workflowReasoning, roleResults, synthesis, startTime, endTime) {
+  constructor(text, negotiatedRoles, workflow, workflowReasoning, roleResults, synthesis, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.negotiatedRoles = negotiatedRoles;
     this.workflow = workflow;
     this.workflowReasoning = workflowReasoning;
     this.roleResults = roleResults;
     this.synthesis = synthesis;
+    this.qualityReview = qualityReview;
   }
   negotiatedRoles;
   workflow;
   workflowReasoning;
   roleResults;
   synthesis;
+  qualityReview;
 };
 var NEGOTIATE_SYSTEM = `You are a team architect. Given a task, propose a team of specialized agents. Each role must have a distinct name, expertise, and goal.
 
@@ -1471,6 +1572,7 @@ async function negotiateRoles(task, opts) {
   const response = await ask(`Task: ${task}
 
 ${prompt}`, {
+    ...opts,
     model: opts.plannerModel ?? opts.model,
     maxTokens: 2048,
     thinkingLevel: "high"
@@ -1507,10 +1609,11 @@ ${rolesText}
 
 Determine the best execution strategy.`,
     {
+      ...opts,
       model: opts.plannerModel ?? opts.model,
       maxTokens: 512,
       thinkingLevel: "high",
-      system: WORKFLOW_SYSTEM
+      system: mergeSystem(opts.system, WORKFLOW_SYSTEM)
     }
   );
   const wfMatch = response.match(/WORKFLOW\s*:\s*(.+)/i);
@@ -1529,10 +1632,9 @@ async function executeRoles(roles, task, workflow, opts) {
     let context = task;
     for (const role of roles) {
       const output = await ask(context, {
+        ...opts,
         model: workerModel,
-        maxTokens: opts.maxTokens,
-        thinkingLevel: opts.thinkingLevel,
-        system: EXECUTE_SYSTEM2(role)
+        system: mergeSystem(opts.system, EXECUTE_SYSTEM2(role))
       });
       results.push({ role: role.name, output });
       context = `Previous output from ${role.name}:
@@ -1544,10 +1646,9 @@ Continue with: ${task}`;
     const parallelResults = await Promise.allSettled(
       roles.map(
         (role) => ask(task, {
+          ...opts,
           model: workerModel,
-          maxTokens: opts.maxTokens,
-          thinkingLevel: opts.thinkingLevel,
-          system: EXECUTE_SYSTEM2(role)
+          system: mergeSystem(opts.system, EXECUTE_SYSTEM2(role))
         }).then((text) => ({ role: role.name, output: text })).catch((err) => ({ role: role.name, output: `(failed: ${String(err)})` }))
       )
     );
@@ -1569,10 +1670,10 @@ ${resultsText}
 
 Synthesize a comprehensive final answer.`,
     {
+      ...opts,
       model: opts.plannerModel ?? opts.model,
-      maxTokens: opts.maxTokens,
       thinkingLevel: "high",
-      system: SYNTHESIS_SYSTEM3
+      system: mergeSystem(opts.system, SYNTHESIS_SYSTEM3)
     }
   );
 }
@@ -1612,38 +1713,29 @@ async function execute9(pieces, args, opts) {
 `);
   const roleResults = await executeRoles(roles, task, workflow, opts);
   if (!opts.quiet) process.stderr.write("  \u2192 Synthesizing...\n");
-  const synthesis = await synthesize(task, roleResults, { ...opts, plannerModel });
-  const t1 = Date.now();
-  const summary = [
-    `Roles: ${roles.map((r) => r.name).join(", ")}`,
-    `Workflow: ${workflow} (${reasoning})`,
-    `Results: ${roleResults.length}/${roles.length} succeeded`,
-    `Synthesis: ${synthesis}`
-  ].join("\n\n");
-  return new NuOutput(summary, roles, workflow, reasoning, roleResults, synthesis, t0, t1);
-}
-function makeNu(opts = {}) {
-  const merged = { ...defaults9, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeNu({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute9(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeNu({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+  const synthesis = await synthesize(task, roleResults, { ...opts, plannerModel });
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityReview = await runQualityReview(task, synthesis, opts);
+  const t1 = Date.now();
+  const summary = [
+    `Roles: ${roles.map((r) => r.name).join(", ")}`,
+    `Workflow: ${workflow} (${reasoning})`,
+    `Results: ${roleResults.length}/${roles.length} succeeded`,
+    `Synthesis: ${synthesis}`
+  ].join("\n\n");
+  return new NuOutput(
+    summary,
+    roles,
+    workflow,
+    reasoning,
+    roleResults,
+    synthesis,
+    t0,
+    t1,
+    qualityReview
+  );
 }
-var \u039D = makeNu();
+var \u039D = createPatternTag(defaults9, execute9);
 
 // src/patterns/orchestrator.ts
 var defaults10 = {
@@ -1663,15 +1755,17 @@ var OrchestratorWorkerResult = class {
   success;
 };
 var OrchestratorOutput = class extends PatternOutput {
-  constructor(text, plan, synthesis, workerResults, startTime, endTime) {
+  constructor(text, plan, synthesis, workerResults, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.plan = plan;
     this.synthesis = synthesis;
     this.workerResults = workerResults;
+    this.qualityReview = qualityReview;
   }
   plan;
   synthesis;
   workerResults;
+  qualityReview;
 };
 var PLANNER_SYSTEM = `You are a senior architect and project planner. Given a high-level request, create a detailed execution plan.
 
@@ -1694,6 +1788,7 @@ async function execute10(pieces, args, opts) {
   const request = build(pieces, args);
   const t0 = Date.now();
   const workerCount = opts.workers ?? 3;
+  const phases = [];
   const plannerModel = opts.plannerModel ?? opts.model;
   const workerModel = opts.workerModel ?? opts.model;
   if (!opts.quiet) {
@@ -1703,11 +1798,18 @@ async function execute10(pieces, args, opts) {
     );
   }
   if (!opts.quiet) process.stderr.write("  \u2192 Planning...\n");
+  const planStart = Date.now();
   const planText = await ask(request, {
+    ...opts,
     model: plannerModel,
-    maxTokens: opts.maxTokens,
     thinkingLevel: "high",
-    system: PLANNER_SYSTEM.replace("{$workerCount}", String(workerCount))
+    system: mergeSystem(opts.system, PLANNER_SYSTEM.replace("{$workerCount}", String(workerCount)))
+  });
+  phases.push({
+    phase: "plan",
+    durationMs: Date.now() - planStart,
+    description: `Generated plan with ${workerCount} workers`,
+    modelUsed: plannerModel
   });
   const subTasks = [];
   const taskLines = planText.split("\n");
@@ -1731,27 +1833,37 @@ async function execute10(pieces, args, opts) {
 `);
     }
   }
+  const planSummary = tasks.length > 0 ? `Execute ${tasks.length} sub-task(s) as planned?
+    ${tasks.map((t, i) => `${i + 1}. ${t.slice(0, 80)}`).join("\n    ")}` : `Execute the plan?`;
+  if (!await confirmPhase(planSummary, opts)) {
+    throw new Error("pizx/\u03A9: Execution cancelled by user.");
+  }
   const workerResults = [];
   const concurrency = opts.concurrency ?? 3;
+  const dispatchStart = Date.now();
   for (let i = 0; i < tasks.length; i += concurrency) {
     const batch = tasks.slice(i, i + concurrency);
     const batchResults = await Promise.allSettled(
       batch.map(
-        (task) => ask(task, {
-          model: workerModel,
-          maxTokens: opts.maxTokens,
-          thinkingLevel: opts.thinkingLevel,
-          system: WORKER_SYSTEM
-        }).then((text) => new OrchestratorWorkerResult(task, text, true)).catch((err) => new OrchestratorWorkerResult(task, String(err), false))
+        (task) => ask(task, { ...opts, model: workerModel, system: mergeSystem(opts.system, WORKER_SYSTEM) }).then((text) => new OrchestratorWorkerResult(task, text, true)).catch((err) => new OrchestratorWorkerResult(task, String(err), false))
       )
     );
     batchResults.forEach((r) => {
       if (r.status === "fulfilled") workerResults.push(r.value);
     });
   }
+  const succeeded = workerResults.filter((w) => w.success).length;
+  phases.push({
+    phase: "dispatch",
+    durationMs: Date.now() - dispatchStart,
+    description: `Executed ${workerResults.length} worker(s), ${succeeded} succeeded`,
+    modelUsed: workerModel,
+    callCount: workerResults.length
+  });
   if (!opts.quiet) process.stderr.write("  \u2192 Synthesizing results...\n");
   const workerTexts = workerResults.map((wr, i) => `Task ${i + 1}: ${wr.task}
 Result: ${wr.output}`).join("\n\n");
+  const synthStart = Date.now();
   const synthesis = await ask(
     `Original request:
 ${request}
@@ -1764,46 +1876,60 @@ ${workerTexts}
 
 Synthesize a final deliverable.`,
     {
+      ...opts,
       model: plannerModel,
-      maxTokens: opts.maxTokens,
       thinkingLevel: "high",
-      system: SYNTHESIS_SYSTEM4
+      system: mergeSystem(opts.system, SYNTHESIS_SYSTEM4)
     }
   );
+  phases.push({
+    phase: "synthesize",
+    durationMs: Date.now() - synthStart,
+    description: "Synthesized worker results into final deliverable",
+    modelUsed: plannerModel
+  });
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityStart = Date.now();
+  const qualityReview = await runQualityReview(request, synthesis, opts);
+  if (qualityReview) {
+    phases.push({
+      phase: "quality-review",
+      durationMs: Date.now() - qualityStart,
+      description: `Score: ${qualityReview.score.toFixed(2)} \u2014 ${qualityReview.assessment.slice(0, 60)}`,
+      modelUsed: plannerModel
+    });
+  }
   const t1 = Date.now();
+  const reviewSection = qualityReview ? `
+
+Quality Review: ${qualityReview.score.toFixed(2)} \u2014 ${qualityReview.assessment}
+  Recommendation: ${qualityReview.recommendation}` : "";
   const summary = `Plan:
 ${planText}
 
 Workers: ${workerResults.filter((w) => w.success).length}/${workerResults.length} succeeded
 
 Synthesis:
-${synthesis}`;
-  return new OrchestratorOutput(summary, planText, synthesis, workerResults, t0, t1);
-}
-function makeOrchestrator(opts = {}) {
-  const merged = { ...defaults10, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeOrchestrator({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute10(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeOrchestrator({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+${synthesis}${reviewSection}`;
+  const output = new OrchestratorOutput(
+    summary,
+    planText,
+    synthesis,
+    workerResults,
+    t0,
+    t1,
+    qualityReview
+  );
+  output.phaseLog = phases;
+  return output;
 }
-var \u03A9 = makeOrchestrator();
+var \u03A9 = createPatternTag(defaults10, execute10);
 
 // src/patterns/pipeline.ts
+function describeStage(stage) {
+  if (typeof stage === "function") return "(composed pattern)";
+  return stage;
+}
 var defaults11 = {
   maxTokens: 4096,
   thinkingLevel: "medium"
@@ -1819,13 +1945,15 @@ var PipelineStageResult = class {
   index;
 };
 var PipelineOutput = class extends PatternOutput {
-  constructor(text, finalOutput, stages, startTime, endTime) {
+  constructor(text, finalOutput, stages, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.finalOutput = finalOutput;
     this.stages = stages;
+    this.qualityReview = qualityReview;
   }
   finalOutput;
   stages;
+  qualityReview;
 };
 function parseStages(template, explicitStages, separator) {
   if (explicitStages && explicitStages.length > 0) return explicitStages;
@@ -1867,55 +1995,46 @@ async function execute11(pieces, args, opts) {
 `);
     }
   }
+  const stageSummary = `Run ${stages.length} pipeline stage(s)?
+    ${stages.map((s, i) => `${i + 1}. ${describeStage(s)}`).join("\n    ")}`;
+  if (!await confirmPhase(stageSummary, opts)) {
+    throw new Error("pizx/\u039B: Execution cancelled by user.");
+  }
   const stageResults = [];
   let currentInput = "";
   for (let i = 0; i < stages.length; i++) {
     const stage = stages[i];
+    const stageLabel = describeStage(stage);
     const customPrompt = opts.stagePrompts?.[i];
     if (!opts.quiet)
-      process.stderr.write(`  \u2192 Stage ${i + 1}/${stages.length}: ${stage.slice(0, 50)}...
+      process.stderr.write(`  \u2192 Stage ${i + 1}/${stages.length}: ${stageLabel.slice(0, 50)}...
 `);
-    const prompt = customPrompt ?? generateStagePrompt(stage, currentInput, i === 0);
-    const systemMessage = i === 0 ? `You are a specialist executing stage ${i + 1}: ${stage}. Focus only on this stage's output.` : `You are a specialist executing stage ${i + 1}: ${stage}. Process the previous stage's output according to your instructions. Maintain all important information from previous stages.`;
-    const output = await ask(prompt, {
-      model: workerModel,
-      maxTokens: opts.maxTokens,
-      thinkingLevel: opts.thinkingLevel,
-      system: systemMessage
-    });
-    stageResults.push(new PipelineStageResult(stage, output, i));
+    let output;
+    if (typeof stage === "function") {
+      output = await stage(currentInput);
+    } else {
+      const prompt = customPrompt ?? generateStagePrompt(stage, currentInput, i === 0);
+      const systemMessage = i === 0 ? `You are a specialist executing stage ${i + 1}: ${stage}. Focus only on this stage's output.` : `You are a specialist executing stage ${i + 1}: ${stage}. Process the previous stage's output according to your instructions. Maintain all important information from previous stages.`;
+      output = await ask(prompt, {
+        ...opts,
+        model: workerModel,
+        system: mergeSystem(opts.system, systemMessage)
+      });
+    }
+    stageResults.push(new PipelineStageResult(stageLabel, output, i));
     currentInput = output;
   }
   const t1 = Date.now();
   const finalOutput = currentInput;
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityReview = await runQualityReview(template, finalOutput, opts);
   const summary = stageResults.map(
     (sr) => `Stage ${sr.index + 1} (${sr.stage}):
 ${sr.output.slice(0, 200)}${sr.output.length > 200 ? "..." : ""}`
   ).join("\n\n");
-  return new PipelineOutput(summary, finalOutput, stageResults, t0, t1);
-}
-function makePipeline(opts = {}) {
-  const merged = { ...defaults11, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makePipeline({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute11(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makePipeline({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+  return new PipelineOutput(summary, finalOutput, stageResults, t0, t1, qualityReview);
 }
-var \u039B = makePipeline();
+var \u039B = createPatternTag(defaults11, execute11);
 
 // src/patterns/ralph.ts
 import { createAgentSession } from "@earendil-works/pi-coding-agent";
@@ -1950,17 +2069,17 @@ async function executeWithTools(goal, opts) {
   });
   try {
     await session.sendUserMessage(goal);
-    const msgs = session.messages ?? [];
-    for (let i = msgs.length - 1; i >= 0; i--) {
-      if (msgs[i].role === "assistant") {
-        const c = msgs[i].content;
-        if (typeof c === "string") return c.trim();
-        if (Array.isArray(c)) {
-          const texts = c.filter(
-            (x) => x.type === "text" && typeof x.text === "string"
-          ).map((x) => x.text);
-          if (texts.length > 0) return texts.join("").trim();
-        }
+    const messages = session.messages;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg?.role !== "assistant") continue;
+      const c = "content" in msg ? msg.content : void 0;
+      if (typeof c === "string") return c.trim();
+      if (Array.isArray(c)) {
+        const texts = c.filter(
+          (x) => x.type === "text" && typeof x.text === "string"
+        ).map((x) => x.text);
+        if (texts.length > 0) return texts.join("").trim();
       }
     }
     return "(no assistant response)";
@@ -1995,10 +2114,9 @@ async function execute12(pieces, args, opts) {
     }
     if (!opts.quiet) process.stderr.write("  \u2192 Analyzing...\n");
     const analysis = await ask(currentGoal, {
+      ...opts,
       model: plannerModel,
-      maxTokens: opts.maxTokens,
-      thinkingLevel: opts.thinkingLevel,
-      system: ANALYSIS_SYSTEM2
+      system: mergeSystem(opts.system, ANALYSIS_SYSTEM2)
     });
     if (!opts.quiet) process.stderr.write("  \u2192 Planning...\n");
     const plan = await ask(
@@ -2007,12 +2125,7 @@ async function execute12(pieces, args, opts) {
 Analysis: ${analysis}
 
 Generate an implementation plan.`,
-      {
-        model: plannerModel,
-        maxTokens: opts.maxTokens,
-        thinkingLevel: opts.thinkingLevel,
-        system: PLAN_SYSTEM2
-      }
+      { ...opts, model: plannerModel, system: mergeSystem(opts.system, PLAN_SYSTEM2) }
     );
     if (!opts.quiet) process.stderr.write("  \u2192 Executing...\n");
     const result = opts.useTools ? await executeWithTools(`Implement this plan:
@@ -2025,9 +2138,8 @@ Goal: ${currentGoal}`, {
 ${plan}
 
 Goal: ${currentGoal}`, {
-      model: workerModel,
-      maxTokens: opts.maxTokens,
-      thinkingLevel: opts.thinkingLevel
+      ...opts,
+      model: workerModel
     });
     if (!opts.quiet) process.stderr.write("  \u2192 Reviewing...\n");
     const review = await ask(`Plan:
@@ -2037,10 +2149,11 @@ Result:
 ${result}
 
 Review the implementation.`, {
+      ...opts,
       model: plannerModel,
       maxTokens: 1024,
       thinkingLevel: "high",
-      system: REVIEW_SYSTEM
+      system: mergeSystem(opts.system, REVIEW_SYSTEM)
     });
     const shouldContinue = review.includes("ITERATE") && !review.includes("DONE");
     iterations.push({
@@ -2076,28 +2189,7 @@ Original goal: ${goal}`;
     t1
   );
 }
-function makeRalph(opts = {}) {
-  const merged = { ...defaults12, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeRalph({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute12(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeRalph({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
-}
-var \u03A1 = makeRalph();
+var \u03A1 = createPatternTag(defaults12, execute12);
 
 // src/patterns/subagent.ts
 var defaults13 = {
@@ -2117,13 +2209,15 @@ var SubagentResult = class {
   success;
 };
 var SubagentOutput = class extends PatternOutput {
-  constructor(text, synthesis, subResults, startTime, endTime) {
+  constructor(text, synthesis, subResults, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.synthesis = synthesis;
     this.subResults = subResults;
+    this.qualityReview = qualityReview;
   }
   synthesis;
   subResults;
+  qualityReview;
 };
 var DECOMPOSE_SYSTEM = `You are a task decomposition specialist. Break down complex tasks into independent sub-tasks that can be worked on in parallel. Output ONLY a JSON array of strings, each being a self-contained sub-task description. No markdown, no explanation.`;
 var SYNTHESIS_SYSTEM5 = `You are a synthesis specialist. Combine the results from multiple sub-agent analyses into a coherent, comprehensive answer. Identify patterns, conflicts, and gaps.`;
@@ -2136,10 +2230,11 @@ ${task}
 
 Output a JSON array of strings.`,
     {
+      ...opts,
       model: opts.model,
       maxTokens: 1024,
       thinkingLevel: "medium",
-      system: DECOMPOSE_SYSTEM
+      system: mergeSystem(opts.system, DECOMPOSE_SYSTEM)
     }
   );
   try {
@@ -2160,6 +2255,7 @@ var SUBAGENT_SYSTEM = `You are a domain specialist. Complete your assigned sub-t
 async function execute13(pieces, args, opts) {
   const task = build(pieces, args);
   const t0 = Date.now();
+  const phases = [];
   const plannerModel = opts.plannerModel ?? opts.model;
   const workerModel = opts.workerModel ?? opts.model;
   if (!opts.quiet) {
@@ -2169,7 +2265,14 @@ async function execute13(pieces, args, opts) {
     );
   }
   if (!opts.quiet) process.stderr.write("  \u2192 Decomposing task into sub-tasks...\n");
+  const decomposeStart = Date.now();
   const subTasks = await decomposeTask(task, { ...opts, model: plannerModel });
+  phases.push({
+    phase: "decompose",
+    durationMs: Date.now() - decomposeStart,
+    description: `Decomposed into ${subTasks.length} sub-task(s)`,
+    modelUsed: plannerModel
+  });
   if (!opts.quiet) {
     process.stderr.write(`  \u2192 ${subTasks.length} sub-task(s) identified:
 `);
@@ -2179,27 +2282,37 @@ async function execute13(pieces, args, opts) {
 `);
     }
   }
+  const subTaskSummary = `Execute ${subTasks.length} sub-task(s)?
+    ${subTasks.map((st, i) => `${i + 1}. ${st.slice(0, 80)}`).join("\n    ")}`;
+  if (!await confirmPhase(subTaskSummary, opts)) {
+    throw new Error("pizx/\u03A3: Execution cancelled by user.");
+  }
   const subResults = [];
   const concurrency = opts.concurrency ?? 4;
+  const execStart = Date.now();
   for (let i = 0; i < subTasks.length; i += concurrency) {
     const batch = subTasks.slice(i, i + concurrency);
     const batchResults = await Promise.allSettled(
       batch.map(
-        (st) => ask(st, {
-          model: workerModel,
-          maxTokens: opts.maxTokens,
-          thinkingLevel: opts.thinkingLevel,
-          system: SUBAGENT_SYSTEM
-        }).then((text) => new SubagentResult(st, text, true)).catch((err) => new SubagentResult(st, String(err), false))
+        (st) => ask(st, { ...opts, model: workerModel, system: mergeSystem(opts.system, SUBAGENT_SYSTEM) }).then((text) => new SubagentResult(st, text, true)).catch((err) => new SubagentResult(st, String(err), false))
       )
     );
     batchResults.forEach((r) => {
       if (r.status === "fulfilled") subResults.push(r.value);
     });
   }
+  const succeeded = subResults.filter((r) => r.success).length;
+  phases.push({
+    phase: "execute",
+    durationMs: Date.now() - execStart,
+    description: `Executed ${subResults.length} sub-task(s), ${succeeded} succeeded`,
+    modelUsed: workerModel,
+    callCount: subResults.length
+  });
   if (!opts.quiet) process.stderr.write("  \u2192 Synthesizing results...\n");
   const subResultsText = subResults.map((sr, i) => `Sub-task ${i + 1}: ${sr.subTask}
 Result: ${sr.text}`).join("\n\n");
+  const synthStart = Date.now();
   const synthesis = await ask(
     `Original task:
 ${task}
@@ -2208,38 +2321,31 @@ Sub-task results:
 ${subResultsText}
 
 Synthesize a comprehensive answer.`,
-    {
-      model: plannerModel,
-      maxTokens: opts.maxTokens,
-      thinkingLevel: opts.thinkingLevel,
-      system: SYNTHESIS_SYSTEM5
-    }
+    { ...opts, model: plannerModel, system: mergeSystem(opts.system, SYNTHESIS_SYSTEM5) }
   );
-  const t1 = Date.now();
-  return new SubagentOutput(synthesis, synthesis, subResults, t0, t1);
-}
-function makeSubagent(opts = {}) {
-  const merged = { ...defaults13, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeSubagent({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute13(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeSubagent({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
+  phases.push({
+    phase: "synthesize",
+    durationMs: Date.now() - synthStart,
+    description: "Synthesized sub-agent results",
+    modelUsed: plannerModel
   });
-  return fn;
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qStart = Date.now();
+  const qualityReview = await runQualityReview(task, synthesis, opts);
+  if (qualityReview) {
+    phases.push({
+      phase: "quality-review",
+      durationMs: Date.now() - qStart,
+      description: `Score: ${qualityReview.score.toFixed(2)}`,
+      modelUsed: plannerModel
+    });
+  }
+  const t1 = Date.now();
+  const output = new SubagentOutput(synthesis, synthesis, subResults, t0, t1, qualityReview);
+  output.phaseLog = phases;
+  return output;
 }
-var \u03A3 = makeSubagent();
+var \u03A3 = createPatternTag(defaults13, execute13);
 
 // src/patterns/tau.ts
 var defaults14 = {
@@ -2263,15 +2369,17 @@ var ToolMediatedEntry = class {
   content;
 };
 var TauOutput = class extends PatternOutput {
-  constructor(text, entries, finalState, synthesis, startTime, endTime) {
+  constructor(text, entries, finalState, synthesis, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.entries = entries;
     this.finalState = finalState;
     this.synthesis = synthesis;
+    this.qualityReview = qualityReview;
   }
   entries;
   finalState;
   synthesis;
+  qualityReview;
 };
 var SCHEMA_SYSTEM = `You are a coordination architect. Given a task, design a shared structured context for agent collaboration.
 
@@ -2326,6 +2434,7 @@ async function defineSchema(task, opts) {
   const response = await ask(`Task: ${task}
 
 ${prompt}`, {
+    ...opts,
     model: opts.plannerModel ?? opts.model,
     maxTokens: 1024,
     thinkingLevel: "high"
@@ -2378,10 +2487,9 @@ async function executeRound(roles, assignments, store, round, opts) {
       const systemPrompt = isWrite ? WRITE_SYSTEM(role, keysStr).replace("{store}", storeText) : UPDATE_SYSTEM(role, keysStr).replace("{store}", storeText);
       const task = isWrite ? `Write your initial findings to your assigned keys: ${keysStr}` : `Review the shared context and update your entries for keys: ${keysStr}`;
       const response = await ask(task, {
+        ...opts,
         model: workerModel,
-        maxTokens: opts.maxTokens,
-        thinkingLevel: opts.thinkingLevel,
-        system: systemPrompt
+        system: mergeSystem(opts.system, systemPrompt)
       });
       return { role, response };
     })
@@ -2421,10 +2529,10 @@ ${storeText}
 
 Consolidate into a comprehensive, well-structured synthesis.`,
     {
+      ...opts,
       model: opts.plannerModel ?? opts.model,
-      maxTokens: opts.maxTokens,
       thinkingLevel: "high",
-      system: CONSOLIDATE_SYSTEM
+      system: mergeSystem(opts.system, CONSOLIDATE_SYSTEM)
     }
   );
 }
@@ -2469,6 +2577,8 @@ async function execute14(pieces, args, opts) {
   }
   if (!opts.quiet) process.stderr.write("  \u2192 Consolidating store...\n");
   const synthesis = await consolidateStore(task, store, { ...opts, plannerModel });
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityReview = await runQualityReview(task, synthesis, opts);
   const t1 = Date.now();
   const summary = [
     `Schema keys: ${keys.join(", ")}`,
@@ -2477,30 +2587,9 @@ async function execute14(pieces, args, opts) {
     `Entries: ${allEntries.length}`,
     `Synthesis: ${synthesis}`
   ].join("\n\n");
-  return new TauOutput(summary, allEntries, store, synthesis, t0, t1);
-}
-function makeTau(opts = {}) {
-  const merged = { ...defaults14, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeTau({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute14(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeTau({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+  return new TauOutput(summary, allEntries, store, synthesis, t0, t1, qualityReview);
 }
-var \u03A4 = makeTau();
+var \u03A4 = createPatternTag(defaults14, execute14);
 
 // src/patterns/thread.ts
 var defaults15 = {
@@ -2509,27 +2598,6 @@ var defaults15 = {
   agents: 3,
   turns: 3
 };
-var ROLE_SETS4 = {
-  2: ["Proposer \u2014 advocate the best approach", "Critic \u2014 identify weaknesses and gaps"],
-  3: [
-    "Proposer \u2014 suggest the best approach",
-    "Critic \u2014 identify weaknesses, risks, and missing pieces",
-    "Synthesizer \u2014 combine the best ideas into a practical plan"
-  ],
-  4: [
-    "Proposer \u2014 advocate a bold solution",
-    "Critic \u2014 identify risks and weaknesses",
-    "Pragmatist \u2014 focus on practical implementation",
-    "Innovator \u2014 propose creative alternatives"
-  ],
-  5: [
-    "Proposer",
-    "Critic",
-    "Pragmatist",
-    "Innovator",
-    "Devil's Advocate \u2014 challenge every assumption"
-  ]
-};
 var ThreadMessage = class {
   constructor(role, turn, content) {
     this.role = role;
@@ -2541,13 +2609,15 @@ var ThreadMessage = class {
   content;
 };
 var ThreadOutput = class extends PatternOutput {
-  constructor(text, conclusion, messages, startTime, endTime) {
+  constructor(text, conclusion, messages, startTime, endTime, qualityReview) {
     super(text, startTime, endTime);
     this.conclusion = conclusion;
     this.messages = messages;
+    this.qualityReview = qualityReview;
   }
   conclusion;
   messages;
+  qualityReview;
 };
 var THREAD_PROMPT = `You are an agent with the role: {role}.
 Engage in a multi-agent conversation about the topic.
@@ -2569,7 +2639,7 @@ async function execute15(pieces, args, opts) {
   const t0 = Date.now();
   const agentCount = opts.agents ?? 3;
   const maxTurns = opts.turns ?? 3;
-  const roles = opts.roles ?? ROLE_SETS4[agentCount] ?? ROLE_SETS4[3] ?? [];
+  const roles = opts.roles ?? THREAD_ROLE_SETS[agentCount] ?? THREAD_ROLE_SETS[3] ?? [];
   const plannerModel = opts.plannerModel ?? opts.model;
   const workerModel = opts.workerModel ?? opts.model;
   if (!opts.quiet) {
@@ -2587,11 +2657,7 @@ async function execute15(pieces, args, opts) {
     for (let a = 0; a < roles.length; a++) {
       const role = roles[a] ?? `Agent ${a + 1}`;
       const prompt = buildThreadPrompt(role, thread);
-      const response = await ask(prompt, {
-        model: workerModel,
-        maxTokens: opts.maxTokens,
-        thinkingLevel: opts.thinkingLevel
-      });
+      const response = await ask(prompt, { ...opts, model: workerModel });
       messages.push(new ThreadMessage(role, turn, response));
       thread += `
 [${role}] (Turn ${turn}): ${response}
@@ -2607,46 +2673,24 @@ ${thread}
 
 Synthesize a clear, actionable conclusion.`,
     {
+      ...opts,
       model: plannerModel,
-      maxTokens: opts.maxTokens,
       thinkingLevel: "high",
-      system: SYNTHESIS_SYSTEM6
+      system: mergeSystem(opts.system, SYNTHESIS_SYSTEM6)
     }
   );
+  if (!opts.quiet && opts.qualityCheck) process.stderr.write("  \u2192 Quality review...\n");
+  const qualityReview = await runQualityReview(topic, conclusion, opts);
   const t1 = Date.now();
   const summary = messages.map(
     (m) => `[${m.role}] Turn ${m.turn}: ${m.content.slice(0, 150)}${m.content.length > 150 ? "..." : ""}`
   ).join("\n");
-  return new ThreadOutput(summary, conclusion, messages, t0, t1);
-}
-function makeThread(opts = {}) {
-  const merged = { ...defaults15, ...opts };
-  const fn = ((pieces, ...args) => {
-    if (!Array.isArray(pieces)) {
-      return makeThread({ ...merged, ...pieces });
-    }
-    return new PatternPromise((resolve, reject) => {
-      execute15(pieces, args, merged).then(resolve, reject);
-    });
-  });
-  let _quiet;
-  Object.defineProperty(fn, "quiet", {
-    get() {
-      if (!_quiet) _quiet = makeThread({ ...merged, quiet: true });
-      return _quiet;
-    },
-    enumerable: true,
-    configurable: true
-  });
-  return fn;
+  return new ThreadOutput(summary, conclusion, messages, t0, t1, qualityReview);
 }
-var \u0398 = makeThread();
+var \u0398 = createPatternTag(defaults15, execute15);
 
 // src/pi.ts
 import {
-  getEnvApiKey as getEnvApiKey2,
-  getModels as getModels2,
-  getProviders as getProviders2,
   streamSimple
 } from "@earendil-works/pi-ai";
 
@@ -2664,10 +2708,28 @@ var PiOutput = class {
   events;
   startTime;
   endTime;
+  /** Trace entry for this single LLM call. Populated by the π tag. */
+  trace = [];
   /** Duration in milliseconds */
   get duration() {
     return this.endTime - this.startTime;
   }
+  /** Total input tokens (convenience accessor) */
+  get inputTokens() {
+    return this.trace[0]?.inputTokens ?? 0;
+  }
+  /** Total output tokens (convenience accessor) */
+  get outputTokens() {
+    return this.trace[0]?.outputTokens ?? 0;
+  }
+  /** Total tokens (convenience accessor) */
+  get totalTokens() {
+    return this.trace[0]?.totalTokens ?? 0;
+  }
+  /** Total cost in USD (convenience accessor) */
+  get totalCost() {
+    return this.trace[0]?.cost ?? 0;
+  }
   toString() {
     return this.text;
   }
@@ -2693,90 +2755,16 @@ var defaults16 = {
   quiet: false,
   maxTokens: 4096
 };
-var _piSettings2;
-function getPiDefaults2() {
-  if (_piSettings2 === void 0) {
-    _piSettings2 = isPiInstalled() ? loadPiSettings() : {};
-  }
-  return _piSettings2;
-}
-function allModels2() {
-  const result = [];
-  for (const p of getProviders2()) {
-    const ms = getModels2(p);
-    if (ms && ms.length > 0) result.push(...ms);
-  }
-  return result;
-}
-function getConfiguredProviders2() {
-  return getProviders2().filter((p) => getEnvApiKey2(p) !== void 0);
-}
-function configuredModels2() {
-  const configured = new Set(getConfiguredProviders2());
-  return allModels2().filter((m) => configured.has(m.provider));
-}
-function findModelById2(id) {
-  const all = allModels2();
-  if (id.includes("/")) {
-    const [provider, modelId] = id.split("/", 2);
-    return all.find(
-      (m) => m.provider === provider && (m.id === modelId || m.id.endsWith(`/${modelId}`))
-    );
-  }
-  return all.find((m) => m.id === id || m.id.endsWith(`/${id}`));
-}
-function pickModel2(preferred) {
-  if (preferred) {
-    const hit = findModelById2(preferred);
-    if (hit) return hit;
-  }
-  const settings = getPiDefaults2();
-  if (settings.defaultModel) {
-    const hit = findModelById2(settings.defaultModel);
-    if (hit) return hit;
-  }
-  if (settings.defaultProvider) {
-    const providerModels = getModels2(settings.defaultProvider);
-    if (providerModels && providerModels.length > 0) {
-      const configured = new Set(getConfiguredProviders2());
-      if (configured.has(settings.defaultProvider)) {
-        return providerModels[0];
-      }
-    }
-  }
-  const available = configuredModels2();
-  if (available.length > 0) {
-    const order2 = ["claude-sonnet-4-5", "claude-sonnet-4", "gemini-2.5-flash", "gpt-4o-mini"];
-    for (const id of order2) {
-      const m = available.find((m2) => m2.id.includes(id));
-      if (m) return m;
-    }
-    return available[0];
-  }
-  const models = allModels2();
-  if (models.length === 0) return void 0;
-  const order = ["claude-sonnet-4-5", "claude-sonnet-4", "gemini-2.5-flash", "gpt-4o-mini"];
-  for (const id of order) {
-    const m = models.find((m2) => m2.id.includes(id));
-    if (m) return m;
-  }
-  return models[0];
-}
-function build2(pieces, args) {
-  let s = "";
-  for (let i = 0; i < pieces.length; i++) {
-    s += pieces[i];
-    if (i < args.length) s += String(args[i]);
-  }
-  return s;
-}
 function makeContext(pieces, args, opts) {
+  const systemParts = [];
+  if (opts.system) systemParts.push(opts.system);
+  if (opts.appendSystemPrompt) systemParts.push(opts.appendSystemPrompt);
   return {
-    systemPrompt: opts.system,
+    systemPrompt: systemParts.length > 0 ? systemParts.join("\n\n") : void 0,
     messages: [
       {
         role: "user",
-        content: build2(pieces, args),
+        content: build(pieces, args),
         timestamp: Date.now()
       }
     ]
@@ -2785,25 +2773,52 @@ function makeContext(pieces, args, opts) {
 function makeOpts(opts) {
   return {
     maxTokens: opts.maxTokens,
-    reasoning: opts.thinkingLevel
+    reasoning: opts.thinkingLevel,
+    thinkingBudgets: opts.thinkingBudgets,
+    timeoutMs: opts.timeoutMs,
+    maxRetries: opts.maxRetries
   };
 }
 async function run(pieces, args, opts) {
-  const model = pickModel2(opts.model);
+  const model = pickModel(opts.model);
   if (!model) throw new Error("pizx/\u03C0: No AI models configured. Run `pi auth login` first.");
   const t0 = Date.now();
   let text = "";
-  for await (const ev of streamSimple(model, makeContext(pieces, args, opts), makeOpts(opts))) {
-    if (ev.type === "text_delta") {
-      text += ev.delta;
-      if (!opts.quiet) process.stdout.write(ev.delta);
+  let traceEntry;
+  try {
+    for await (const ev of streamSimple(model, makeContext(pieces, args, opts), makeOpts(opts))) {
+      if (ev.type === "text_delta") {
+        text += ev.delta;
+        if (!opts.quiet) process.stdout.write(ev.delta);
+      } else if (ev.type === "done") {
+        const msg = ev.message;
+        if (msg?.usage) {
+          traceEntry = {
+            call: 1,
+            modelId: model.id,
+            promptPreview: build(pieces, args).slice(0, 200),
+            outputPreview: text.slice(0, 200),
+            inputTokens: msg.usage.input,
+            outputTokens: msg.usage.output,
+            cacheReadTokens: msg.usage.cacheRead,
+            cacheWriteTokens: msg.usage.cacheWrite,
+            totalTokens: msg.usage.totalTokens,
+            cost: msg.usage.cost.total,
+            durationMs: Date.now() - t0
+          };
+        }
+      }
     }
+  } catch (err) {
+    throw new Error(`pizx/\u03C0: AI generation failed: ${getErrorMessage(err)}`);
   }
   if (!opts.quiet && text) process.stdout.write("\n");
-  return new PiOutput(text.trim(), model.id, [], t0, Date.now());
+  const output = new PiOutput(text.trim(), model.id, [], t0, Date.now());
+  if (traceEntry) output.trace = [traceEntry];
+  return output;
 }
 async function* runStream(pieces, args, opts) {
-  const model = pickModel2(opts.model);
+  const model = pickModel(opts.model);
   if (!model) throw new Error("pizx/\u03C0: No AI models configured");
   for await (const ev of streamSimple(model, makeContext(pieces, args, opts), makeOpts(opts))) {
     if (ev.type === "text_delta") yield ev.delta;
@@ -2846,7 +2861,10 @@ function makePi(opts = {}) {
 var \u03C0 = makePi();
 
 // src/pi-agent.ts
-import { createAgentSession as createAgentSession2 } from "@earendil-works/pi-coding-agent";
+import {
+  createAgentSession as createAgentSession2,
+  DefaultResourceLoader
+} from "@earendil-works/pi-coding-agent";
 var _agentDefaults = {
   quiet: false,
   maxTurns: 10
@@ -2878,24 +2896,49 @@ var AgentOutput = class {
 var AgentPromise = class extends Promise {
 };
 var _sharedSession = null;
-async function getSession(opts) {
-  if (_sharedSession && !opts.model) return _sharedSession;
-  const result = await createAgentSession2({
-    cwd: opts.cwd,
-    thinkingLevel: opts.thinkingLevel,
-    tools: opts.tools,
-    excludeTools: opts.excludeTools
+function createLoader(opts) {
+  const hasSystem = opts.system !== void 0;
+  const hasAppend = opts.appendSystemPrompt !== void 0;
+  const hasSkills = opts.skills && opts.skills.length > 0;
+  if (!hasSystem && !hasAppend && !hasSkills) return void 0;
+  return new DefaultResourceLoader({
+    cwd: opts.cwd ?? process.cwd(),
+    agentDir: "",
+    systemPrompt: opts.system,
+    appendSystemPrompt: opts.appendSystemPrompt ? [opts.appendSystemPrompt] : void 0
   });
-  _sharedSession = result.session;
-  return _sharedSession;
 }
-function build3(pieces, args) {
-  let s = "";
-  for (let i = 0; i < pieces.length; i++) {
-    s += pieces[i];
-    if (i < args.length) s += String(args[i]);
+async function getSession(opts) {
+  if (_sharedSession && !opts.model) return _sharedSession;
+  try {
+    const loader = createLoader(opts);
+    if (opts.skills && opts.skills.length > 0 && loader) {
+      const skillMap = await loadSkillContents(opts.skills);
+      const skillPaths = [];
+      for (const [name] of skillMap) {
+        for (const base of SKILL_PATHS) {
+          skillPaths.push({
+            path: `${base}/${name}`,
+            metadata: { source: "pizx", scope: "project", origin: "top-level" }
+          });
+        }
+      }
+      if (skillPaths.length > 0) {
+        loader.extendResources({ skillPaths });
+      }
+    }
+    const result = await createAgentSession2({
+      cwd: opts.cwd,
+      thinkingLevel: opts.thinkingLevel,
+      tools: opts.tools,
+      excludeTools: opts.excludeTools,
+      resourceLoader: loader
+    });
+    _sharedSession = result.session;
+    return _sharedSession;
+  } catch (err) {
+    throw new Error(`pizx/\u03A0: Failed to create agent session: ${getErrorMessage(err)}`);
   }
-  return s.trim();
 }
 function getMessageText(msg) {
   const content = msg.content;
@@ -2917,7 +2960,7 @@ function getLastAssistantText(session) {
   return "";
 }
 async function execute16(pieces, args, opts) {
-  const prompt = build3(pieces, args);
+  const prompt = build(pieces, args);
   const session = await getSession(opts);
   const t0 = Date.now();
   if (!opts.quiet) {
@@ -2928,15 +2971,12 @@ async function execute16(pieces, args, opts) {
     await session.sendUserMessage(prompt);
     const t1 = Date.now();
     const text = getLastAssistantText(session);
-    const turnCount = session.messages.filter(
-      (m) => m.role === "assistant"
-    ).length;
+    const turnCount = session.messages.filter((m) => m.role === "assistant").length;
     return new AgentOutput(text || "(no assistant response)", turnCount, t0, t1);
   } catch (err) {
     const t1 = Date.now();
-    const msg = err instanceof Error ? err.message : String(err);
     console.error("\u03A0 error:", err);
-    return new AgentOutput(`\u03A0 error: ${msg}`, 0, t0, t1);
+    return new AgentOutput(`\u03A0 error: ${getErrorMessage(err)}`, 0, t0, t1);
   }
 }
 function makeAgent(opts = {}) {
@@ -2998,7 +3038,7 @@ function parseArgs(argv) {
         if (argv[i + 1] && !argv[i + 1].startsWith("-")) flags.model = argv[++i];
         break;
       case "--system":
-        if (argv[i + 1]) flags.system = argv[++i];
+        if (argv[i + 1] && !argv[i + 1].startsWith("-")) flags.system = argv[++i];
         break;
       case "-q":
       case "--quiet":
@@ -3039,6 +3079,7 @@ function printHelp() {
    \`\u039B\`   Pipeline \u2014 sequential agent chain
    \`\u03A8\`   Critique \u2014 generate, critique, improve
    \`\u03A9\`   Orchestrator \u2014 plan, dispatch, synthesize
+   \`\u039D\`   Nu \u2014 Self-Organizing Teams
 
  ${chalk.bold("Communication Patterns")}
    \`\u0398\`   Thread \u2014 multi-agent conversation
@@ -3048,6 +3089,8 @@ function printHelp() {
  ${chalk.bold("Orchestration Topologies")}
    \`\u0391\`   Adaptive \u2014 self-adjusting orchestration
    \`\u0393\`   Graph \u2014 DAG-based task execution
+   \`\u03A7\`   Chi \u2014 Cross-Agent Learning
+   \`\u03A4\`   Tau \u2014 Tool-Mediated Orchestration
 
  ${chalk.bold("Example Script")}
    #!/usr/bin/env pizx
@@ -3078,7 +3121,7 @@ async function runPrintMode(flags, args) {
 `);
     }
   } catch (err) {
-    console.error("pizx: pi-ai error:", err instanceof Error ? err.message : err);
+    console.error("pizx: pi-ai error:", getErrorMessage(err));
     process2.exit(1);
   }
 }
@@ -3098,6 +3141,9 @@ async function runScriptMode(scriptPath) {
   g.\u03A9 = \u03A9;
   g.\u0398 = \u0398;
   g.\u039C = \u039C;
+  g.\u039D = \u039D;
+  g.\u03A4 = \u03A4;
+  g.\u03A7 = \u03A7;
   g.\u0392 = \u0392;
   g.\u0391 = \u0391;
   g.\u0393 = \u0393;
@@ -3109,11 +3155,7 @@ async function runScriptMode(scriptPath) {
   try {
     await import(url.pathToFileURL(absPath).toString());
   } catch (err) {
-    if (err instanceof Error) {
-      console.error("pizx:", err.message);
-    } else {
-      console.error("pizx:", err);
-    }
+    console.error("pizx:", getErrorMessage(err));
     process2.exit(1);
   }
 }
@@ -3140,7 +3182,7 @@ async function main() {
   await runScriptMode(script);
 }
 main().catch((err) => {
-  console.error("pizx:", err instanceof Error ? err.message : err);
+  console.error("pizx:", getErrorMessage(err));
   process2.exit(1);
 });
 //# sourceMappingURL=cli.js.map