@topce/pizx 0.1.0

package/dist/index.js

@@ -0,0 +1,2963 @@
+// src/index.ts
+export * from "zx";
+
+// src/patterns/types.ts
+import { completeSimple, getEnvApiKey, getModels, getProviders } from "@earendil-works/pi-ai";
+
+// src/load-pi-settings.ts
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function getPiAgentDir() {
+  const envDir = process.env.PI_CODING_AGENT_DIR;
+  if (envDir) return envDir;
+  return join(homedir(), ".pi", "agent");
+}
+function isPiInstalled() {
+  return existsSync(join(getPiAgentDir(), "auth.json"));
+}
+function loadPiSettings(agentDir) {
+  const dir = agentDir ?? getPiAgentDir();
+  const path = join(dir, "settings.json");
+  if (!existsSync(path)) return {};
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return {
+      defaultModel: parsed.defaultModel ?? void 0,
+      defaultProvider: parsed.defaultProvider ?? void 0,
+      defaultThinkingLevel: parsed.defaultThinkingLevel ?? void 0
+    };
+  } catch {
+    return {};
+  }
+}
+
+// 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;
+  /** 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();
+}
+var _piSettings;
+function getPiDefaults() {
+  if (_piSettings === void 0) {
+    _piSettings = isPiInstalled() ? loadPiSettings() : {};
+  }
+  return _piSettings;
+}
+function allModels() {
+  const result = [];
+  for (const p of getProviders()) {
+    const ms = getModels(p);
+    if (ms && ms.length > 0) result.push(...ms);
+  }
+  return result;
+}
+function getConfiguredProviders() {
+  return getProviders().filter((p) => getEnvApiKey(p) !== void 0);
+}
+function configuredModels() {
+  const configured = new Set(getConfiguredProviders());
+  return allModels().filter((m) => configured.has(m.provider));
+}
+function findModelById(id) {
+  const all = allModels();
+  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 pickModel(preferred) {
+  if (preferred) {
+    const hit = findModelById(preferred);
+    if (hit) return hit;
+  }
+  const settings = getPiDefaults();
+  if (settings.defaultModel) {
+    const hit = findModelById(settings.defaultModel);
+    if (hit) return hit;
+  }
+  if (settings.defaultProvider) {
+    const providerModels = getModels(settings.defaultProvider);
+    if (providerModels && providerModels.length > 0) {
+      const configured = new Set(getConfiguredProviders());
+      if (configured.has(settings.defaultProvider)) {
+        return providerModels[0];
+      }
+    }
+  }
+  const available = configuredModels();
+  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 = allModels();
+  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];
+}
+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.");
+  const result = await completeSimple(
+    model,
+    {
+      systemPrompt: opts.system,
+      messages: [{ role: "user", content: prompt, timestamp: Date.now() }]
+    },
+    {
+      maxTokens: opts.maxTokens ?? 4096,
+      reasoning: opts.thinkingLevel ?? "medium"
+    }
+  );
+  const text = result.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+  return text.trim();
+}
+
+// src/patterns/adaptive.ts
+var defaults = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  maxSteps: 5,
+  qualityThreshold: 0.8
+};
+var AdaptiveStep = class {
+  constructor(step, action, result, quality, adaptation) {
+    this.step = step;
+    this.action = action;
+    this.result = result;
+    this.quality = quality;
+    this.adaptation = adaptation;
+  }
+  step;
+  action;
+  result;
+  quality;
+  adaptation;
+};
+var AdaptiveOutput = class extends PatternOutput {
+  constructor(text, finalResult, steps, totalSteps, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.finalResult = finalResult;
+    this.steps = steps;
+    this.totalSteps = totalSteps;
+  }
+  finalResult;
+  steps;
+  totalSteps;
+};
+var PLAN_SYSTEM = `You are an adaptive workflow planner. Given a goal, produce a step-by-step execution plan.
+
+Output format:
+PLAN:
+1. Step description
+2. Step description
+...
+
+Each step must be concrete and self-contained. Generate at most 5 steps.`;
+var EXECUTE_SYSTEM = `You are a task executor. Execute the assigned step. Output your result directly \u2014 no meta-commentary. Be specific and actionable.`;
+var EVALUATE_SYSTEM = `You are a quality evaluator. Review the execution result and provide:
+1. Quality score: a number from 0.0 (poor) to 1.0 (perfect)
+2. Brief assessment (1 sentence)
+3. Adaptation recommendation: "CONTINUE" to proceed as planned, "REFINE" to redo this step, "SKIP_NEXT" to skip the next planned step, or "ADD [description]" to insert a new step before continuing
+
+Output format:
+SCORE: 0.XX
+ASSESSMENT: (one sentence)
+ADAPTATION: CONTINUE | REFINE | SKIP_NEXT | ADD (description)`;
+async function execute(pieces, args, opts) {
+  const goal = build(pieces, args);
+  const t0 = Date.now();
+  const plannerModel = opts.plannerModel ?? opts.model;
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(`\u0391: Adaptive \u2014 "${goal.slice(0, 80)}${goal.length > 80 ? "..." : ""}"
+`);
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Planning...\n");
+  const planText = await ask(goal, {
+    model: plannerModel,
+    maxTokens: opts.maxTokens,
+    thinkingLevel: "high",
+    system: PLAN_SYSTEM
+  });
+  const planLines = planText.split("\n");
+  const plannedSteps = [];
+  for (const line of planLines) {
+    const match = line.match(/^\d+[.)]\s*(.+)/);
+    if (match) plannedSteps.push(match[1].trim());
+  }
+  const steps = plannedSteps.length > 0 ? plannedSteps : [goal];
+  if (!opts.quiet) {
+    process.stderr.write(`  \u2192 ${steps.length} step(s) planned
+`);
+    for (let i = 0; i < steps.length; i++) {
+      const s = steps[i];
+      process.stderr.write(`      [${i + 1}] ${s.slice(0, 60)}${s.length > 60 ? "..." : ""}
+`);
+    }
+  }
+  const adaptiveSteps = [];
+  const maxSteps = opts.maxSteps ?? 5;
+  const threshold = opts.qualityThreshold ?? 0.8;
+  let stepIndex = 0;
+  let executionStep = 0;
+  while (stepIndex < steps.length && executionStep < maxSteps) {
+    executionStep++;
+    const currentStep = steps[stepIndex];
+    if (!opts.quiet)
+      process.stderr.write(`  \u2192 Step ${executionStep}: ${currentStep.slice(0, 60)}...
+`);
+    const result = await ask(currentStep, {
+      model: workerModel,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: opts.thinkingLevel,
+      system: EXECUTE_SYSTEM
+    });
+    const evaluation = await ask(
+      `Goal: ${goal}
+Step executed: ${currentStep}
+Result: ${result}
+
+Evaluate the result.`,
+      {
+        model: plannerModel,
+        maxTokens: 512,
+        thinkingLevel: "high",
+        system: EVALUATE_SYSTEM
+      }
+    );
+    const scoreMatch = evaluation.match(/SCORE:\s*([\d.]+)/i);
+    const assessMatch = evaluation.match(/ASSESSMENT:\s*(.+)/i);
+    const adaptMatch = evaluation.match(/ADAPTATION:\s*(.+)/i);
+    const quality = scoreMatch ? parseFloat(scoreMatch[1]) : 0.5;
+    const assessment = assessMatch?.[1] ?? "(no assessment)";
+    const adaptation = adaptMatch?.[1] ?? "CONTINUE";
+    adaptiveSteps.push(new AdaptiveStep(executionStep, currentStep, result, quality, adaptation));
+    if (!opts.quiet) {
+      process.stderr.write(`      Quality: ${quality.toFixed(2)} | ${assessment.slice(0, 60)}...
+`);
+      process.stderr.write(`      Adaptation: ${adaptation}
+`);
+    }
+    if (quality >= threshold) {
+      if (!opts.quiet)
+        process.stderr.write(`  \u2713 Quality threshold (${threshold}) met \u2014 stopping early
+`);
+      break;
+    }
+    const adaptUpper = adaptation.toUpperCase();
+    if (adaptUpper.startsWith("REFINE")) {
+    } else if (adaptUpper.startsWith("SKIP_NEXT")) {
+      stepIndex += 2;
+    } else if (adaptUpper.startsWith("ADD")) {
+      const newStep = adaptation.replace(/^ADD\s*/i, "");
+      steps.splice(stepIndex + 1, 0, newStep);
+      stepIndex++;
+    } else {
+      stepIndex++;
+    }
+  }
+  const t1 = Date.now();
+  const finalResult = adaptiveSteps.length > 0 ? adaptiveSteps[adaptiveSteps.length - 1].result : "";
+  const summary = adaptiveSteps.map(
+    (s) => `Step ${s.step}: ${s.action.slice(0, 80)}...
+  Quality: ${s.quality.toFixed(2)}
+  Adaptation: ${s.adaptation}`
+  ).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();
+
+// src/patterns/broadcast.ts
+var defaults2 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  workers: 4
+};
+var ROLE_SETS = {
+  2: [
+    "Technical Expert \u2014 evaluate technical feasibility",
+    "Business Expert \u2014 evaluate business viability"
+  ],
+  3: [
+    "Technical Expert \u2014 evaluate technical feasibility",
+    "Business Expert \u2014 evaluate business viability",
+    "User Expert \u2014 evaluate user experience and adoption"
+  ],
+  4: [
+    "Technical Expert",
+    "Business Expert",
+    "User Expert",
+    "Risk Expert \u2014 identify risks, compliance, and security concerns"
+  ],
+  5: [
+    "Technical Expert",
+    "Business Expert",
+    "User Expert",
+    "Risk Expert",
+    "Innovation Expert \u2014 suggest novel approaches and alternatives"
+  ]
+};
+var BroadcastResponse = class {
+  constructor(role, response, success, error) {
+    this.role = role;
+    this.response = response;
+    this.success = success;
+    this.error = error;
+  }
+  role;
+  response;
+  success;
+  error;
+};
+var BroadcastOutput = class extends PatternOutput {
+  constructor(text, synthesis, responses, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.synthesis = synthesis;
+    this.responses = responses;
+  }
+  synthesis;
+  responses;
+};
+var WORKER_PROMPT = `You are a {role}.
+
+A question has been broadcast to you and your fellow specialists:
+
+{question}
+
+Provide your expert analysis and recommendation from your specific perspective.
+Be thorough but concise \u2014 under 200 words.`;
+var SYNTHESIS_SYSTEM = `You are a lead strategist. You broadcast a question to your specialist team. Now synthesize their collective responses into a coherent, actionable recommendation. Weigh conflicting opinions, identify consensus, and present the best path forward.`;
+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 plannerModel = opts.plannerModel ?? opts.model;
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(`\u0392: Broadcast \u2014 ${workerCount} worker(s)
+`);
+    process.stderr.write(
+      `  Question: "${question.slice(0, 80)}${question.length > 80 ? "..." : ""}"
+`
+    );
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Broadcasting to workers...\n");
+  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
+      });
+      return new BroadcastResponse(role, text, true);
+    })
+  );
+  const responses = [];
+  for (const r of broadcastResults) {
+    if (r.status === "fulfilled") {
+      responses.push(r.value);
+    } else {
+      const msg = r.reason instanceof Error ? r.reason.message : String(r.reason);
+      responses.push(new BroadcastResponse("(failed)", "", false, msg));
+    }
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Synthesizing responses...\n");
+  const responsesText = responses.map((wr) => `--- ${wr.role} ---
+${wr.response}`).join("\n\n");
+  const synthesis = await ask(
+    `Original question:
+${question}
+
+Worker responses:
+${responsesText}
+
+Synthesize a cohesive, actionable recommendation.`,
+    {
+      model: plannerModel,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: "high",
+      system: SYNTHESIS_SYSTEM
+    }
+  );
+  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;
+}
+var \u0392 = makeBroadcast();
+
+// src/patterns/chi.ts
+var defaults3 = {
+  maxTokens: 4096,
+  thinkingLevel: "high"
+};
+var LearningInsight = class {
+  constructor(category, pattern, recommendation, confidence) {
+    this.category = category;
+    this.pattern = pattern;
+    this.recommendation = recommendation;
+    this.confidence = confidence;
+  }
+  category;
+  pattern;
+  recommendation;
+  confidence;
+};
+var ChiOutput = class extends PatternOutput {
+  constructor(text, insights, summary, suggestedChanges, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.insights = insights;
+    this.summary = summary;
+    this.suggestedChanges = suggestedChanges;
+  }
+  insights;
+  summary;
+  suggestedChanges;
+};
+var ANALYSIS_SYSTEM = `You are an agent team performance analyst. Review a multi-agent execution and extract structured learnings.
+
+Analyze across these 4 categories:
+
+1. COMMUNICATION: How well did agents share information? Bottlenecks? Gaps?
+2. WORKFLOW: Was execution order optimal? Unnecessary or missing steps?
+3. QUALITY: Were there gaps, inconsistencies, or errors in outputs?
+4. EFFICIENCY: Where could parallelism, caching, or batching improve speed?
+
+For EACH category, output exactly:
+
+CATEGORY: (communication | workflow | quality | efficiency)
+PATTERN: (one specific, observed pattern \u2014 be concrete)
+RECOMMENDATION: (one actionable, specific improvement)
+CONFIDENCE: 0.XX
+
+After all categories, output:
+
+SUMMARY: (2-3 sentence executive summary of key findings)
+
+CHANGES: (concrete, specific changes to agent roles, prompts, or workflow structure \u2014 cite specific phases or prompts that should change)`;
+function resolveInput(opts, template) {
+  if (opts.trace) return opts.trace;
+  if (opts.source) {
+    const sourceType = opts.source.constructor.name;
+    return `Execution trace from ${sourceType} pattern:
+
+${opts.source.text}`;
+  }
+  return `Description of an agent execution:
+
+${template}
+
+(Analyze this described execution and extract learnings.)`;
+}
+function parseInsights(response) {
+  const insights = [];
+  const categoryRegex = /CATEGORY\s*:\s*(\w+)[\s\S]*?PATTERN\s*:\s*(.+?)\nRECOMMENDATION\s*:\s*(.+?)\nCONFIDENCE\s*:\s*([\d.]+)/gi;
+  let match;
+  while ((match = categoryRegex.exec(response)) !== null) {
+    const category = match[1].trim().toLowerCase();
+    const pattern = match[2].trim();
+    const recommendation = match[3].trim();
+    const confidence = parseFloat(match[4]) || 0.5;
+    if (["communication", "workflow", "quality", "efficiency"].includes(category)) {
+      insights.push(
+        new LearningInsight(category, pattern, recommendation, Math.min(1, Math.max(0, confidence)))
+      );
+    }
+  }
+  const summaryMatch = response.match(/SUMMARY\s*:\s*(.+?)(?:\n\n|$)/is);
+  const summary = summaryMatch?.[1]?.trim() ?? "No summary extracted.";
+  const changesMatch = response.match(/CHANGES\s*:\s*(.+?)$/is);
+  const suggestedChanges = changesMatch?.[1]?.trim() ?? "No specific changes recommended.";
+  return { insights, summary, suggestedChanges };
+}
+async function execute3(pieces, args, opts) {
+  const template = build(pieces, args);
+  const input = resolveInput(opts, template);
+  const t0 = Date.now();
+  const plannerModel = opts.plannerModel ?? opts.model;
+  if (!opts.quiet) {
+    const label = opts.source ? opts.source.constructor.name : opts.trace ? "trace" : "analysis";
+    process.stderr.write(`\u03A7: Cross-Agent Learning \u2014 analyzing ${label}
+`);
+  }
+  const response = await ask(input, {
+    model: plannerModel,
+    maxTokens: opts.maxTokens,
+    thinkingLevel: opts.thinkingLevel,
+    system: ANALYSIS_SYSTEM
+  });
+  const { insights, summary, suggestedChanges } = parseInsights(response);
+  const t1 = Date.now();
+  const text = [
+    `Insights: ${insights.length} extracted`,
+    insights.map(
+      (i) => `  [${i.category}] ${i.pattern.slice(0, 80)}... (confidence: ${i.confidence.toFixed(2)})`
+    ).join("\n"),
+    `
+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;
+}
+var \u03A7 = makeChi();
+
+// src/patterns/critique.ts
+var defaults4 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  rounds: 1
+};
+var CritiqueRound = class {
+  constructor(content, critique, round) {
+    this.content = content;
+    this.critique = critique;
+    this.round = round;
+  }
+  content;
+  critique;
+  round;
+};
+var CritiqueOutput = class extends PatternOutput {
+  constructor(text, finalContent, rounds, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.finalContent = finalContent;
+    this.rounds = rounds;
+  }
+  finalContent;
+  rounds;
+};
+var CRITIQUE_SYSTEM = `You are a thorough, constructive critic. Review the following content and identify:
+1. Strengths (what works well)
+2. Weaknesses (what could be improved)
+3. Specific suggestions for improvement
+
+Be specific, actionable, and constructive. Focus on substance, not style.`;
+var IMPROVE_SYSTEM = `You are a skilled editor. Revise the original content based on the critique provided.
+Incorporate the feedback while maintaining the original intent and voice.
+Output ONLY the improved content \u2014 no commentary or explanation.`;
+async function execute4(pieces, args, opts) {
+  const prompt = build(pieces, args);
+  const t0 = Date.now();
+  const rounds = Math.min(opts.rounds ?? 1, 3);
+  const plannerModel = opts.plannerModel ?? opts.model;
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(
+      `\u03A8: Critique \u2014 "${prompt.slice(0, 80)}${prompt.length > 80 ? "..." : ""}"
+`
+    );
+    process.stderr.write(`  \u2192 ${rounds} critique round(s)
+`);
+  }
+  const critiqueRounds = [];
+  let currentContent = "";
+  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
+      });
+    } else {
+      if (!opts.quiet) process.stderr.write(`  \u2192 Improving (round ${r + 1})...
+`);
+      const prevCritique = critiqueRounds[r - 1]?.critique ?? "";
+      currentContent = await ask(
+        `Original request: ${prompt}
+
+Critique:
+${prevCritique}
+
+Content to improve:
+${currentContent}
+
+Revise the content based on the critique.`,
+        {
+          model: workerModel,
+          maxTokens: opts.maxTokens,
+          thinkingLevel: opts.thinkingLevel,
+          system: IMPROVE_SYSTEM
+        }
+      );
+    }
+    if (!opts.quiet) process.stderr.write(`  \u2192 Critiquing (round ${r + 1})...
+`);
+    const critique = await ask(currentContent, {
+      model: plannerModel,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: opts.thinkingLevel,
+      system: CRITIQUE_SYSTEM
+    });
+    critiqueRounds.push(new CritiqueRound(currentContent, critique, r));
+  }
+  const t1 = Date.now();
+  const finalContent = currentContent;
+  const summary = critiqueRounds.map(
+    (cr) => `Round ${cr.round + 1}:
+${cr.content.slice(0, 200)}${cr.content.length > 200 ? "..." : ""}
+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();
+
+// src/patterns/debate.ts
+var defaults5 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  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;
+    this.argument = argument;
+    this.round = round;
+  }
+  role;
+  argument;
+  round;
+};
+var DebateOutput = class extends PatternOutput {
+  constructor(text, conclusion, perspectives, rounds, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.conclusion = conclusion;
+    this.perspectives = perspectives;
+    this.rounds = rounds;
+  }
+  conclusion;
+  perspectives;
+  rounds;
+};
+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.`;
+var SYNTHESIS_SYSTEM2 = `You are a neutral moderator. Synthesize the different perspectives into a balanced, reasoned conclusion. Weigh the evidence from each perspective and provide a final recommendation. Be specific and actionable.`;
+async function execute5(pieces, args, opts) {
+  const question = build(pieces, args);
+  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 plannerModel = opts.plannerModel ?? opts.model;
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(
+      `\u0394: Debate \u2014 "${question.slice(0, 80)}${question.length > 80 ? "..." : ""}"
+`
+    );
+    process.stderr.write(`  \u2192 ${roles.length} perspective(s), ${totalRounds} round(s)
+`);
+  }
+  const allPerspectives = [];
+  let debateHistory = `Question: ${question}
+`;
+  if (!opts.quiet) process.stderr.write("  \u2192 Round 1: Initial perspectives...\n");
+  const round1Results = await Promise.allSettled(
+    roles.map(
+      (role) => ask(question, {
+        model: workerModel,
+        maxTokens: opts.maxTokens,
+        thinkingLevel: opts.thinkingLevel,
+        system: PERSPECTIVE_SYSTEM(role)
+      }).then((text) => new DebatePerspective(role, text, 1))
+    )
+  );
+  const round1Perspectives = [];
+  round1Results.forEach((r, i) => {
+    if (r.status === "fulfilled") {
+      round1Perspectives.push(r.value);
+    } else {
+      round1Perspectives.push(
+        new DebatePerspective(roles[i] ?? `Perspective ${i + 1}`, `(failed: ${r.reason})`, 1)
+      );
+    }
+  });
+  allPerspectives.push(...round1Perspectives);
+  debateHistory += `${round1Perspectives.map((p) => `[Round 1] ${p.role}: ${p.argument}`).join("\n\n")}
+`;
+  for (let round = 2; round <= totalRounds; round++) {
+    if (!opts.quiet) process.stderr.write(`  \u2192 Round ${round}: Rebuttals...
+`);
+    const roundResults = await Promise.allSettled(
+      roles.map((role) => {
+        const othersText = allPerspectives.filter((p) => p.role !== role).map((p) => `[${p.role}, Round ${p.round}]: ${p.argument}`).join("\n\n");
+        const ownText = allPerspectives.filter((p) => p.role === role).map((p) => `[Your Round ${p.round}]: ${p.argument}`).join("\n\n");
+        const prompt = `Question: ${question}
+
+Your previous position:
+${ownText}
+
+Counter-arguments from other perspectives:
+${othersText}
+
+Refine your position. Address the counter-arguments directly. Strengthen your argument with rebuttals.`;
+        return ask(prompt, {
+          model: workerModel,
+          maxTokens: opts.maxTokens,
+          thinkingLevel: opts.thinkingLevel,
+          system: REBUTTAL_SYSTEM(role)
+        }).then((text) => new DebatePerspective(role, text, round));
+      })
+    );
+    const roundPerspectives = [];
+    roundResults.forEach((r, i) => {
+      if (r.status === "fulfilled") {
+        roundPerspectives.push(r.value);
+      } else {
+        roundPerspectives.push(
+          new DebatePerspective(roles[i] ?? `Perspective ${i + 1}`, `(failed: ${r.reason})`, round)
+        );
+      }
+    });
+    allPerspectives.push(...roundPerspectives);
+    debateHistory += `${roundPerspectives.map((p) => `[Round ${round}] ${p.role}: ${p.argument}`).join("\n\n")}
+`;
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Synthesizing perspectives...\n");
+  const conclusion = await ask(
+    `${debateHistory}
+
+Synthesize a balanced conclusion from the full debate above. Weigh the evidence from all rounds.`,
+    {
+      model: plannerModel,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: "high",
+      system: SYNTHESIS_SYSTEM2
+    }
+  );
+  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;
+}
+var \u0394 = makeDebate();
+
+// src/patterns/fleet.ts
+var defaults6 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  concurrency: 5
+};
+var FleetMemberOutput = class {
+  constructor(task, text, success, error) {
+    this.task = task;
+    this.text = text;
+    this.success = success;
+    this.error = error;
+  }
+  task;
+  text;
+  success;
+  error;
+};
+var FleetOutput = class extends PatternOutput {
+  constructor(text, members, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.members = members;
+  }
+  members;
+  /** Number of successful members */
+  get successCount() {
+    return this.members.filter((m) => m.success).length;
+  }
+  /** Number of failed members */
+  get failureCount() {
+    return this.members.filter((m) => !m.success).length;
+  }
+};
+function parseTasks(template, explicitTasks) {
+  if (explicitTasks && explicitTasks.length > 0) return explicitTasks;
+  const lines = template.split("\n").map((l) => l.trim()).filter(Boolean);
+  const bullets = lines.filter((l) => /^[-*]\s/.test(l));
+  if (bullets.length > 1) return bullets.map((b) => b.replace(/^[-*]\s+/, ""));
+  const numbered = lines.filter((l) => /^\d+[.)]\s/.test(l));
+  if (numbered.length > 1) return numbered.map((n) => n.replace(/^\d+[.)]\s+/, ""));
+  if (lines.length > 1) return lines;
+  return [template];
+}
+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) {
+  const model = workerModel ?? opts.model;
+  try {
+    const text = await ask(task, {
+      model,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: opts.thinkingLevel,
+      system: 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);
+  }
+}
+async function execute6(pieces, args, opts) {
+  const template = build(pieces, args);
+  const tasks = parseTasks(template, opts.tasks);
+  const t0 = Date.now();
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(`\u03A6: Fleet executing ${tasks.length} task(s) in parallel
+`);
+    for (let i = 0; i < tasks.length; i++) {
+      const t = tasks[i];
+      process.stderr.write(`  [${i + 1}] ${t.slice(0, 60)}${t.length > 60 ? "..." : ""}
+`);
+    }
+  }
+  const results = [];
+  const concurrency = opts.concurrency ?? 5;
+  for (let i = 0; i < tasks.length; i += concurrency) {
+    const batch = tasks.slice(i, i + concurrency);
+    const batchResults = await Promise.allSettled(
+      batch.map((task) => executeTask(task, opts, workerModel))
+    );
+    batchResults.forEach((r, idx) => {
+      if (r.status === "fulfilled") {
+        results.push(r.value);
+      } else {
+        results.push(new FleetMemberOutput(batch[idx], "", false, r.reason?.toString()));
+      }
+    });
+  }
+  const t1 = Date.now();
+  const summary = results.map(
+    (m, i) => `[${i + 1}] ${m.task}
+  ${m.success ? "\u2713" : "\u2717"} ${m.text.slice(0, 200)}${m.text.length > 200 ? "..." : ""}`
+  ).join("\n\n");
+  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;
+}
+var \u03A6 = makeFleet();
+
+// src/patterns/graph.ts
+var defaults7 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium"
+};
+var GraphNodeResult = class {
+  constructor(nodeId, task, output, success) {
+    this.nodeId = nodeId;
+    this.task = task;
+    this.output = output;
+    this.success = success;
+  }
+  nodeId;
+  task;
+  output;
+  success;
+};
+var GraphOutput = class extends PatternOutput {
+  constructor(text, finalOutput, nodeResults, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.finalOutput = finalOutput;
+    this.nodeResults = nodeResults;
+  }
+  finalOutput;
+  nodeResults;
+};
+function parseGraph(template, separator) {
+  const sep = separator ?? "\u2192";
+  const parts = template.split(sep).map((s) => s.trim()).filter(Boolean);
+  if (parts.length <= 1) {
+    return {
+      nodes: [{ id: "root", task: template.trim() }],
+      edges: []
+    };
+  }
+  const nodes = [];
+  const edges = [];
+  for (let i = 0; i < parts.length; i++) {
+    const id = `step_${i + 1}`;
+    nodes.push({ id, task: parts[i] });
+    if (i > 0) {
+      edges.push({ from: nodes[i - 1].id, to: id });
+    }
+  }
+  return { nodes, edges };
+}
+var NODE_SYSTEM = `You are a task specialist. Execute the assigned task and output your result. Be thorough but concise. Output only the result \u2014 no meta-commentary.`;
+function topoBatches(nodes, edges) {
+  const nodeIds = new Set(nodes.map((n) => n.id));
+  const inDegree = /* @__PURE__ */ new Map();
+  const adj = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    inDegree.set(id, 0);
+    adj.set(id, []);
+  }
+  for (const edge of edges) {
+    if (!nodeIds.has(edge.from) || !nodeIds.has(edge.to)) continue;
+    inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
+    adj.get(edge.from)?.push(edge.to);
+  }
+  const batches = [];
+  const ready = [];
+  for (const [id, deg] of inDegree) {
+    if (deg === 0) ready.push(id);
+  }
+  while (ready.length > 0) {
+    batches.push([...ready]);
+    const nextBatch = [];
+    for (const node of ready) {
+      for (const neighbor of adj.get(node) ?? []) {
+        const newDeg = (inDegree.get(neighbor) ?? 1) - 1;
+        inDegree.set(neighbor, newDeg);
+        if (newDeg === 0) nextBatch.push(neighbor);
+      }
+    }
+    ready.length = 0;
+    ready.push(...nextBatch);
+  }
+  return batches;
+}
+async function execute7(pieces, args, opts) {
+  const template = build(pieces, args);
+  const t0 = Date.now();
+  const { nodes, edges } = opts.graph ?? parseGraph(template, opts.separator);
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(`\u0393: DAG Graph \u2014 ${nodes.length} node(s), ${edges.length} edge(s)
+`);
+    for (const n of nodes) {
+      process.stderr.write(`  [${n.id}] ${n.task.slice(0, 60)}${n.task.length > 60 ? "..." : ""}
+`);
+    }
+  }
+  const batches = topoBatches(nodes, edges);
+  const results = /* @__PURE__ */ new Map();
+  const nodeResults = [];
+  for (let bi = 0; bi < batches.length; bi++) {
+    const batch = batches[bi];
+    if (!opts.quiet)
+      process.stderr.write(`  \u2192 Batch ${bi + 1}/${batches.length}: ${batch.join(", ")}
+`);
+    const batchResults = await Promise.allSettled(
+      batch.map(async (nodeId) => {
+        const node = nodes.find((n) => n.id === nodeId);
+        if (!node) return { nodeId, task: "", text: "", success: false };
+        const deps = edges.filter((e) => e.to === nodeId);
+        let context = node.task;
+        if (deps.length > 0) {
+          const depResults = deps.map((d) => {
+            const depResult = results.get(d.from);
+            return depResult ? `[${d.from} output]: ${depResult}` : "";
+          }).filter(Boolean).join("\n\n");
+          if (depResults) {
+            context = `Previous results:
+${depResults}
+
+Your task: ${node.task}`;
+          }
+        }
+        const text = await ask(context, {
+          model: workerModel,
+          maxTokens: opts.maxTokens,
+          thinkingLevel: opts.thinkingLevel,
+          system: NODE_SYSTEM
+        });
+        return { nodeId, task: node.task, text, success: true };
+      })
+    );
+    for (const r of batchResults) {
+      if (r.status === "fulfilled") {
+        results.set(r.value.nodeId, r.value.text);
+        nodeResults.push(
+          new GraphNodeResult(r.value.nodeId, r.value.task, r.value.text, r.value.success)
+        );
+      }
+    }
+  }
+  const t1 = Date.now();
+  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") : "";
+  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;
+}
+var \u0393 = makeGraph();
+
+// src/patterns/memory.ts
+var defaults8 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  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;
+    this.round = round;
+    this.content = content;
+  }
+  role;
+  round;
+  content;
+};
+var MemoryOutput = class extends PatternOutput {
+  constructor(text, synthesis, entries, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.synthesis = synthesis;
+    this.entries = entries;
+  }
+  synthesis;
+  entries;
+};
+var WRITER_PROMPT = `You are a specialist with role: {role}.
+
+Topic: {topic}
+
+Current findings on the shared blackboard (written by other agents):
+{context}
+
+Add your contribution to the blackboard. Be specific, add unique insights.
+Don't repeat what others have already covered \u2014 fill gaps, add depth, or challenge.
+Keep your contribution under 200 words.`;
+var CONSOLIDATOR_SYSTEM = `You are a research director. Consolidate findings from multiple specialists into a comprehensive, well-structured synthesis. Combine overlapping insights, resolve contradictions, prioritize the most impactful findings.`;
+function buildWriterPrompt(role, topic, context) {
+  return WRITER_PROMPT.replace("{role}", role).replace("{topic}", topic).replace("{context}", context || "(No prior entries yet. You are the first contributor.)");
+}
+async function execute8(pieces, args, opts) {
+  const topic = build(pieces, args);
+  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 plannerModel = opts.plannerModel ?? opts.model;
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(`\u039C: Shared Memory \u2014 ${agentCount} agent(s), ${totalRounds} round(s)
+`);
+    process.stderr.write(`  Topic: "${topic.slice(0, 80)}${topic.length > 80 ? "..." : ""}"
+`);
+  }
+  const entries = [];
+  let blackboard = "";
+  for (let round = 1; round <= totalRounds; round++) {
+    if (!opts.quiet) process.stderr.write(`  \u2192 Round ${round}/${totalRounds}
+`);
+    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
+        });
+        return { role, text };
+      })
+    );
+    for (const r of roundResults) {
+      if (r.status === "fulfilled") {
+        entries.push(new MemoryEntry(r.value.role, round, r.value.text));
+        blackboard += `
+[${r.value.role}] Round ${round}: ${r.value.text}
+`;
+      }
+    }
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Consolidating findings...\n");
+  const synthesis = await ask(
+    `Topic: ${topic}
+
+Blackboard findings:
+${blackboard}
+
+Consolidate into a comprehensive, structured synthesis.`,
+    {
+      model: plannerModel,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: "high",
+      system: CONSOLIDATOR_SYSTEM
+    }
+  );
+  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;
+}
+var \u039C = makeMemory();
+
+// src/patterns/nu.ts
+var defaults9 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  minAgents: 2,
+  maxAgents: 5
+};
+var NuRole = class {
+  constructor(name, expertise, goal) {
+    this.name = name;
+    this.expertise = expertise;
+    this.goal = goal;
+  }
+  name;
+  expertise;
+  goal;
+};
+var NuOutput = class extends PatternOutput {
+  constructor(text, negotiatedRoles, workflow, workflowReasoning, roleResults, synthesis, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.negotiatedRoles = negotiatedRoles;
+    this.workflow = workflow;
+    this.workflowReasoning = workflowReasoning;
+    this.roleResults = roleResults;
+    this.synthesis = synthesis;
+  }
+  negotiatedRoles;
+  workflow;
+  workflowReasoning;
+  roleResults;
+  synthesis;
+};
+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.
+
+Output format \u2014 one role per block, exactly as shown:
+
+ROLE:
+NAME: Security Analyst
+EXPERTISE: (1 sentence describing domain knowledge)
+GOAL: (1 sentence describing what this role must accomplish)
+
+ROLE:
+NAME: Performance Engineer
+EXPERTISE: (1 sentence)
+GOAL: (1 sentence)
+
+Propose between {min} and {max} roles. Each role must be clearly distinct.
+Output only the role blocks \u2014 no preamble, no summary.`;
+var WORKFLOW_SYSTEM = `You are a workflow designer. Given a set of agent roles, determine the best execution strategy.
+
+Rules:
+- sequential: roles depend on each other's outputs (output of A is input to B)
+- parallel: roles can work independently on different aspects
+- mixed: some roles are independent, some depend on others' outputs
+
+Output exactly:
+WORKFLOW: (sequential | parallel | mixed)
+REASONING: (1-2 sentences explaining why)`;
+var EXECUTE_SYSTEM2 = (role) => `You are a ${role.name}. Expertise: ${role.expertise}. Goal: ${role.goal}. Complete your assigned task thoroughly and concisely. Output your findings directly \u2014 no meta-commentary.`;
+var SYNTHESIS_SYSTEM3 = `You are a delivery manager. Synthesize the contributions from all team members into a coherent, comprehensive final answer. Combine overlapping insights, resolve conflicts, and prioritize the most impactful findings.`;
+async function negotiateRoles(task, opts) {
+  if (opts.roles && opts.roles.length > 0) return opts.roles;
+  const min = opts.minAgents ?? 2;
+  const max = opts.maxAgents ?? 5;
+  const prompt = NEGOTIATE_SYSTEM.replace("{min}", String(min)).replace("{max}", String(max));
+  const response = await ask(`Task: ${task}
+
+${prompt}`, {
+    model: opts.plannerModel ?? opts.model,
+    maxTokens: 2048,
+    thinkingLevel: "high"
+  });
+  const roles = [];
+  const roleBlocks = response.split(/ROLE\s*:/i).filter((b) => b.trim());
+  for (const block of roleBlocks) {
+    const nameMatch = block.match(/NAME\s*:\s*(.+)/i);
+    const expertiseMatch = block.match(/EXPERTISE\s*:\s*(.+)/i);
+    const goalMatch = block.match(/GOAL\s*:\s*(.+)/i);
+    if (nameMatch && expertiseMatch && goalMatch) {
+      roles.push(new NuRole(nameMatch[1].trim(), expertiseMatch[1].trim(), goalMatch[1].trim()));
+    }
+  }
+  if (roles.length === 0) {
+    const lines = response.split("\n").map((l) => l.trim()).filter(Boolean);
+    const fallbackRoles = lines.slice(0, max).map((line, i) => {
+      const clean = line.replace(/^[-*\d]+[.)\s]*/, "").slice(0, 60);
+      return new NuRole(`Agent ${i + 1}`, clean, `Execute sub-task: ${clean}`);
+    });
+    return fallbackRoles.length > 0 ? fallbackRoles : [new NuRole("Generalist", "Broad domain knowledge", task)];
+  }
+  return roles.slice(0, max);
+}
+async function decideWorkflow(roles, task, opts) {
+  if (roles.length <= 1)
+    return { workflow: "parallel", reasoning: "Single role \u2014 no dependencies." };
+  const rolesText = roles.map((r, i) => `${i + 1}. ${r.name}: ${r.goal}`).join("\n");
+  const response = await ask(
+    `Task: ${task}
+
+Roles:
+${rolesText}
+
+Determine the best execution strategy.`,
+    {
+      model: opts.plannerModel ?? opts.model,
+      maxTokens: 512,
+      thinkingLevel: "high",
+      system: WORKFLOW_SYSTEM
+    }
+  );
+  const wfMatch = response.match(/WORKFLOW\s*:\s*(.+)/i);
+  const reasonMatch = response.match(/REASONING\s*:\s*(.+)/i);
+  const workflowRaw = (wfMatch?.[1] ?? "parallel").trim().toLowerCase();
+  const workflow = workflowRaw.startsWith("seq") ? "sequential" : workflowRaw.startsWith("mix") ? "mixed" : "parallel";
+  return {
+    workflow,
+    reasoning: reasonMatch?.[1]?.trim() ?? "Auto-determined based on role dependencies."
+  };
+}
+async function executeRoles(roles, task, workflow, opts) {
+  const workerModel = opts.workerModel ?? opts.model;
+  const results = [];
+  if (workflow === "sequential") {
+    let context = task;
+    for (const role of roles) {
+      const output = await ask(context, {
+        model: workerModel,
+        maxTokens: opts.maxTokens,
+        thinkingLevel: opts.thinkingLevel,
+        system: EXECUTE_SYSTEM2(role)
+      });
+      results.push({ role: role.name, output });
+      context = `Previous output from ${role.name}:
+${output}
+
+Continue with: ${task}`;
+    }
+  } else {
+    const parallelResults = await Promise.allSettled(
+      roles.map(
+        (role) => ask(task, {
+          model: workerModel,
+          maxTokens: opts.maxTokens,
+          thinkingLevel: opts.thinkingLevel,
+          system: EXECUTE_SYSTEM2(role)
+        }).then((text) => ({ role: role.name, output: text })).catch((err) => ({ role: role.name, output: `(failed: ${String(err)})` }))
+      )
+    );
+    for (const r of parallelResults) {
+      if (r.status === "fulfilled") results.push(r.value);
+    }
+  }
+  return results;
+}
+async function synthesize(task, results, opts) {
+  const resultsText = results.map((r) => `--- ${r.role} ---
+${r.output}`).join("\n\n");
+  return ask(
+    `Original task:
+${task}
+
+Team member outputs:
+${resultsText}
+
+Synthesize a comprehensive final answer.`,
+    {
+      model: opts.plannerModel ?? opts.model,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: "high",
+      system: SYNTHESIS_SYSTEM3
+    }
+  );
+}
+async function execute9(pieces, args, opts) {
+  const task = build(pieces, args);
+  const t0 = Date.now();
+  const plannerModel = opts.plannerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(
+      `\u039D: Self-Organizing Teams \u2014 "${task.slice(0, 80)}${task.length > 80 ? "..." : ""}"
+`
+    );
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Negotiating roles...\n");
+  const roles = await negotiateRoles(task, { ...opts, plannerModel });
+  if (!opts.quiet) {
+    process.stderr.write(`  \u2192 ${roles.length} role(s) proposed:
+`);
+    for (const r of roles) {
+      process.stderr.write(
+        `      ${r.name}: ${r.goal.slice(0, 60)}${r.goal.length > 60 ? "..." : ""}
+`
+      );
+    }
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Deciding workflow...\n");
+  const { workflow, reasoning } = await decideWorkflow(roles, task, { ...opts, plannerModel });
+  if (!opts.quiet) {
+    process.stderr.write(`  \u2192 Workflow: ${workflow}
+`);
+    process.stderr.write(
+      `  \u2192 Reasoning: ${reasoning.slice(0, 80)}${reasoning.length > 80 ? "..." : ""}
+`
+    );
+  }
+  if (!opts.quiet) process.stderr.write(`  \u2192 Executing (${workflow})...
+`);
+  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;
+}
+var \u039D = makeNu();
+
+// src/patterns/orchestrator.ts
+var defaults10 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  workers: 3,
+  concurrency: 3
+};
+var OrchestratorWorkerResult = class {
+  constructor(task, output, success) {
+    this.task = task;
+    this.output = output;
+    this.success = success;
+  }
+  task;
+  output;
+  success;
+};
+var OrchestratorOutput = class extends PatternOutput {
+  constructor(text, plan, synthesis, workerResults, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.plan = plan;
+    this.synthesis = synthesis;
+    this.workerResults = workerResults;
+  }
+  plan;
+  synthesis;
+  workerResults;
+};
+var PLANNER_SYSTEM = `You are a senior architect and project planner. Given a high-level request, create a detailed execution plan.
+
+Output in this exact format:
+
+PLAN SUMMARY:
+(one paragraph summarizing the approach)
+
+SUB-TASKS:
+1. (specific, actionable sub-task)
+2. (specific, actionable sub-task)
+3. (specific, actionable sub-task)
+
+Each sub-task must be self-contained and independently executable.
+Generate exactly {$workerCount} sub-tasks (adjust to the requested worker count).
+Focus on concrete actions, not abstractions.`;
+var WORKER_SYSTEM = `You are a task specialist. Complete your assigned sub-task thoroughly and concisely. Output your findings, code, or analysis directly \u2014 no meta-commentary.`;
+var SYNTHESIS_SYSTEM4 = `You are a delivery manager. Synthesize the worker results into a final, coherent deliverable that fulfills the original request. Combine, reconcile, and structure the outputs. Address any gaps or conflicts.`;
+async function execute10(pieces, args, opts) {
+  const request = build(pieces, args);
+  const t0 = Date.now();
+  const workerCount = opts.workers ?? 3;
+  const plannerModel = opts.plannerModel ?? opts.model;
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(
+      `\u03A9: Orchestrator \u2014 "${request.slice(0, 80)}${request.length > 80 ? "..." : ""}"
+`
+    );
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Planning...\n");
+  const planText = await ask(request, {
+    model: plannerModel,
+    maxTokens: opts.maxTokens,
+    thinkingLevel: "high",
+    system: PLANNER_SYSTEM.replace("{$workerCount}", String(workerCount))
+  });
+  const subTasks = [];
+  const taskLines = planText.split("\n");
+  let inTasks = false;
+  for (const line of taskLines) {
+    if (line.match(/^SUB-TASKS:/i)) {
+      inTasks = true;
+      continue;
+    }
+    if (inTasks && line.match(/^\d+[.)]\s/)) {
+      subTasks.push(line.replace(/^\d+[.)]\s+/, "").trim());
+    }
+  }
+  const tasks = subTasks.length > 0 ? subTasks.slice(0, workerCount) : [request];
+  if (!opts.quiet) {
+    process.stderr.write(`  \u2192 ${tasks.length} sub-task(s) identified
+`);
+    for (let i = 0; i < tasks.length; i++) {
+      const t = tasks[i];
+      process.stderr.write(`      [${i + 1}] ${t.slice(0, 60)}${t.length > 60 ? "..." : ""}
+`);
+    }
+  }
+  const workerResults = [];
+  const concurrency = opts.concurrency ?? 3;
+  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))
+      )
+    );
+    batchResults.forEach((r) => {
+      if (r.status === "fulfilled") workerResults.push(r.value);
+    });
+  }
+  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 synthesis = await ask(
+    `Original request:
+${request}
+
+Plan:
+${planText}
+
+Worker results:
+${workerTexts}
+
+Synthesize a final deliverable.`,
+    {
+      model: plannerModel,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: "high",
+      system: SYNTHESIS_SYSTEM4
+    }
+  );
+  const t1 = Date.now();
+  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;
+}
+var \u03A9 = makeOrchestrator();
+
+// src/patterns/pipeline.ts
+var defaults11 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium"
+};
+var PipelineStageResult = class {
+  constructor(stage, output, index) {
+    this.stage = stage;
+    this.output = output;
+    this.index = index;
+  }
+  stage;
+  output;
+  index;
+};
+var PipelineOutput = class extends PatternOutput {
+  constructor(text, finalOutput, stages, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.finalOutput = finalOutput;
+    this.stages = stages;
+  }
+  finalOutput;
+  stages;
+};
+function parseStages(template, explicitStages, separator) {
+  if (explicitStages && explicitStages.length > 0) return explicitStages;
+  const sep = separator ?? "\u2192";
+  const altSep = sep === "\u2192" ? "->" : sep;
+  const bySep = template.split(sep).flatMap((s) => s.split(altSep)).map((s) => s.trim()).filter(Boolean);
+  if (bySep.length > 1) return bySep;
+  const byPipe = template.split("|").map((s) => s.trim()).filter(Boolean);
+  if (byPipe.length > 1) return byPipe;
+  const byLine = template.split("\n").map(
+    (s) => s.trim().replace(/^\d+[.)]\s*/, "").replace(/^[-*]\s*/, "")
+  ).filter(Boolean);
+  if (byLine.length > 1) return byLine;
+  return [template];
+}
+function generateStagePrompt(stage, previousOutput, isFirst) {
+  if (isFirst) {
+    return `Task: ${stage}
+
+Execute the task above.`;
+  }
+  return `Previous stage output:
+${previousOutput}
+
+Current stage: ${stage}
+
+Process the previous output according to the current stage's instructions.`;
+}
+async function execute11(pieces, args, opts) {
+  const template = build(pieces, args);
+  const stages = parseStages(template, opts.stages, opts.separator);
+  const t0 = Date.now();
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(`\u039B: Pipeline \u2014 ${stages.length} stage(s)
+`);
+    for (let i = 0; i < stages.length; i++) {
+      process.stderr.write(`  [${i + 1}] ${stages[i]}
+`);
+    }
+  }
+  const stageResults = [];
+  let currentInput = "";
+  for (let i = 0; i < stages.length; i++) {
+    const stage = stages[i];
+    const customPrompt = opts.stagePrompts?.[i];
+    if (!opts.quiet)
+      process.stderr.write(`  \u2192 Stage ${i + 1}/${stages.length}: ${stage.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));
+    currentInput = output;
+  }
+  const t1 = Date.now();
+  const finalOutput = currentInput;
+  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;
+}
+var \u039B = makePipeline();
+
+// src/patterns/ralph.ts
+import { createAgentSession } from "@earendil-works/pi-coding-agent";
+var defaults12 = {
+  maxIterations: 5,
+  useTools: true,
+  maxAgentTurns: 10,
+  thinkingLevel: "medium",
+  maxTokens: 4096
+};
+var RalphOutput = class extends PatternOutput {
+  constructor(text, iterationCount, completed, iterations, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.iterationCount = iterationCount;
+    this.completed = completed;
+    this.iterations = iterations;
+  }
+  iterationCount;
+  completed;
+  iterations;
+};
+async function executeWithTools(goal, opts) {
+  const agentModel = opts.model ? pickModel(opts.model) : void 0;
+  if (opts.model && !agentModel) {
+    throw new Error(
+      `pizx/\u03A1: model not found: "${opts.model}". Run \`pi models\` to see available models.`
+    );
+  }
+  const { session } = await createAgentSession({
+    tools: ["read", "bash", "edit", "write", "grep", "ls"],
+    ...agentModel ? { model: agentModel } : {}
+  });
+  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();
+        }
+      }
+    }
+    return "(no assistant response)";
+  } finally {
+    session.dispose();
+  }
+}
+var ANALYSIS_SYSTEM2 = `You are a senior engineer. Analyze the current state and identify what needs to change to achieve the goal. Be specific \u2014 name files and code patterns. Keep it under 200 words.`;
+var PLAN_SYSTEM2 = `You are a precise coding architect. Generate a minimal, actionable implementation plan with specific file paths and changes. Keep it under 250 words.`;
+var REVIEW_SYSTEM = `You are a quality assurance reviewer. Review the changes that were just made. Determine:
+1. Was the plan fully implemented? Answer "FULLY" or "PARTIALLY"
+2. Are there any issues? (1 sentence)
+3. Should we iterate again? Answer "ITERATE" or "DONE"
+
+Your final line MUST be either "FINAL: ITERATE" or "FINAL: DONE".`;
+async function execute12(pieces, args, opts) {
+  const goal = build(pieces, args);
+  const t0 = Date.now();
+  const iterations = [];
+  const plannerModel = opts.plannerModel ?? opts.model;
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(`\u03A1: Ralph Loop \u2014 "${goal.slice(0, 80)}${goal.length > 80 ? "..." : ""}"
+`);
+  }
+  let currentGoal = goal;
+  let iteration = 1;
+  while (iteration <= (opts.maxIterations ?? 5)) {
+    if (!opts.quiet) {
+      process.stderr.write(`\u03A1: Iteration ${iteration}/${opts.maxIterations}
+`);
+    }
+    if (!opts.quiet) process.stderr.write("  \u2192 Analyzing...\n");
+    const analysis = await ask(currentGoal, {
+      model: plannerModel,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: opts.thinkingLevel,
+      system: ANALYSIS_SYSTEM2
+    });
+    if (!opts.quiet) process.stderr.write("  \u2192 Planning...\n");
+    const plan = await ask(
+      `Goal: ${currentGoal}
+
+Analysis: ${analysis}
+
+Generate an implementation plan.`,
+      {
+        model: plannerModel,
+        maxTokens: opts.maxTokens,
+        thinkingLevel: opts.thinkingLevel,
+        system: PLAN_SYSTEM2
+      }
+    );
+    if (!opts.quiet) process.stderr.write("  \u2192 Executing...\n");
+    const result = opts.useTools ? await executeWithTools(`Implement this plan:
+${plan}
+
+Goal: ${currentGoal}`, {
+      ...opts,
+      model: workerModel
+    }) : await ask(`Implement this plan:
+${plan}
+
+Goal: ${currentGoal}`, {
+      model: workerModel,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: opts.thinkingLevel
+    });
+    if (!opts.quiet) process.stderr.write("  \u2192 Reviewing...\n");
+    const review = await ask(`Plan:
+${plan}
+
+Result:
+${result}
+
+Review the implementation.`, {
+      model: plannerModel,
+      maxTokens: 1024,
+      thinkingLevel: "high",
+      system: REVIEW_SYSTEM
+    });
+    const shouldContinue = review.includes("ITERATE") && !review.includes("DONE");
+    iterations.push({
+      iteration,
+      plan,
+      result,
+      review,
+      shouldContinue
+    });
+    if (!shouldContinue) {
+      if (!opts.quiet)
+        process.stderr.write(`\u03A1: Quality threshold reached after ${iteration} iteration(s)
+`);
+      break;
+    }
+    currentGoal = `Continue improving. Previous plan: ${plan}
+Review feedback: ${review}
+Original goal: ${goal}`;
+    iteration++;
+  }
+  const t1 = Date.now();
+  const summary = iterations.map(
+    (i) => `Iteration ${i.iteration}:
+  Plan: ${i.plan.slice(0, 100)}...
+  Review: ${i.review.slice(0, 100)}...`
+  ).join("\n");
+  return new RalphOutput(
+    summary,
+    iterations.length,
+    iteration <= (opts.maxIterations ?? 5),
+    iterations,
+    t0,
+    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();
+
+// src/patterns/subagent.ts
+var defaults13 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  maxSubTasks: 4,
+  concurrency: 4
+};
+var SubagentResult = class {
+  constructor(subTask, text, success) {
+    this.subTask = subTask;
+    this.text = text;
+    this.success = success;
+  }
+  subTask;
+  text;
+  success;
+};
+var SubagentOutput = class extends PatternOutput {
+  constructor(text, synthesis, subResults, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.synthesis = synthesis;
+    this.subResults = subResults;
+  }
+  synthesis;
+  subResults;
+};
+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.`;
+async function decomposeTask(task, opts) {
+  if (opts.subdomains && opts.subdomains.length > 0) return opts.subdomains;
+  const result = await ask(
+    `Decompose this task into ${opts.maxSubTasks ?? 4} independent sub-tasks that can be worked on in parallel:
+
+${task}
+
+Output a JSON array of strings.`,
+    {
+      model: opts.model,
+      maxTokens: 1024,
+      thinkingLevel: "medium",
+      system: DECOMPOSE_SYSTEM
+    }
+  );
+  try {
+    const jsonMatch = result.match(/\[[\s\S]*\]/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      if (Array.isArray(parsed) && parsed.length > 0) {
+        return parsed.map(String).slice(0, opts.maxSubTasks ?? 4);
+      }
+    }
+  } catch {
+  }
+  return result.split("\n").map(
+    (l) => l.replace(/^\d+[.)]\s*/, "").replace(/^[-*]\s*/, "").trim()
+  ).filter(Boolean).slice(0, opts.maxSubTasks ?? 4);
+}
+var SUBAGENT_SYSTEM = `You are a domain specialist. Complete your assigned sub-task thoroughly. Output your findings clearly and concisely.`;
+async function execute13(pieces, args, opts) {
+  const task = build(pieces, args);
+  const t0 = Date.now();
+  const plannerModel = opts.plannerModel ?? opts.model;
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(
+      `\u03A3: Subagent delegation \u2014 "${task.slice(0, 80)}${task.length > 80 ? "..." : ""}"
+`
+    );
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Decomposing task into sub-tasks...\n");
+  const subTasks = await decomposeTask(task, { ...opts, model: plannerModel });
+  if (!opts.quiet) {
+    process.stderr.write(`  \u2192 ${subTasks.length} sub-task(s) identified:
+`);
+    for (let i = 0; i < subTasks.length; i++) {
+      const st = subTasks[i];
+      process.stderr.write(`      [${i + 1}] ${st.slice(0, 60)}${st.length > 60 ? "..." : ""}
+`);
+    }
+  }
+  const subResults = [];
+  const concurrency = opts.concurrency ?? 4;
+  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))
+      )
+    );
+    batchResults.forEach((r) => {
+      if (r.status === "fulfilled") subResults.push(r.value);
+    });
+  }
+  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 synthesis = await ask(
+    `Original task:
+${task}
+
+Sub-task results:
+${subResultsText}
+
+Synthesize a comprehensive answer.`,
+    {
+      model: plannerModel,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: opts.thinkingLevel,
+      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
+  });
+  return fn;
+}
+var \u03A3 = makeSubagent();
+
+// src/patterns/tau.ts
+var defaults14 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  agents: 3,
+  rounds: 1
+};
+var ToolMediatedEntry = class {
+  constructor(agent, round, operation, key, content) {
+    this.agent = agent;
+    this.round = round;
+    this.operation = operation;
+    this.key = key;
+    this.content = content;
+  }
+  agent;
+  round;
+  operation;
+  key;
+  content;
+};
+var TauOutput = class extends PatternOutput {
+  constructor(text, entries, finalState, synthesis, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.entries = entries;
+    this.finalState = finalState;
+    this.synthesis = synthesis;
+  }
+  entries;
+  finalState;
+  synthesis;
+};
+var SCHEMA_SYSTEM = `You are a coordination architect. Given a task, design a shared structured context for agent collaboration.
+
+Output format exactly:
+KEYS: key1, key2, key3, key4
+
+AGENT 1:
+ROLE: (one-word role name)
+ASSIGNED_KEYS: key1, key2
+
+AGENT 2:
+ROLE: (one-word role name)
+ASSIGNED_KEYS: key3
+
+Define exactly {agentCount} agents with distinct roles. Each agent is assigned 1-2 keys.
+Keys should be named categories relevant to the task (e.g., "Market_Size", "Competitors", "Risks").`;
+var WRITE_SYSTEM = (role, keys) => `You are a ${role}. Write your initial findings to your assigned keys in the shared context.
+
+SHARED CONTEXT (current state \u2014 may be empty):
+{store}
+
+Your assigned keys: ${keys}
+
+Write initial, thorough findings to each of your keys. Output ONLY in this format:
+
+KEY: key_name
+VALUE: your findings for this key
+
+KEY: key_name
+VALUE: your findings for this key`;
+var UPDATE_SYSTEM = (role, keys) => `You are a ${role}. Review the current shared context and refine/update your entries.
+
+SHARED CONTEXT (current state from all agents):
+{store}
+
+Your assigned keys: ${keys}
+
+Review what other agents wrote. Update your entries to:
+- Fill gaps others haven't covered
+- Add depth and specific details
+- Challenge or validate others' findings where relevant
+- Avoid repeating what's already well-covered
+
+Output ONLY in this format:
+
+KEY: key_name
+VALUE: your updated findings for this key`;
+var CONSOLIDATE_SYSTEM = `You are a research director. Consolidate the structured findings from all specialists into a comprehensive, well-organized synthesis. Combine overlapping insights, resolve contradictions, and prioritize the most impactful findings. Structure your output clearly.`;
+async function defineSchema(task, opts) {
+  const agentCount = opts.agents ?? 3;
+  const prompt = SCHEMA_SYSTEM.replace("{agentCount}", String(agentCount));
+  const response = await ask(`Task: ${task}
+
+${prompt}`, {
+    model: opts.plannerModel ?? opts.model,
+    maxTokens: 1024,
+    thinkingLevel: "high"
+  });
+  const keysMatch = response.match(/KEYS\s*:\s*(.+)/i);
+  const keys = keysMatch?.[1]?.split(",").map((k) => k.trim()).filter(Boolean) ?? ["Findings", "Risks", "Recommendations"];
+  const agentRegex = /AGENT\s+\d+\s*:\s*\nROLE\s*:\s*(.+?)\nASSIGNED_KEYS\s*:\s*(.+?)(?:\n|$)/gi;
+  const roles = [];
+  const assignments = /* @__PURE__ */ new Map();
+  let match;
+  while ((match = agentRegex.exec(response)) !== null) {
+    const role = match[1].trim();
+    const agentKeys = match[2].split(",").map((k) => k.trim()).filter(Boolean);
+    roles.push(role);
+    assignments.set(role, agentKeys.length > 0 ? agentKeys : [keys[0] ?? "General"]);
+  }
+  if (roles.length === 0) {
+    for (let i = 0; i < agentCount; i++) {
+      const role = `Specialist ${i + 1}`;
+      roles.push(role);
+      const assignedKey = keys[i % keys.length] ?? `Key_${i + 1}`;
+      assignments.set(role, [assignedKey]);
+    }
+  }
+  return { keys, roles: roles.slice(0, agentCount), assignments };
+}
+function formatStore(store) {
+  const entries = Object.entries(store).filter(([, v]) => v);
+  if (entries.length === 0) return "(empty \u2014 you are the first contributor)";
+  return entries.map(([k, v]) => `[${k}]: ${v}`).join("\n\n");
+}
+function mergeEntry(store, key, content) {
+  if (store[key]) {
+    store[key] += `
+
+${content}`;
+  } else {
+    store[key] = content;
+  }
+}
+async function executeRound(roles, assignments, store, round, opts) {
+  const workerModel = opts.workerModel ?? opts.model;
+  const isWrite = round === 1;
+  const operation = isWrite ? "write" : "update";
+  const roundResults = await Promise.allSettled(
+    roles.map(async (role) => {
+      const assignedKeys = assignments.get(role) ?? ["General"];
+      const keysStr = assignedKeys.join(", ");
+      const storeText = formatStore(store);
+      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, {
+        model: workerModel,
+        maxTokens: opts.maxTokens,
+        thinkingLevel: opts.thinkingLevel,
+        system: systemPrompt
+      });
+      return { role, response };
+    })
+  );
+  const entries = [];
+  const newStore = { ...store };
+  for (const r of roundResults) {
+    if (r.status !== "fulfilled") continue;
+    const { role, response } = r.value;
+    const kvRegex = /KEY\s*:\s*(.+?)\nVALUE\s*:\s*([\s\S]*?)(?=\nKEY\s*:|\n*$)/gi;
+    let kvMatch;
+    let found = false;
+    while ((kvMatch = kvRegex.exec(response)) !== null) {
+      const key = kvMatch[1].trim();
+      const value = kvMatch[2].trim();
+      entries.push(new ToolMediatedEntry(role, round, operation, key, value));
+      mergeEntry(newStore, key, value);
+      found = true;
+    }
+    if (!found) {
+      const fallbackKey = assignments.get(role)?.[0] ?? "General";
+      const content = response.trim();
+      entries.push(new ToolMediatedEntry(role, round, operation, fallbackKey, content));
+      mergeEntry(newStore, fallbackKey, content);
+    }
+  }
+  return { entries, store: newStore };
+}
+async function consolidateStore(task, store, opts) {
+  const storeText = formatStore(store);
+  return ask(
+    `Original task: ${task}
+
+Structured findings from all specialists:
+
+${storeText}
+
+Consolidate into a comprehensive, well-structured synthesis.`,
+    {
+      model: opts.plannerModel ?? opts.model,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: "high",
+      system: CONSOLIDATE_SYSTEM
+    }
+  );
+}
+async function execute14(pieces, args, opts) {
+  const task = build(pieces, args);
+  const t0 = Date.now();
+  const totalRounds = opts.rounds ?? 1;
+  const plannerModel = opts.plannerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(
+      `\u03A4: Tool-Mediated Orchestration \u2014 "${task.slice(0, 80)}${task.length > 80 ? "..." : ""}"
+`
+    );
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Defining shared context schema...\n");
+  const { keys, roles, assignments } = await defineSchema(task, { ...opts, plannerModel });
+  if (!opts.quiet) {
+    process.stderr.write(`  \u2192 Schema: ${keys.join(", ")}
+`);
+    process.stderr.write(`  \u2192 ${roles.length} agent(s): ${roles.join(", ")}
+`);
+    for (const [role, assignedKeys] of assignments) {
+      process.stderr.write(`      ${role} \u2192 ${assignedKeys.join(", ")}
+`);
+    }
+  }
+  const allEntries = [];
+  let store = {};
+  for (let round = 1; round <= totalRounds; round++) {
+    const label = round === 1 ? "Writing" : "Updating";
+    if (!opts.quiet) process.stderr.write(`  \u2192 Round ${round}/${totalRounds}: ${label}...
+`);
+    const { entries, store: updatedStore } = await executeRound(
+      roles,
+      assignments,
+      store,
+      round,
+      opts
+    );
+    allEntries.push(...entries);
+    store = updatedStore;
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Consolidating store...\n");
+  const synthesis = await consolidateStore(task, store, { ...opts, plannerModel });
+  const t1 = Date.now();
+  const summary = [
+    `Schema keys: ${keys.join(", ")}`,
+    `Agents: ${roles.join(", ")}`,
+    `Rounds: ${totalRounds}`,
+    `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;
+}
+var \u03A4 = makeTau();
+
+// src/patterns/thread.ts
+var defaults15 = {
+  maxTokens: 4096,
+  thinkingLevel: "medium",
+  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;
+    this.turn = turn;
+    this.content = content;
+  }
+  role;
+  turn;
+  content;
+};
+var ThreadOutput = class extends PatternOutput {
+  constructor(text, conclusion, messages, startTime, endTime) {
+    super(text, startTime, endTime);
+    this.conclusion = conclusion;
+    this.messages = messages;
+  }
+  conclusion;
+  messages;
+};
+var THREAD_PROMPT = `You are an agent with the role: {role}.
+Engage in a multi-agent conversation about the topic.
+
+The conversation so far:
+{thread}
+
+Respond as your role. Be specific, build on or challenge what others have said.
+Keep your response under 200 words.`;
+var SYNTHESIS_SYSTEM6 = `You are a neutral facilitator. Synthesize the multi-agent conversation thread into a clear, actionable conclusion. Weigh the evidence, resolve conflicts, and present the best path forward.`;
+function buildThreadPrompt(role, thread) {
+  return THREAD_PROMPT.replace("{role}", role).replace(
+    "{thread}",
+    thread || "(This is the first message in the thread.)"
+  );
+}
+async function execute15(pieces, args, opts) {
+  const topic = build(pieces, args);
+  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 plannerModel = opts.plannerModel ?? opts.model;
+  const workerModel = opts.workerModel ?? opts.model;
+  if (!opts.quiet) {
+    process.stderr.write(`\u0398: Thread \u2014 ${agentCount} agent(s), ${maxTurns} turn(s)
+`);
+    process.stderr.write(`  Topic: "${topic.slice(0, 80)}${topic.length > 80 ? "..." : ""}"
+`);
+  }
+  const messages = [];
+  let thread = `Topic: ${topic}
+`;
+  for (let turn = 1; turn <= maxTurns; turn++) {
+    if (!opts.quiet) process.stderr.write(`  \u2192 Turn ${turn}/${maxTurns}
+`);
+    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
+      });
+      messages.push(new ThreadMessage(role, turn, response));
+      thread += `
+[${role}] (Turn ${turn}): ${response}
+`;
+    }
+  }
+  if (!opts.quiet) process.stderr.write("  \u2192 Synthesizing conclusion...\n");
+  const conclusion = await ask(
+    `Topic: ${topic}
+
+Conversation thread:
+${thread}
+
+Synthesize a clear, actionable conclusion.`,
+    {
+      model: plannerModel,
+      maxTokens: opts.maxTokens,
+      thinkingLevel: "high",
+      system: SYNTHESIS_SYSTEM6
+    }
+  );
+  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;
+}
+var \u0398 = makeThread();
+
+// src/pi.ts
+import {
+  getEnvApiKey as getEnvApiKey2,
+  getModels as getModels2,
+  getProviders as getProviders2,
+  streamSimple
+} from "@earendil-works/pi-ai";
+
+// src/pi-output.ts
+var PiOutput = class {
+  constructor(text, modelUsed, events = [], startTime = Date.now(), endTime = Date.now()) {
+    this.text = text;
+    this.modelUsed = modelUsed;
+    this.events = events;
+    this.startTime = startTime;
+    this.endTime = endTime;
+  }
+  text;
+  modelUsed;
+  events;
+  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;
+  }
+  /** Number of characters in output */
+  get length() {
+    return this.text.length;
+  }
+  /** Number of lines in output */
+  get lines() {
+    return this.text.split("\n").length;
+  }
+};
+
+// src/pi.ts
+var defaults16 = {
+  thinkingLevel: "medium",
+  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) {
+  return {
+    systemPrompt: opts.system,
+    messages: [
+      {
+        role: "user",
+        content: build2(pieces, args),
+        timestamp: Date.now()
+      }
+    ]
+  };
+}
+function makeOpts(opts) {
+  return {
+    maxTokens: opts.maxTokens,
+    reasoning: opts.thinkingLevel
+  };
+}
+async function run(pieces, args, opts) {
+  const model = pickModel2(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);
+    }
+  }
+  if (!opts.quiet && text) process.stdout.write("\n");
+  return new PiOutput(text.trim(), model.id, [], t0, Date.now());
+}
+async function* runStream(pieces, args, opts) {
+  const model = pickModel2(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;
+  }
+}
+var PiPromise = class extends Promise {
+  _modelId = "";
+  constructor(fn, modelId) {
+    super(fn);
+    if (modelId) this._modelId = modelId;
+  }
+  get modelUsed() {
+    return this._modelId;
+  }
+};
+function makePi(opts = {}) {
+  const merged = { ...defaults16, ...opts };
+  const fn = ((pieces, ...args) => {
+    if (!Array.isArray(pieces)) {
+      return makePi({ ...merged, ...pieces });
+    }
+    return new PiPromise((resolve, reject) => {
+      run(pieces, args, merged).then(resolve, reject);
+    });
+  });
+  let _quiet;
+  Object.defineProperty(fn, "quiet", {
+    get() {
+      if (!_quiet) _quiet = makePi({ ...merged, quiet: true });
+      return _quiet;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  fn.stream = async function* stream_pi(pieces, ...args) {
+    yield* runStream(pieces, args, merged);
+  };
+  return fn;
+}
+var \u03C0 = makePi();
+function configurePi(opts) {
+  Object.assign(defaults16, opts);
+}
+
+// src/pi-agent.ts
+import { createAgentSession as createAgentSession2 } from "@earendil-works/pi-coding-agent";
+var _agentDefaults = {
+  quiet: false,
+  maxTurns: 10
+};
+var AgentOutput = class {
+  constructor(text, turnCount = 0, startTime = Date.now(), endTime = Date.now()) {
+    this.text = text;
+    this.turnCount = turnCount;
+    this.startTime = startTime;
+    this.endTime = endTime;
+  }
+  text;
+  turnCount;
+  startTime;
+  endTime;
+  get duration() {
+    return this.endTime - this.startTime;
+  }
+  toString() {
+    return this.text;
+  }
+  valueOf() {
+    return this.text;
+  }
+  [Symbol.toPrimitive]() {
+    return this.text;
+  }
+};
+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
+  });
+  _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]);
+  }
+  return s.trim();
+}
+function getMessageText(msg) {
+  const content = msg.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter(
+      (c) => c.type === "text" && typeof c.text === "string"
+    ).map((c) => c.text).join("");
+  }
+  return "";
+}
+function getLastAssistantText(session) {
+  const messages = session.messages;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "assistant") {
+      return getMessageText(messages[i]);
+    }
+  }
+  return "";
+}
+async function execute16(pieces, args, opts) {
+  const prompt = build3(pieces, args);
+  const session = await getSession(opts);
+  const t0 = Date.now();
+  if (!opts.quiet) {
+    process.stderr.write(`\u03A0: ${prompt.slice(0, 100)}${prompt.length > 100 ? "..." : ""}
+`);
+  }
+  try {
+    await session.sendUserMessage(prompt);
+    const t1 = Date.now();
+    const text = getLastAssistantText(session);
+    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);
+  }
+}
+function makeAgent(opts = {}) {
+  const merged = { ..._agentDefaults, ...opts };
+  const fn = ((pieces, ...args) => {
+    if (!Array.isArray(pieces)) {
+      return makeAgent({ ...merged, ...pieces });
+    }
+    return new AgentPromise((resolve, reject) => {
+      execute16(pieces, args, merged).then(resolve, reject);
+    });
+  });
+  let _quiet;
+  Object.defineProperty(fn, "quiet", {
+    get() {
+      if (!_quiet) _quiet = makeAgent({ ...merged, quiet: true });
+      return _quiet;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  return fn;
+}
+var \u03A0 = makeAgent();
+function configureAgent(opts) {
+  Object.assign(_agentDefaults, opts);
+}
+async function closeAgent() {
+  if (_sharedSession) {
+    _sharedSession.dispose();
+    _sharedSession = null;
+  }
+}
+export {
+  AdaptiveOutput,
+  AdaptiveStep,
+  AgentOutput,
+  AgentPromise,
+  BroadcastOutput,
+  BroadcastResponse,
+  CritiqueOutput,
+  CritiqueRound,
+  DebateOutput,
+  DebatePerspective,
+  FleetMemberOutput,
+  FleetOutput,
+  GraphNodeResult,
+  GraphOutput,
+  MemoryEntry,
+  MemoryOutput,
+  OrchestratorOutput,
+  OrchestratorWorkerResult,
+  PatternOutput,
+  PatternPromise,
+  PiOutput,
+  PiPromise,
+  PipelineOutput,
+  PipelineStageResult,
+  RalphOutput,
+  SubagentOutput,
+  SubagentResult,
+  ThreadMessage,
+  ThreadOutput,
+  closeAgent,
+  configureAgent,
+  configurePi,
+  \u0391,
+  \u0392,
+  \u0393,
+  \u0394,
+  \u0398,
+  \u039B,
+  \u039C,
+  \u03A0,
+  \u03A1,
+  \u03A3,
+  \u03A6,
+  \u03A8,
+  \u03A9,
+  \u03C0
+};
+//# sourceMappingURL=index.js.map