omnius 1.0.381 → 1.0.383

package/dist/index.js

@@ -4820,6 +4820,17 @@ var init_shell = __esm({
         return lines.join("\n");
       }
       async finalizeResult(command, timeout2, start2, result) {
+        const reportedExitCode = this.reportedExitCodeFromOutput(`${result.output ?? ""}
+${result.llmContent ?? ""}`);
+        if (result.success && reportedExitCode !== null && reportedExitCode !== 0) {
+          const error = `Command reported non-zero exit marker ${reportedExitCode} despite wrapper exit 0.`;
+          result = {
+            ...result,
+            success: false,
+            error,
+            llmContent: this.markTranscriptFailure(result.llmContent ?? result.output ?? "", reportedExitCode, error)
+          };
+        }
         if (this.isBenignPipePreviewSigpipe(command, result)) {
           const note = "[NOTE — preview pipe closed after producing output]\nA downstream preview command such as `head`/`tail`/`sed -n` closed the pipe early, producing SIGPIPE exit 141 upstream. Captured output is usable as a preview; rerun without the preview pipe if the full output is needed.";
           const output = result.output ? `${result.output}
@@ -4901,6 +4912,32 @@ ${elevatedResult.stderr}` : ""),
         }
         return result;
       }
+      reportedExitCodeFromOutput(text2) {
+        const matches = text2.matchAll(/(?:^|\n)\s*(?:__)?EXIT_CODE\s*=\s*(\d+)\s*(?:\n|$)/g);
+        let found = null;
+        for (const match of matches) {
+          const value2 = Number(match[1]);
+          if (Number.isInteger(value2))
+            found = value2;
+        }
+        return found;
+      }
+      markTranscriptFailure(text2, exitCode, error) {
+        if (!text2)
+          return error;
+        let next = text2;
+        next = next.replace(/status: success/g, "status: failure");
+        next = next.replace(/exit_code: 0/g, `exit_code: ${exitCode}`);
+        if (!next.includes(`exit_code: ${exitCode}`)) {
+          next = `${next}
+exit_code: ${exitCode}`;
+        }
+        if (!next.includes(error)) {
+          next = `${next}
+error: ${error}`;
+        }
+        return next;
+      }
       isBenignPipePreviewSigpipe(command, result) {
         if (result.success !== false)
           return false;
@@ -20357,18 +20394,18 @@ function detectStage(metrics2) {
     return "specialization";
   return "exploration";
 }
-function thresholdsForStage(stage) {
-  return { ...STAGE_THRESHOLDS[stage] };
+function thresholdsForStage(stage2) {
+  return { ...STAGE_THRESHOLDS[stage2] };
 }
-function characteristicsForStage(stage) {
-  return { ...STAGE_CHARACTERISTICS[stage] };
+function characteristicsForStage(stage2) {
+  return { ...STAGE_CHARACTERISTICS[stage2] };
 }
 function report(metrics2) {
-  const stage = detectStage(metrics2);
-  const thresholds = thresholdsForStage(stage);
-  const characteristics = characteristicsForStage(stage);
-  const nextStage = computeNextStage(stage, metrics2);
-  return { stage, metrics: metrics2, thresholds, characteristics, nextStage };
+  const stage2 = detectStage(metrics2);
+  const thresholds = thresholdsForStage(stage2);
+  const characteristics = characteristicsForStage(stage2);
+  const nextStage = computeNextStage(stage2, metrics2);
+  return { stage: stage2, metrics: metrics2, thresholds, characteristics, nextStage };
 }
 function computeNextStage(current, m2) {
   const next = current === "exploration" ? "specialization" : current === "specialization" ? "integration" : current === "integration" ? "wisdom" : null;
@@ -21815,11 +21852,11 @@ var init_memoryStageContext = __esm({
       current;
       onStageChange;
       constructor(options2 = {}) {
-        const stage = options2.initialStage ?? "exploration";
+        const stage2 = options2.initialStage ?? "exploration";
         this.current = {
-          stage,
-          thresholds: thresholdsForStage(stage),
-          characteristics: characteristicsForStage(stage),
+          stage: stage2,
+          thresholds: thresholdsForStage(stage2),
+          characteristics: characteristicsForStage(stage2),
           computedAt: Date.now()
         };
         this.onStageChange = options2.onStageChange;
@@ -274668,12 +274705,12 @@ function parseStructuredProgress(text2) {
     const parsed = JSON.parse(trimmed);
     if (parsed["omnius_progress"] !== true)
       return null;
-    const stage = String(parsed["stage"] ?? "process");
+    const stage2 = String(parsed["stage"] ?? "process");
     const message2 = String(parsed["message"] ?? "").trim();
     const percent = typeof parsed["percent"] === "number" ? parsed["percent"] : void 0;
     if (!message2)
       return null;
-    return { stage, message: message2, percent };
+    return { stage: stage2, message: message2, percent };
   } catch {
     return null;
   }
@@ -277260,12 +277297,12 @@ async function runProcess3(command, args, options2) {
       }, 5e3);
       sigkillTimer.unref();
     };
-    const abortWithMessage = (message2, stage) => {
+    const abortWithMessage = (message2, stage2) => {
       stderr += stderr.endsWith("\n") || stderr.length === 0 ? `${message2}
 ` : `
 ${message2}
 `;
-      options2.onProgress?.({ stage, message: message2, elapsedMs: Date.now() - startedAt2 });
+      options2.onProgress?.({ stage: stage2, message: message2, elapsedMs: Date.now() - startedAt2 });
       terminateChild();
       finish({ code: 124, stdout, stderr }, { preserveSigkillTimer: true });
     };
@@ -281041,12 +281078,12 @@ function parseStructuredProgress2(text2) {
     const parsed = JSON.parse(trimmed);
     if (parsed["omnius_progress"] !== true)
       return null;
-    const stage = String(parsed["stage"] ?? "process");
+    const stage2 = String(parsed["stage"] ?? "process");
     const message2 = String(parsed["message"] ?? "").trim();
     const percent = typeof parsed["percent"] === "number" ? parsed["percent"] : void 0;
     if (!message2)
       return null;
-    return { stage, message: message2, percent };
+    return { stage: stage2, message: message2, percent };
   } catch {
     return null;
   }
@@ -284867,9 +284904,9 @@ No artifact created: provide prompt and/or input_image for ${kindLabel(kind)} ge
           brokerDecision
         };
       }
-      emit(start2, stage, message2, percent) {
+      emit(start2, stage2, message2, percent) {
         this.progressCallback?.({
-          stage,
+          stage: stage2,
           message: message2,
           percent,
           elapsedMs: performance.now() - start2
@@ -549127,7 +549164,7 @@ var init_agent_tool = __esm({
     _idCounter = 0;
     AgentTool = class {
       name = "agent";
-      description = "Spawn a sub-agent to handle a task autonomously. Sub-agents have their own context window and tool set, controlled by the agent type.\n\nAgent types:\n- general: Full tool access (minus agent spawning). For complex multi-step tasks.\n- explore: Read-only. Fast codebase search and analysis.\n- plan: Read-only. Returns structured implementation plans.\n- coordinator: Orchestrates teams of agents. Cannot edit files directly.\n\nUse run_in_background=true for parallel work. Check results via task_status/task_output.";
+      description = "Spawn a sub-agent to handle a task autonomously. Sub-agents have their own context window and tool set, controlled by the agent type.\n\nAgent types:\n- general: Full tool access (minus agent spawning). For complex multi-step tasks.\n- explore: Read-only. Fast codebase search and analysis.\n- plan: Read-only. Returns structured implementation plans.\n- coordinator: Orchestrates teams of agents. Cannot edit files directly.\n\nDeployment patterns: optional named orchestration contracts such as sequential_pipeline, parallel_analysis, scatter_gather, maker_checker, debate_review, specialist_committee, hierarchical_crew, blackboard, task_swarm, and dynamic_task_ledger. Use them only when specialization, context isolation, parallelism, critique, or dynamic decomposition is structurally needed.\n\nUse run_in_background=true for parallel work. Check results via task_status/task_output.";
       parameters = {
         type: "object",
         properties: {
@@ -549140,6 +549177,14 @@ var init_agent_tool = __esm({
             enum: ["general", "explore", "plan", "coordinator"],
             description: "Agent type determining tool access and behavior (default: general)"
           },
+          deployment_pattern: {
+            type: "string",
+            description: "Optional named sub-agent deployment pattern. Examples: single_worker, sequential_pipeline, parallel_analysis, scatter_gather, orchestrator_workers, maker_checker, debate_review, specialist_committee, hierarchical_crew, blackboard, task_swarm, dynamic_task_ledger. Multi-stage patterns auto-select coordinator when subagent_type is omitted."
+          },
+          pattern: {
+            type: "string",
+            description: "Compatibility alias for deployment_pattern. Prefer deployment_pattern."
+          },
           run_in_background: {
             type: "boolean",
             description: "Run asynchronously, return task ID immediately (default: false)"
@@ -549184,7 +549229,8 @@ var init_agent_tool = __esm({
       async execute(args) {
         const start2 = performance.now();
         const prompt = String(args["prompt"] ?? "");
-        const subagentType = String(args["subagent_type"] ?? "general");
+        const rawPattern = String(args["deployment_pattern"] ?? args["pattern"] ?? "").trim();
+        let subagentType = String(args["subagent_type"] ?? "general");
         const runInBackground = Boolean(args["run_in_background"] ?? false);
         const modelOverride = args["model"] ? String(args["model"]) : void 0;
         const isolation = args["isolation"] ? String(args["isolation"]) : void 0;
@@ -549202,6 +549248,19 @@ var init_agent_tool = __esm({
             durationMs: performance.now() - start2
           };
         }
+        const deploymentPattern = rawPattern ? this.callbacks.resolveDeploymentPattern?.(rawPattern, prompt) : void 0;
+        if (rawPattern && !deploymentPattern) {
+          const available = this.callbacks.listDeploymentPatterns?.().join(", ") || "(pattern registry unavailable)";
+          return {
+            success: false,
+            output: "",
+            error: `Unknown deployment pattern: ${rawPattern}. Available: ${available}`,
+            durationMs: performance.now() - start2
+          };
+        }
+        if (deploymentPattern?.coordinatorRequired && args["subagent_type"] === void 0) {
+          subagentType = "coordinator";
+        }
         const resolved = this.callbacks.resolveType(subagentType);
         if (!resolved) {
           const available = this.callbacks.listTypes().join(", ");
@@ -549260,11 +549319,15 @@ var init_agent_tool = __esm({
           }
         }
         const composedPrompt = (() => {
-          if (preloadedFiles.length === 0 && constraints.length === 0)
+          if (preloadedFiles.length === 0 && constraints.length === 0 && !deploymentPattern)
             return prompt;
           const lines = [];
           lines.push("[Sub-Agent Handoff — parent has provided this scoped context]");
           lines.push("");
+          if (deploymentPattern) {
+            lines.push(deploymentPattern.instructions);
+            lines.push("");
+          }
           if (preloadedFiles.length > 0) {
             lines.push("## Pre-loaded files");
             lines.push("These files have already been read for you. Reference them directly without calling file_read.");
@@ -549319,6 +549382,7 @@ var init_agent_tool = __esm({
             systemPromptAddition: resolved.systemPromptAddition,
             relevantFiles: preloadedFiles,
             constraints,
+            deploymentPattern: deploymentPattern?.pattern,
             subAgentMode: true
           }).then((result) => {
             this.callbacks?.onViewStatus?.(agentId, result.completed ? "completed" : "failed");
@@ -549349,6 +549413,7 @@ var init_agent_tool = __esm({
             systemPromptAddition: resolved.systemPromptAddition,
             relevantFiles: preloadedFiles,
             constraints,
+            deploymentPattern: deploymentPattern?.pattern,
             subAgentMode: true
           });
           if (result.completed) {
@@ -566361,17 +566426,58 @@ function retentionStrength(note, now2 = Date.now()) {
   const retention = Math.exp(-ageH / Math.max(1, stability));
   return Math.min(1, Math.max(note.importance / 10 * 0.2, retention));
 }
+function hashFeature(s2) {
+  let h = 2166136261;
+  for (let i2 = 0; i2 < s2.length; i2++) {
+    h ^= s2.charCodeAt(i2);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function textFeatures(text2) {
+  const tokens = text2.toLowerCase().split(/[^\p{L}\p{N}_./-]+/u).map((t2) => t2.trim()).filter(Boolean);
+  const features = [...tokens];
+  for (let i2 = 0; i2 < tokens.length - 1; i2++) {
+    features.push(`${tokens[i2]} ${tokens[i2 + 1]}`);
+  }
+  return features;
+}
+function textToHashEmbedding(text2, dimensions = DEFAULT_HASH_DIMS) {
+  const dim = Math.max(8, Math.floor(dimensions));
+  const vec = new Array(dim).fill(0);
+  for (const feature of textFeatures(text2)) {
+    const h = hashFeature(feature);
+    const idx = h % dim;
+    const sign2 = (h & 2147483648) === 0 ? 1 : -1;
+    vec[idx] += sign2;
+  }
+  const norm = Math.sqrt(vec.reduce((sum, v) => sum + v * v, 0));
+  if (!norm)
+    return vec;
+  return vec.map((v) => Math.round(v / norm * 1e6) / 1e6);
+}
+function relevanceScore(note, queryEmbedding) {
+  if (!queryEmbedding)
+    return 0.5;
+  if (!note.embedding || note.embedding.length !== queryEmbedding.length)
+    return 0;
+  return Math.max(0, cosine3(note.embedding, queryEmbedding));
+}
 function scoreNote(note, opts = {}) {
   const now2 = opts.now ?? Date.now();
   const w = opts.weights ?? DEFAULT_WEIGHTS;
   const recency = retentionStrength(note, now2);
   const importance = Math.min(1, Math.max(0, note.importance / 10));
-  const relevance = opts.queryEmbedding && note.embedding ? Math.max(0, cosine3(note.embedding, opts.queryEmbedding)) : 0.5;
+  const relevance = opts.queryEmbedding ? relevanceScore(note, opts.queryEmbedding) : 0.5;
   const total = w.recency * recency + w.importance * importance + w.relevance * relevance;
   return Math.round(total / (w.recency + w.importance + w.relevance) * 1e4) / 1e4;
 }
 function selectTopNotes(notes, k, opts) {
-  return [...notes].map((n2) => ({ n: n2, s: scoreNote(n2, opts) })).sort((a2, b) => b.s - a2.s).slice(0, Math.max(0, k)).map((x) => x.n);
+  return [...notes].map((n2) => ({
+    n: n2,
+    s: scoreNote(n2, opts),
+    r: relevanceScore(n2, opts?.queryEmbedding)
+  })).filter(({ r: r2 }) => !opts?.queryEmbedding || opts.minRelevance === void 0 || r2 >= opts.minRelevance).sort((a2, b) => b.s - a2.s).slice(0, Math.max(0, k)).map((x) => x.n);
 }
 function findDuplicateGroups(notes, simThreshold = 0.92) {
   const groups = [];
@@ -566438,7 +566544,7 @@ function planConsolidation(notes, opts = {}) {
   }
   return { keep, prune, merge: merge2, distill };
 }
-var HOUR, ImportanceBudget, DEFAULT_WEIGHTS;
+var HOUR, ImportanceBudget, DEFAULT_WEIGHTS, DEFAULT_HASH_DIMS;
 var init_memory_consolidation = __esm({
   "packages/orchestrator/dist/memory-consolidation.js"() {
     "use strict";
@@ -566465,6 +566571,7 @@ var init_memory_consolidation = __esm({
       }
     };
     DEFAULT_WEIGHTS = { recency: 1, importance: 1, relevance: 1 };
+    DEFAULT_HASH_DIMS = 256;
   }
 });
 
@@ -566508,6 +566615,10 @@ function noteAfterTask(args) {
     createdAt: now2,
     lastAccessedMs: now2,
     accessCount: 0,
+    embedding: textToHashEmbedding(`${args.summary || ""}
+${(args.keywords ?? []).join(" ")}`),
+    sourceSurface: args.sourceSurface,
+    sourceKey: args.sourceKey,
     version: 1
   });
   const budget = new ImportanceBudget(THRESHOLD);
@@ -566555,11 +566666,28 @@ function noteAfterTask(args) {
   save2(store2);
   return result;
 }
-function recallTopNotes(k = 5) {
+function ensureNoteEmbeddings(store2) {
+  let changed = false;
+  for (const note of store2.notes) {
+    if (!Array.isArray(note.embedding) || note.embedding.length === 0) {
+      note.embedding = textToHashEmbedding(`${note.content || ""}
+${(note.keywords ?? []).join(" ")}`);
+      changed = true;
+    }
+  }
+  return changed;
+}
+function recallTopNotes(k = 5, opts = {}) {
   const store2 = load2();
   if (!store2.notes.length)
     return [];
-  const top = selectTopNotes(store2.notes, k);
+  const changed = ensureNoteEmbeddings(store2);
+  const queryEmbedding = opts.query ? textToHashEmbedding(opts.query) : void 0;
+  const top = selectTopNotes(store2.notes, k, {
+    queryEmbedding,
+    minRelevance: queryEmbedding ? opts.minRelevance ?? 0.18 : void 0,
+    weights: queryEmbedding ? { recency: 0.5, importance: 0.75, relevance: 2 } : void 0
+  });
   const now2 = Date.now();
   const ids = new Set(top.map((n2) => n2.id));
   for (const n2 of store2.notes)
@@ -566567,11 +566695,12 @@ function recallTopNotes(k = 5) {
       n2.accessCount += 1;
       n2.lastAccessedMs = now2;
     }
-  save2(store2);
+  if (changed || ids.size > 0)
+    save2(store2);
   return top;
 }
-function recallNotesBlock(k = 5) {
-  const top = recallTopNotes(k);
+function recallNotesBlock(k = 5, opts = {}) {
+  const top = recallTopNotes(k, opts);
   if (!top.length)
     return "";
   const lines = top.map((n2) => `- (${n2.tier === "semantic" ? "learned" : "recent"}, imp ${n2.importance}) ${n2.content}`);
@@ -569258,6 +569387,8 @@ function violatesDirective(directive, input) {
   if (input.toolName === "task_complete") {
     return directive.state === "terminal_incomplete";
   }
+  if (input.toolName === "ask_user")
+    return false;
   const family = actionFamily(input.toolName, input.args);
   if (directive.forbiddenActionFamilies.includes(family))
     return true;
@@ -569267,20 +569398,41 @@ function violatesDirective(directive, input) {
     case "update_todos":
       return input.toolName !== "todo_write";
     case "read_authoritative_target":
-      return input.toolName !== "file_read";
+      return !isEvidenceGatheringTool(input.toolName);
     case "run_verification":
       return input.toolName !== "shell";
     case "report_blocked":
     case "report_incomplete":
-      return input.toolName !== "task_complete";
+      return !isReportTool(input.toolName);
     case "edit_different_target":
-      return input.toolName === "shell" || input.isReadLike || directive.forbiddenActionFamilies.includes(family);
+      return !isEditTool(input.toolName) && !isEvidenceGatheringTool(input.toolName);
     case "use_cached_evidence":
       return directive.forbiddenActionFamilies.includes(family);
     default:
       return false;
   }
 }
+function isEvidenceGatheringTool(toolName) {
+  return [
+    "file_read",
+    "grep_search",
+    "find_files",
+    "list_directory",
+    "log_explore",
+    "todo_write"
+  ].includes(toolName);
+}
+function isEditTool(toolName) {
+  return [
+    "file_write",
+    "file_edit",
+    "file_patch",
+    "batch_edit"
+  ].includes(toolName);
+}
+function isReportTool(toolName) {
+  return toolName === "task_complete" || toolName === "ask_user";
+}
 function actionFamily(toolName, args) {
   const target = args?.["path"] ?? args?.["file"] ?? args?.["filePath"] ?? args?.["file_path"] ?? args?.["command"] ?? args?.["cmd"] ?? "";
   return `${toolName}:${normalizeTarget(String(target ?? "")) || "no-target"}`;
@@ -569313,6 +569465,7 @@ var init_focusSupervisor = __esm({
       lastReason = "";
       lastContext = null;
       failureFamilies = /* @__PURE__ */ new Map();
+      ignoredDirectiveStreak = 0;
       constructor(options2 = {}) {
         this.mode = options2.mode ?? "auto";
         this.modelTier = options2.modelTier ?? "large";
@@ -569361,13 +569514,15 @@ var init_focusSupervisor = __esm({
         const prior = this.directive;
         if (prior && violatesDirective(prior, input)) {
           prior.ignoredCount++;
+          this.ignoredDirectiveStreak++;
           const strict = this.shouldStrictlyIntervene(input.context);
           if (strict && prior.ignoredCount >= 1) {
+            const ignoredManyTimes = this.ignoredDirectiveStreak >= 3;
             const directive = this.setDirective({
               turn: input.turn,
-              state: "single_next_action",
-              reason: `model ignored prior directive ${prior.id}: ${prior.reason}`,
-              requiredNextAction: prior.requiredNextAction,
+              state: ignoredManyTimes ? "verify_or_block" : "single_next_action",
+              reason: ignoredManyTimes ? `model ignored ${this.ignoredDirectiveStreak} focus directives; report incomplete or ask for help instead of trying another variant` : `model ignored prior directive ${prior.id}; ${prior.reason}`,
+              requiredNextAction: ignoredManyTimes ? "report_incomplete" : prior.requiredNextAction,
               forbiddenActionFamilies: unique2([
                 ...prior.forbiddenActionFamilies,
                 family
@@ -569403,7 +569558,7 @@ var init_focusSupervisor = __esm({
             turn: input.turn,
             state,
             reason: input.cachedResultFailed ? `cached failed ${input.toolName} evidence already exists` : `duplicate ${input.toolName} call has cached evidence`,
-            requiredNextAction: input.cachedResultFailed ? "edit_different_target" : "use_cached_evidence",
+            requiredNextAction: input.cachedResultFailed ? "read_authoritative_target" : "use_cached_evidence",
             forbiddenActionFamilies: [family]
           });
           if (strict && !advisoryOnly && (input.cachedResultFailed || duplicateHitCount >= hitLimit)) {
@@ -569429,6 +569584,8 @@ var init_focusSupervisor = __esm({
         }
         this.lastDecision = "pass";
         this.lastReason = "";
+        if (!this.directive)
+          this.ignoredDirectiveStreak = 0;
         return this.pass();
       }
       observeToolResult(input) {
@@ -569550,6 +569707,7 @@ var init_focusSupervisor = __esm({
         this.lastReason = reason;
         this.directive = null;
         this.state = "observe";
+        this.ignoredDirectiveStreak = 0;
       }
       pass() {
         return { kind: "pass", state: this.state, ...this.directive ? { directive: this.directive } : {} };
@@ -572867,11 +573025,11 @@ ${parts.join("\n")}
         }
         return "unknown";
       }
-      _recordContextWindowDump(stage, request, turn, attempt) {
+      _recordContextWindowDump(stage2, request, turn, attempt) {
         const agentType = this.options.artifactMode === "internal" ? "internal" : this.options.subAgent || this.options.recursionDepth > 0 ? "sub-agent" : "main";
         const record = recordContextWindowDump({
           source: "agenticRunner",
-          stage,
+          stage: stage2,
           agentType,
           sessionId: this._sessionId,
           runId: this._sessionId,
@@ -578443,7 +578601,7 @@ ${_fanout}`;
         } catch {
         }
         try {
-          const _notes = recallNotesBlock(5);
+          const _notes = recallNotesBlock(5, { query: persistentTaskGoal });
           if (_notes)
             systemPrompt = `${systemPrompt}
 
@@ -578453,21 +578611,11 @@ ${_notes}`;
         try {
           if (!this.options.subAgent) {
             const _imp = Math.min(9, Math.max(3, 3 + Math.floor((persistentTaskGoal.length || 0) / 250)));
-            const _kw = String(persistentTaskGoal || "").toLowerCase().match(/[a-z][a-z0-9_-]{3,}/g)?.filter((w) => ![
-              "this",
-              "that",
-              "with",
-              "from",
-              "into",
-              "your",
-              "have",
-              "will",
-              "please"
-            ].includes(w)).slice(0, 6) ?? [];
             noteAfterTask({
               summary: `Task: ${persistentTaskGoal.slice(0, 200)}`,
               importance: _imp,
-              keywords: _kw
+              sourceSurface: this._inferSurface(),
+              sourceKey: this.options.stateDir ?? this.authoritativeWorkingDirectory()
             });
           }
         } catch {
@@ -592874,6 +593022,565 @@ var init_agent_types = __esm({
   }
 });
 
+// packages/orchestrator/dist/agent-patterns.js
+function stage(input) {
+  return { required: true, ...input };
+}
+function buildDeploymentPatternInstructions(def, stages, task) {
+  const lines = [
+    "[Sub-Agent Deployment Pattern]",
+    `pattern: ${def.pattern}`,
+    `topology: ${def.topology}`,
+    `task: ${task}`,
+    `coordinator_required: ${def.coordinatorRequired}`,
+    `max_agents: ${def.maxAgents}`,
+    "",
+    "Use this pattern only because the task needs specialization, isolation, parallelism, critique, or dynamic decomposition.",
+    def.systemPromptAddition,
+    "",
+    "Stages:"
+  ];
+  for (const s2 of stages) {
+    lines.push(`${s2.order}. ${s2.id} — ${s2.label}`, `   agent_type: ${s2.agentType}`, `   mode: ${s2.mode}${s2.parallelGroup ? ` (${s2.parallelGroup})` : ""}`, `   purpose: ${s2.purpose}`);
+    if (s2.dependsOn?.length)
+      lines.push(`   depends_on: ${s2.dependsOn.join(", ")}`);
+    lines.push("   output_contract:");
+    for (const item of s2.outputContract)
+      lines.push(`   - ${item}`);
+  }
+  lines.push("", "Coordinator contract:", "- Keep worker prompts narrow and self-contained.", "- Run independent stages in parallel only when their write sets do not overlap.", "- Validate each handoff before starting dependent stages.", "- Preserve dissent, failures, and unresolved blockers in the final synthesis.", "- Complete only with evidence from worker outputs and verification.");
+  return lines.join("\n");
+}
+function getAgentDeploymentPatternRegistry() {
+  return _patternRegistry;
+}
+function registerAgentDeploymentPattern(def) {
+  _patternRegistry.register(def);
+}
+function getAgentDeploymentPattern(pattern) {
+  return _patternRegistry.get(pattern);
+}
+function planAgentDeploymentPattern(pattern, task) {
+  return _patternRegistry.plan(pattern, task);
+}
+function buildAgentDeploymentPatternSummary() {
+  return _patternRegistry.buildPatternSummary();
+}
+var BUILT_INS, AgentDeploymentPatternRegistry, _patternRegistry;
+var init_agent_patterns = __esm({
+  "packages/orchestrator/dist/agent-patterns.js"() {
+    "use strict";
+    init_agent_types();
+    BUILT_INS = [
+      {
+        pattern: "single_worker",
+        aliases: ["single", "direct_worker"],
+        description: "One bounded worker owns the delegated task.",
+        topology: "single",
+        useWhen: ["The task is narrow enough for one context window."],
+        avoidWhen: ["Independent critique, parallel search, or separate permissions are required."],
+        coordinatorRequired: false,
+        maxAgents: 1,
+        systemPromptAddition: "Use the least autonomous design: one focused worker, scoped evidence, then task_complete.",
+        stages: [
+          stage({
+            id: "worker",
+            label: "Focused worker",
+            agentType: "general",
+            purpose: "Complete the delegated task inside one scoped context.",
+            order: 1,
+            mode: "sequential",
+            outputContract: ["Summary of changes or findings", "Verification evidence", "Open blockers"]
+          })
+        ]
+      },
+      {
+        pattern: "sequential_pipeline",
+        aliases: ["pipeline", "planner_executor_reporter"],
+        description: "Fixed-order handoff where each stage validates and passes compact output forward.",
+        topology: "sequential",
+        useWhen: ["The workflow order is known and each handoff can be validated."],
+        avoidWhen: ["Stages are independent and should run in parallel."],
+        coordinatorRequired: true,
+        maxAgents: 3,
+        systemPromptAddition: "Run a fixed sequence. Do not skip handoff validation between stages.",
+        stages: [
+          stage({
+            id: "plan",
+            label: "Planner",
+            agentType: "plan",
+            purpose: "Produce a compact implementation or investigation plan.",
+            order: 1,
+            mode: "sequential",
+            outputContract: ["Concrete steps", "Files or systems to inspect", "Verification plan"]
+          }),
+          stage({
+            id: "execute",
+            label: "Executor",
+            agentType: "general",
+            purpose: "Execute the approved plan.",
+            order: 2,
+            mode: "sequential",
+            dependsOn: ["plan"],
+            outputContract: ["Work performed", "Files modified", "Commands/tests run"]
+          }),
+          stage({
+            id: "report",
+            label: "Reporter",
+            agentType: "explore",
+            purpose: "Check resulting evidence and summarize final state.",
+            order: 3,
+            mode: "review",
+            dependsOn: ["execute"],
+            outputContract: ["Evidence-backed result", "Residual risks", "Suggested next steps"]
+          })
+        ]
+      },
+      {
+        pattern: "parallel_analysis",
+        aliases: ["concurrent_analysis", "sectioning"],
+        description: "Run independent specialists in parallel and aggregate disagreements explicitly.",
+        topology: "parallel",
+        useWhen: ["Independent perspectives or code regions can be analyzed separately."],
+        avoidWhen: ["Workers must mutate the same files without a merge owner."],
+        coordinatorRequired: true,
+        maxAgents: 5,
+        systemPromptAddition: "Launch independent read-only or scoped workers in parallel, then aggregate explicitly.",
+        stages: [
+          stage({
+            id: "explorer_a",
+            label: "Explorer A",
+            agentType: "explore",
+            purpose: "Inspect the first region or perspective.",
+            order: 1,
+            mode: "parallel",
+            parallelGroup: "analysis",
+            outputContract: ["Findings", "Source paths", "Confidence"]
+          }),
+          stage({
+            id: "explorer_b",
+            label: "Explorer B",
+            agentType: "explore",
+            purpose: "Inspect the second region or perspective.",
+            order: 1,
+            mode: "parallel",
+            parallelGroup: "analysis",
+            outputContract: ["Findings", "Source paths", "Confidence"]
+          }),
+          stage({
+            id: "aggregate",
+            label: "Aggregator",
+            agentType: "plan",
+            purpose: "Merge findings, preserve disagreements, and recommend next action.",
+            order: 2,
+            mode: "aggregate",
+            dependsOn: ["explorer_a", "explorer_b"],
+            outputContract: ["Merged conclusion", "Disagreements", "Evidence list"]
+          })
+        ]
+      },
+      {
+        pattern: "scatter_gather",
+        aliases: ["map_reduce", "fanout_reduce"],
+        description: "Fan out over many files/regions, then reduce into one compact result.",
+        topology: "scatter_gather",
+        useWhen: ["The input corpus is too large for one context window."],
+        avoidWhen: ["Only one or two files are relevant."],
+        coordinatorRequired: true,
+        maxAgents: 8,
+        systemPromptAddition: "Partition by source/region, require provenance from every mapper, then reduce deterministically.",
+        stages: [
+          stage({
+            id: "map",
+            label: "Mapper workers",
+            agentType: "explore",
+            purpose: "Process assigned partitions independently.",
+            order: 1,
+            mode: "parallel",
+            parallelGroup: "map",
+            outputContract: ["Partition id", "Relevant paths", "Distilled findings"]
+          }),
+          stage({
+            id: "reduce",
+            label: "Reducer",
+            agentType: "plan",
+            purpose: "Dedupe and synthesize mapper outputs.",
+            order: 2,
+            mode: "aggregate",
+            dependsOn: ["map"],
+            outputContract: ["Deduped paths", "Synthesis", "Empty partitions"]
+          })
+        ]
+      },
+      {
+        pattern: "orchestrator_workers",
+        aliases: ["manager_workers", "manager_agents_as_tools"],
+        description: "A coordinator decomposes unknown subtasks and owns final synthesis.",
+        topology: "orchestrator_workers",
+        useWhen: ["Subtasks are not fully known upfront."],
+        avoidWhen: ["The task can be expressed as a fixed sequence."],
+        coordinatorRequired: true,
+        maxAgents: 6,
+        systemPromptAddition: "The coordinator owns decomposition, worker scope, progress ledger, and final synthesis.",
+        stages: [
+          stage({
+            id: "coordinate",
+            label: "Coordinator",
+            agentType: "coordinator",
+            purpose: "Maintain task ledger and dispatch narrow workers.",
+            order: 1,
+            mode: "coordinate",
+            outputContract: ["Task ledger", "Worker assignments", "Completion criteria"]
+          }),
+          stage({
+            id: "workers",
+            label: "Workers",
+            agentType: "general",
+            purpose: "Execute scoped subtasks assigned by the coordinator.",
+            order: 2,
+            mode: "parallel",
+            dependsOn: ["coordinate"],
+            outputContract: ["Scoped result", "Files touched", "Verification evidence"]
+          })
+        ]
+      },
+      {
+        pattern: "maker_checker",
+        aliases: ["make_check", "generator_reviewer"],
+        description: "One worker produces, an independent checker validates before completion.",
+        topology: "maker_checker",
+        useWhen: ["Quality, policy, or correctness needs an independent review."],
+        avoidWhen: ["There is no clear checkable output."],
+        coordinatorRequired: true,
+        maxAgents: 2,
+        systemPromptAddition: "Keep maker and checker independent. Prefer deterministic tests over model judgment when available.",
+        stages: [
+          stage({
+            id: "maker",
+            label: "Maker",
+            agentType: "general",
+            purpose: "Implement or draft the requested artifact.",
+            order: 1,
+            mode: "sequential",
+            outputContract: ["Produced artifact", "Implementation notes", "Verification run"]
+          }),
+          stage({
+            id: "checker",
+            label: "Checker",
+            agentType: "explore",
+            purpose: "Validate the maker output without sharing the maker prompt as hidden state.",
+            order: 2,
+            mode: "review",
+            dependsOn: ["maker"],
+            outputContract: ["Pass/fail", "Findings with evidence", "Required fixes"]
+          })
+        ]
+      },
+      {
+        pattern: "debate_review",
+        aliases: ["adversarial_review", "debate"],
+        description: "Assign competing positions, then synthesize with evidence.",
+        topology: "debate",
+        useWhen: ["The decision is ambiguous or confirmation bias is likely."],
+        avoidWhen: ["The task is a straightforward implementation with objective tests."],
+        coordinatorRequired: true,
+        maxAgents: 4,
+        systemPromptAddition: "Assign explicit positions, require evidence for claims, then synthesize neutrally.",
+        stages: [
+          stage({
+            id: "pro",
+            label: "Pro advocate",
+            agentType: "plan",
+            purpose: "Argue for the proposed approach using evidence.",
+            order: 1,
+            mode: "parallel",
+            parallelGroup: "debate",
+            outputContract: ["Argument", "Evidence", "Assumptions"]
+          }),
+          stage({
+            id: "con",
+            label: "Risk advocate",
+            agentType: "plan",
+            purpose: "Argue against the proposed approach and surface risks.",
+            order: 1,
+            mode: "parallel",
+            parallelGroup: "debate",
+            outputContract: ["Counterargument", "Evidence", "Risks"]
+          }),
+          stage({
+            id: "synthesis",
+            label: "Neutral synthesizer",
+            agentType: "plan",
+            purpose: "Resolve the debate and state the decision criteria.",
+            order: 2,
+            mode: "aggregate",
+            dependsOn: ["pro", "con"],
+            outputContract: ["Decision", "Tradeoffs", "Dissent preserved"]
+          })
+        ]
+      },
+      {
+        pattern: "specialist_committee",
+        aliases: ["committee", "aggregator"],
+        description: "Domain specialists produce findings; an aggregator preserves evidence and dissent.",
+        topology: "committee",
+        useWhen: ["The problem spans multiple domains or risk lenses."],
+        avoidWhen: ["The domain is singular and objective tests are available."],
+        coordinatorRequired: true,
+        maxAgents: 6,
+        systemPromptAddition: "Specialists must state assumptions, evidence, uncertainty, and dissent.",
+        stages: [
+          stage({
+            id: "technical",
+            label: "Technical specialist",
+            agentType: "general",
+            purpose: "Assess implementation feasibility and constraints.",
+            order: 1,
+            mode: "parallel",
+            parallelGroup: "committee",
+            outputContract: ["Technical findings", "Evidence", "Uncertainty"]
+          }),
+          stage({
+            id: "risk",
+            label: "Risk specialist",
+            agentType: "explore",
+            purpose: "Assess safety, operational, or regression risks.",
+            order: 1,
+            mode: "parallel",
+            parallelGroup: "committee",
+            outputContract: ["Risks", "Evidence", "Mitigations"]
+          }),
+          stage({
+            id: "aggregate",
+            label: "Aggregator",
+            agentType: "plan",
+            purpose: "Synthesize specialist findings and preserve disagreements.",
+            order: 2,
+            mode: "aggregate",
+            dependsOn: ["technical", "risk"],
+            outputContract: ["Synthesis", "Dissent", "Recommendation"]
+          })
+        ]
+      },
+      {
+        pattern: "hierarchical_crew",
+        aliases: ["crew", "multi_team"],
+        description: "A coordinator manages subcrews for large multi-domain work.",
+        topology: "hierarchical",
+        useWhen: ["The task is large, multi-domain, and decomposable."],
+        avoidWhen: ["A flat worker set is enough."],
+        coordinatorRequired: true,
+        maxAgents: 10,
+        systemPromptAddition: "Define hierarchy, responsibilities, checkpoints, and stop conditions before spawning subcrews.",
+        stages: [
+          stage({
+            id: "lead",
+            label: "Crew lead",
+            agentType: "coordinator",
+            purpose: "Own hierarchy, checkpoints, and final integration.",
+            order: 1,
+            mode: "coordinate",
+            outputContract: ["Hierarchy", "Responsibilities", "Checkpoints"]
+          }),
+          stage({
+            id: "subcrews",
+            label: "Subcrew workers",
+            agentType: "general",
+            purpose: "Execute scoped domain work under the lead.",
+            order: 2,
+            mode: "parallel",
+            dependsOn: ["lead"],
+            outputContract: ["Domain result", "Verification", "Blockers"]
+          })
+        ]
+      },
+      {
+        pattern: "blackboard",
+        aliases: ["shared_workspace"],
+        description: "Workers coordinate through a structured shared artifact.",
+        topology: "blackboard",
+        useWhen: ["Multiple agents must update a common evolving state."],
+        avoidWhen: ["Workers can return independent final outputs without coordination."],
+        coordinatorRequired: true,
+        maxAgents: 6,
+        systemPromptAddition: "Use a structured blackboard with author, timestamp, source, confidence, and conflict fields.",
+        stages: [
+          stage({
+            id: "board_init",
+            label: "Board initializer",
+            agentType: "plan",
+            purpose: "Create the shared artifact schema and initial task lanes.",
+            order: 1,
+            mode: "sequential",
+            outputContract: ["Board schema", "Task lanes", "Conflict policy"]
+          }),
+          stage({
+            id: "contributors",
+            label: "Contributors",
+            agentType: "general",
+            purpose: "Write structured entries to the board without conflicting writes.",
+            order: 2,
+            mode: "parallel",
+            dependsOn: ["board_init"],
+            outputContract: ["Board entries", "Sources", "Confidence"]
+          })
+        ]
+      },
+      {
+        pattern: "task_swarm",
+        aliases: ["swarm"],
+        description: "Many small stateless workers process granular queued tasks.",
+        topology: "swarm",
+        useWhen: ["The workload is large, partitionable, and homogeneous."],
+        avoidWhen: ["Workers need shared mutable state or nuanced coordination."],
+        coordinatorRequired: true,
+        maxAgents: 12,
+        systemPromptAddition: "Keep swarm workers stateless, cap fan-out, aggregate deterministically, and monitor cost.",
+        stages: [
+          stage({
+            id: "queue",
+            label: "Queue planner",
+            agentType: "plan",
+            purpose: "Partition work into small independent units.",
+            order: 1,
+            mode: "sequential",
+            outputContract: ["Queue entries", "Unit success criteria", "Fan-out cap"]
+          }),
+          stage({
+            id: "workers",
+            label: "Swarm workers",
+            agentType: "explore",
+            purpose: "Process assigned units independently.",
+            order: 2,
+            mode: "parallel",
+            dependsOn: ["queue"],
+            outputContract: ["Unit id", "Result", "Failure reason"]
+          })
+        ]
+      },
+      {
+        pattern: "dynamic_task_ledger",
+        aliases: ["magentic", "dynamic_ledger", "replan_ledger"],
+        description: "Maintain a visible task ledger while planning, executing, observing, and replanning.",
+        topology: "dynamic_ledger",
+        useWhen: ["The solution path is unknown and must adapt to observations."],
+        avoidWhen: ["A fixed pipeline or one worker can solve the task."],
+        coordinatorRequired: true,
+        maxAgents: 8,
+        systemPromptAddition: "Maintain a visible task/progress ledger with success criteria, completed work, blockers, and replan reasons.",
+        stages: [
+          stage({
+            id: "ledger",
+            label: "Ledger coordinator",
+            agentType: "coordinator",
+            purpose: "Maintain task decomposition and reconfigure subtasks as evidence arrives.",
+            order: 1,
+            mode: "coordinate",
+            outputContract: ["Current ledger", "Success criteria", "Replan reasons"]
+          }),
+          stage({
+            id: "workers",
+            label: "Adaptive workers",
+            agentType: "general",
+            purpose: "Execute current ledger items and return evidence.",
+            order: 2,
+            mode: "parallel",
+            dependsOn: ["ledger"],
+            outputContract: ["Ledger item id", "Evidence", "Blockers"]
+          }),
+          stage({
+            id: "verify",
+            label: "Verifier",
+            agentType: "explore",
+            purpose: "Verify completed ledger items before final synthesis.",
+            order: 3,
+            mode: "review",
+            dependsOn: ["workers"],
+            outputContract: ["Verified items", "Rejected claims", "Remaining work"]
+          })
+        ]
+      }
+    ];
+    AgentDeploymentPatternRegistry = class {
+      patterns = /* @__PURE__ */ new Map();
+      aliases = /* @__PURE__ */ new Map();
+      constructor() {
+        for (const def of BUILT_INS)
+          this.register(def);
+      }
+      register(def) {
+        this.validate(def);
+        this.patterns.set(def.pattern, def);
+        this.aliases.set(def.pattern, def.pattern);
+        for (const alias of def.aliases ?? [])
+          this.aliases.set(alias, def.pattern);
+      }
+      get(pattern) {
+        const canonical = this.aliases.get(pattern) ?? pattern;
+        return this.patterns.get(canonical);
+      }
+      listPatterns() {
+        return Array.from(this.patterns.keys());
+      }
+      listDefinitions() {
+        return Array.from(this.patterns.values());
+      }
+      plan(pattern, task) {
+        const def = this.get(pattern);
+        if (!def)
+          return void 0;
+        const typeRegistry = getAgentTypeRegistry();
+        const stages = def.stages.slice().sort((a2, b) => a2.order - b.order || a2.id.localeCompare(b.id)).map((s2) => ({
+          ...s2,
+          agentTypeDescription: typeRegistry.get(s2.agentType)?.description ?? "Unknown agent type"
+        }));
+        return {
+          pattern: def.pattern,
+          topology: def.topology,
+          description: def.description,
+          coordinatorRequired: def.coordinatorRequired,
+          task,
+          stages,
+          instructions: buildDeploymentPatternInstructions(def, stages, task)
+        };
+      }
+      buildPatternSummary() {
+        const lines = ["Available sub-agent deployment patterns:"];
+        for (const def of this.patterns.values()) {
+          lines.push(`- ${def.pattern} (${def.topology}): ${def.description} Use when: ${def.useWhen[0] ?? "structurally justified"}`);
+        }
+        return lines.join("\n");
+      }
+      validate(def) {
+        if (!def.pattern.trim())
+          throw new Error("pattern id is required");
+        if (!def.stages.length)
+          throw new Error(`pattern ${def.pattern} must define at least one stage`);
+        const typeRegistry = getAgentTypeRegistry();
+        const ids = /* @__PURE__ */ new Set();
+        for (const s2 of def.stages) {
+          if (!s2.id.trim())
+            throw new Error(`pattern ${def.pattern} has a stage without id`);
+          if (ids.has(s2.id))
+            throw new Error(`pattern ${def.pattern} repeats stage id ${s2.id}`);
+          ids.add(s2.id);
+          if (!typeRegistry.get(s2.agentType)) {
+            throw new Error(`pattern ${def.pattern} references unknown agent type ${s2.agentType}`);
+          }
+          for (const dep of s2.dependsOn ?? []) {
+            if (!def.stages.some((candidate) => candidate.id === dep)) {
+              throw new Error(`pattern ${def.pattern} stage ${s2.id} depends on unknown stage ${dep}`);
+            }
+          }
+        }
+        if (def.maxAgents < 1)
+          throw new Error(`pattern ${def.pattern} maxAgents must be positive`);
+      }
+    };
+    _patternRegistry = new AgentDeploymentPatternRegistry();
+  }
+});
+
 // packages/orchestrator/dist/agent-task.js
 function isTerminalTaskStatus(status) {
   return status === "completed" || status === "failed" || status === "killed";
@@ -596125,6 +596832,7 @@ var init_conversational_scrutiny = __esm({
 var dist_exports3 = {};
 __export(dist_exports3, {
   AGENT_DISALLOWED_TOOLS: () => AGENT_DISALLOWED_TOOLS,
+  AgentDeploymentPatternRegistry: () => AgentDeploymentPatternRegistry,
   AgentLoop: () => AgentLoop,
   AgentTaskManager: () => AgentTaskManager,
   AgentTypeRegistry: () => AgentTypeRegistry,
@@ -596180,6 +596888,7 @@ __export(dist_exports3, {
   arcSummary: () => arcSummary,
   auditCompletionClaims: () => auditCompletionClaims,
   auditPerceptionClaims: () => auditPerceptionClaims,
+  buildAgentDeploymentPatternSummary: () => buildAgentDeploymentPatternSummary,
   buildAgentNotification: () => buildAgentNotification,
   buildAgentTypeSummary: () => buildAgentTypeSummary,
   buildCompletionScenarioDecomposition: () => buildCompletionScenarioDecomposition,
@@ -596259,6 +596968,8 @@ __export(dist_exports3, {
   generateUserTestingResult: () => generateUserTestingResult,
   generateUserTestingValidatorSkill: () => generateUserTestingValidatorSkill,
   generateWorkerSkillTemplate: () => generateWorkerSkillTemplate,
+  getAgentDeploymentPattern: () => getAgentDeploymentPattern,
+  getAgentDeploymentPatternRegistry: () => getAgentDeploymentPatternRegistry,
   getAgentType: () => getAgentType,
   getAgentTypeRegistry: () => getAgentTypeRegistry,
   getAllDefaultPricing: () => getAllDefaultPricing,
@@ -596311,6 +597022,7 @@ __export(dist_exports3, {
   parseTextToolCalls: () => parseTextToolCalls,
   partitionToolCalls: () => partitionToolCalls,
   persistAgentTaskSidecar: () => persistAgentTaskSidecar,
+  planAgentDeploymentPattern: () => planAgentDeploymentPattern,
   planConsolidation: () => planConsolidation,
   preprocessContextReferences: () => preprocessContextReferences,
   pressureCheck: () => pressureCheck,
@@ -596338,6 +597050,7 @@ __export(dist_exports3, {
   recordToolDecision: () => recordToolDecision,
   recordToolEvidence: () => recordToolEvidence,
   recordToolExecution: () => recordToolExecution,
+  registerAgentDeploymentPattern: () => registerAgentDeploymentPattern,
   registerAgentType: () => registerAgentType,
   registerCommand: () => registerCommand,
   registerHookHandler: () => registerHookHandler,
@@ -596432,6 +597145,7 @@ var init_dist8 = __esm({
     init_stability_tracker();
     init_render_decision();
     init_agent_types();
+    init_agent_patterns();
     init_agent_task();
     init_task_recovery();
     init_coordinator();
@@ -596570,7 +597284,7 @@ function generationKindForToolName(toolName) {
 function formatGenerativeProgress(kind, event, options2 = {}) {
   const width = Math.max(8, Math.min(32, options2.width ?? (options2.surface === "telegram" ? 12 : 20)));
   const label = kindLabel2(kind);
-  const stage = stageLabel(event.stage);
+  const stage2 = stageLabel(event.stage);
   const pct = finitePercent(event.percent);
   const bytes = formatProgressBytes(event);
   const elapsed = formatElapsed(event.elapsedMs);
@@ -596578,17 +597292,17 @@ function formatGenerativeProgress(kind, event, options2 = {}) {
   if (typeof pct === "number") {
     const filled = Math.max(0, Math.min(width, Math.round(pct / 100 * width)));
     const bar = `${"#".repeat(filled)}${"-".repeat(width - filled)}`;
-    return `${label} ${stage}: [${bar}] ${pct}% ${message2}${bytes}${elapsed}`;
+    return `${label} ${stage2}: [${bar}] ${pct}% ${message2}${bytes}${elapsed}`;
   }
-  return `${label} ${stage}: ${message2}${bytes}${elapsed}`;
+  return `${label} ${stage2}: ${message2}${bytes}${elapsed}`;
 }
 function kindLabel2(kind) {
   if (kind === "tts") return "TTS";
   if (kind === "model") return "3D/CAD";
   return kind.slice(0, 1).toUpperCase() + kind.slice(1);
 }
-function stageLabel(stage) {
-  const normalized = String(stage || "process").trim().toLowerCase();
+function stageLabel(stage2) {
+  const normalized = String(stage2 || "process").trim().toLowerCase();
   if (normalized === "setup") return "setup";
   if (normalized === "download") return "download";
   if (normalized === "load") return "load";
@@ -658420,23 +659134,23 @@ ${sections.join("\n\n")}`;
 function adaptTool3(tool) {
   return adaptExecutionTool(tool);
 }
-function buildDreamPrompt(mode, stage, cycleNum, totalCycles, previousFindings, dreamsDir) {
+function buildDreamPrompt(mode, stage2, cycleNum, totalCycles, previousFindings, dreamsDir) {
   const modeDesc = mode === "lucid" ? "LUCID DREAM MODE: You have full implementation capability. After ideation, you will implement, test, and evaluate changes." : mode === "deep" ? "DEEP DREAM MODE: Explore deeply with multiple expansion/contraction cycles. All proposals go in .omnius/dreams/." : "DREAM MODE: Creative exploration only. All output must be written to .omnius/dreams/ directory using file_write.";
   const stageInstruction = {
     "NREM-1": `LIGHT SCAN (Stage 1/${SLEEP_STAGES.length}): Do a quick scan of the codebase structure. Identify the main files, architecture patterns, and surface-level observations. Note areas that catch your attention. Write a brief scan report.`,
     "NREM-2": `PATTERN DETECTION (Stage 2/${SLEEP_STAGES.length}): Look deeper at the patterns you noticed. Identify: technical debt, missing tests, code duplication, potential optimizations, missing features, security concerns, DX improvements. Categorize findings by priority.`,
     "NREM-3": `DEEP CONSOLIDATION (Stage 3/${SLEEP_STAGES.length}): Synthesize your findings into concrete, actionable proposals. For each proposal, write: (1) problem statement, (2) proposed solution with implementation plan, (3) estimated effort, (4) expected impact. Create clean entrypoint files.`,
     "REM": `CREATIVE EXPANSION (Stage 4/${SLEEP_STAGES.length}): Think boldly and creatively. What novel features could transform this project? Cross-domain inspiration? Unconventional approaches? Generate at least 3 wild ideas alongside 3 practical innovations. Write detailed vision documents.`
-  }[stage.name];
+  }[stage2.name];
   return loadPrompt3("tui/dream-stages.md", {
     modeDesc,
     cycleNum: String(cycleNum),
     totalCycles: String(totalCycles),
-    stageName: stage.name,
-    stageLabel: stage.label,
-    stageDescription: stage.description,
+    stageName: stage2.name,
+    stageLabel: stage2.label,
+    stageDescription: stage2.description,
     stageInstruction: stageInstruction || "",
-    stageNameLower: stage.name.toLowerCase(),
+    stageNameLower: stage2.name.toLowerCase(),
     previousFindings: previousFindings ? `PREVIOUS FINDINGS FROM EARLIER STAGES:
 ${previousFindings}
 ` : ""
@@ -658477,9 +659191,9 @@ function renderDreamStage(name10, label, description) {
 `);
   });
 }
-function renderDreamStageComplete(stage, durationMs) {
+function renderDreamStageComplete(stage2, durationMs) {
   const secs = (durationMs / 1e3).toFixed(1);
-  dreamWrite(() => process.stdout.write(`    ${c3.green("✔")} ${stage} complete ${c3.dim(`(${secs}s)`)}
+  dreamWrite(() => process.stdout.write(`    ${c3.green("✔")} ${stage2} complete ${c3.dim(`(${secs}s)`)}
 `));
 }
 function renderDreamContraction(cycle) {
@@ -658826,12 +659540,12 @@ var init_dream_engine = __esm({
             let previousFindings = "";
             const cycleResults = [];
             const modelTier2 = getModelTier(this.config.model);
-            for (const stage of SLEEP_STAGES) {
+            for (const stage2 of SLEEP_STAGES) {
               if (this.abortController.signal.aborted) break;
-              renderDreamStage(stage.name, stage.label, stage.description);
+              renderDreamStage(stage2.name, stage2.label, stage2.description);
               const startMs = Date.now();
               let result;
-              if (stage.name === "REM" && modelTier2 === "large" && detectSystemSpecs().gpuVramGB > 0) {
+              if (stage2.name === "REM" && modelTier2 === "large" && detectSystemSpecs().gpuVramGB > 0) {
                 renderInfo("REM: Autoresearch swarm — 5-agent GPU experiment loop (Researcher + Monitor + Evaluator + Critic + Flow Maintainer)");
                 const swarmResult = await this.runAutoresearchSwarm(
                   cycle,
@@ -658839,7 +659553,7 @@ var init_dream_engine = __esm({
                   onEvent
                 );
                 result = { summary: swarmResult.summary, turns: 0, toolCalls: 0 };
-              } else if (stage.name === "REM" && modelTier2 === "large") {
+              } else if (stage2.name === "REM" && modelTier2 === "large") {
                 renderInfo("REM: Multi-agent creative mode — parallel Visionary + Pragmatist + Cross-Pollinator");
                 const remResult = await this.runMultiAgentREM(
                   cycle,
@@ -658852,7 +659566,7 @@ var init_dream_engine = __esm({
               } else {
                 const prompt = buildDreamPrompt(
                   mode,
-                  stage,
+                  stage2,
                   cycle,
                   totalCycles,
                   previousFindings,
@@ -658867,7 +659581,7 @@ var init_dream_engine = __esm({
               const durationMs = Date.now() - startMs;
               const cycleResult = {
                 cycle,
-                stage: stage.name,
+                stage: stage2.name,
                 ideas: [],
                 proposals: [],
                 filesGenerated: [],
@@ -658875,12 +659589,12 @@ var init_dream_engine = __esm({
               };
               previousFindings += `
 
-### ${stage.label} findings:
+### ${stage2.label} findings:
 ${result.summary}`;
               cycleResult.ideas.push(result.summary);
               cycleResults.push(cycleResult);
               this.state.results.push(cycleResult);
-              renderDreamStageComplete(stage.name, durationMs);
+              renderDreamStageComplete(stage2.name, durationMs);
             }
             if (mode !== "default" || cycle === totalCycles) {
               renderDreamContraction(cycle);
@@ -666733,19 +667447,19 @@ function deriveVisualEvidencePlan(request) {
 }
 async function executeVisualEvidencePlan(resolution, plan, executor) {
   const stages = [];
-  for (const stage of plan.stages) {
+  for (const stage2 of plan.stages) {
     const start2 = Date.now();
     try {
-      const result = await executor(stage.kind, resolution.path, "auto");
-      stages.push({ ...stage, completed: true, output: result.output, durationMs: result.durationMs });
+      const result = await executor(stage2.kind, resolution.path, "auto");
+      stages.push({ ...stage2, completed: true, output: result.output, durationMs: result.durationMs });
     } catch (err) {
       stages.push({
-        ...stage,
+        ...stage2,
         completed: false,
         error: err instanceof Error ? err.message : String(err),
         durationMs: Date.now() - start2
       });
-      if (stage.required) break;
+      if (stage2.required) break;
     }
   }
   const succeeded = stages.filter((s2) => s2.completed);
@@ -678111,13 +678825,13 @@ ${TELEGRAM_PUBLIC_ORCHESTRATOR_CONTRACT}`
             if (!html) return;
             const state = stateFor(toolName);
             const now2 = Date.now();
-            const stage = String(event.stage || "process");
+            const stage2 = String(event.stage || "process");
             const percent = typeof event.percent === "number" && Number.isFinite(event.percent) ? Math.round(event.percent) : void 0;
-            const terminalStage = stage === "save" || stage === "thumbnail" || stage === "hf_token_required";
-            const shouldRender = state.lastRenderedAt === 0 || stage !== state.lastStage || typeof percent === "number" && (state.lastPercent === void 0 || Math.abs(percent - state.lastPercent) >= 5) || now2 - state.lastRenderedAt >= 3500 || terminalStage;
+            const terminalStage = stage2 === "save" || stage2 === "thumbnail" || stage2 === "hf_token_required";
+            const shouldRender = state.lastRenderedAt === 0 || stage2 !== state.lastStage || typeof percent === "number" && (state.lastPercent === void 0 || Math.abs(percent - state.lastPercent) >= 5) || now2 - state.lastRenderedAt >= 3500 || terminalStage;
             if (!shouldRender) return;
             state.lastRenderedAt = now2;
-            state.lastStage = stage;
+            state.lastStage = stage2;
             state.lastPercent = percent;
             enqueue(state, html);
           },
@@ -690225,7 +690939,7 @@ async function tunnelViaTor(req3) {
 function openSocks5(targetHost, targetPort, timeoutMs) {
   return new Promise((resolve74, reject) => {
     const sock = createConnection3({ host: DEFAULT_SOCKS_HOST, port: DEFAULT_SOCKS_PORT });
-    let stage = "greet";
+    let stage2 = "greet";
     const timer = setTimeout(() => {
       try {
         sock.destroy(new Error(`Tor SOCKS5 timeout (${timeoutMs}ms)`));
@@ -690241,7 +690955,7 @@ function openSocks5(targetHost, targetPort, timeoutMs) {
       sock.write(Buffer.from([5, 1, 0]));
     });
     sock.on("data", (chunk) => {
-      if (stage === "greet") {
+      if (stage2 === "greet") {
         if (chunk.length < 2 || chunk[0] !== 5 || chunk[1] !== 0) {
           clearTimeout(timer);
           reject(new Error("Tor SOCKS5: greeting rejected (auth required?)"));
@@ -690261,10 +690975,10 @@ function openSocks5(targetHost, targetPort, timeoutMs) {
         hostBuf.copy(buf, 5);
         buf.writeUInt16BE(targetPort, 5 + hostBuf.length);
         sock.write(buf);
-        stage = "connect";
+        stage2 = "connect";
         return;
       }
-      if (stage === "connect") {
+      if (stage2 === "connect") {
         if (chunk.length < 2 || chunk[0] !== 5) {
           clearTimeout(timer);
           reject(new Error("Tor SOCKS5: malformed CONNECT reply"));
@@ -690285,7 +690999,7 @@ function openSocks5(targetHost, targetPort, timeoutMs) {
           return;
         }
         clearTimeout(timer);
-        stage = "ready";
+        stage2 = "ready";
         resolve74(sock);
       }
     });
@@ -717076,6 +717790,7 @@ Bypass for special cases: set env OMNIUS_DISABLE_TASK_COMPLETE_BUILD_GUARD=1 (no
 }
 function wireAgentToolMinimal(tool, config, repoRoot) {
   const typeRegistry = getAgentTypeRegistry();
+  const patternRegistry = getAgentDeploymentPatternRegistry();
   const allToolNames = [
     "file_read",
     "file_write",
@@ -717109,6 +717824,27 @@ function wireAgentToolMinimal(tool, config, repoRoot) {
       };
     },
     listTypes: () => typeRegistry.listTypes(),
+    resolveDeploymentPattern: (patternName, task) => {
+      const plan = patternRegistry.plan(patternName, task);
+      if (!plan) return void 0;
+      return {
+        pattern: plan.pattern,
+        topology: plan.topology,
+        description: plan.description,
+        coordinatorRequired: plan.coordinatorRequired,
+        instructions: plan.instructions,
+        stages: plan.stages.map((stage2) => ({
+          id: stage2.id,
+          label: stage2.label,
+          agentType: stage2.agentType,
+          mode: stage2.mode,
+          order: stage2.order,
+          ...stage2.parallelGroup ? { parallelGroup: stage2.parallelGroup } : {},
+          ...stage2.dependsOn ? { dependsOn: stage2.dependsOn } : {}
+        }))
+      };
+    },
+    listDeploymentPatterns: () => patternRegistry.listPatterns(),
     spawnInProcess: async (opts) => {
       let backend;
       if (config.backendType === "nexus") {
@@ -721177,6 +721913,7 @@ Review its full output via sub_agent(action='output', id='${id}')`
     };
     _wireAgentToolCallbacks = (tool) => {
       const typeRegistry = getAgentTypeRegistry();
+      const patternRegistry = getAgentDeploymentPatternRegistry();
       const allToolNames = [
         "file_read",
         "file_write",
@@ -721216,6 +721953,27 @@ Review its full output via sub_agent(action='output', id='${id}')`
           };
         },
         listTypes: () => typeRegistry.listTypes(),
+        resolveDeploymentPattern: (patternName, task) => {
+          const plan = patternRegistry.plan(patternName, task);
+          if (!plan) return void 0;
+          return {
+            pattern: plan.pattern,
+            topology: plan.topology,
+            description: plan.description,
+            coordinatorRequired: plan.coordinatorRequired,
+            instructions: plan.instructions,
+            stages: plan.stages.map((stage2) => ({
+              id: stage2.id,
+              label: stage2.label,
+              agentType: stage2.agentType,
+              mode: stage2.mode,
+              order: stage2.order,
+              ...stage2.parallelGroup ? { parallelGroup: stage2.parallelGroup } : {},
+              ...stage2.dependsOn ? { dependsOn: stage2.dependsOn } : {}
+            }))
+          };
+        },
+        listDeploymentPatterns: () => patternRegistry.listPatterns(),
         spawnInProcess: async (opts) => {
           let backend;
           if (config.backendType === "nexus") {