omnius 1.0.382 → 1.0.384

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) {
@@ -569456,8 +569521,8 @@ var init_focusSupervisor = __esm({
             const directive = this.setDirective({
               turn: input.turn,
               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,
+              reason: ignoredManyTimes ? `model ignored ${this.ignoredDirectiveStreak} focus directives; take the required recovery action before trying another variant` : `model ignored prior directive ${prior.id}; ${prior.reason}`,
+              requiredNextAction: prior.requiredNextAction,
               forbiddenActionFamilies: unique2([
                 ...prior.forbiddenActionFamilies,
                 family
@@ -569561,7 +569626,7 @@ var init_focusSupervisor = __esm({
             turn: input.turn,
             state: "forced_replan",
             reason: `same ${input.toolName} failure family repeated ${next.count} times: ${next.sample}`,
-            requiredNextAction: input.toolName === "shell" ? "read_authoritative_target" : "update_todos",
+            requiredNextAction: input.toolName === "shell" ? "edit_different_target" : "update_todos",
             forbiddenActionFamilies: [actionFamily(input.toolName, input.args)]
           });
         }
@@ -572886,6 +572951,7 @@ ${parts.join("\n")}
           memoryPrefix: options2?.memoryPrefix ?? "",
           memoryPrefixHash: options2?.memoryPrefixHash ?? "",
           stateDir: options2?.stateDir ?? "",
+          surface: options2?.surface ?? "tui",
           artifactMode: options2?.artifactMode ?? "user-task",
           disablePersistentMemory: options2?.disablePersistentMemory ?? false,
           disableCodebaseMap: options2?.disableCodebaseMap ?? false,
@@ -572960,11 +573026,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,
@@ -573237,16 +573303,21 @@ ${parts.join("\n")}
       // -------------------------------------------------------------------------
       /** Infer the surface identifier from runner configuration and dynamic context. */
       _inferSurface() {
-        const ctx3 = this._stickyDynamicContext || this.options.dynamicContext || "";
-        if (/Admin Capability/i.test(ctx3) || /telegram-admin/i.test(ctx3))
-          return "telegram-admin";
-        if (/Telegram|telegram|Voice Soul/i.test(ctx3) || this.options.stateDir)
-          return "telegram-public";
-        if (/api/i.test(ctx3))
-          return "api";
-        if (/background/i.test(ctx3))
-          return "background";
-        return "tui";
+        return this.options.surface;
+      }
+      _isTelegramSurface() {
+        return this.options.surface === "telegram-public" || this.options.surface === "telegram-admin";
+      }
+      stickyDynamicContextForActiveSurface() {
+        const ctx3 = this._stickyDynamicContext.trim();
+        if (!ctx3)
+          return "";
+        if (this._isTelegramSurface())
+          return ctx3;
+        const voiceSoul = this.extractDynamicMarkdownBlock(ctx3, "## Voice Soul Context", 6e3);
+        if (!voiceSoul)
+          return "";
+        return /Telegram|telegram|Public Telegram|Admin Capability/i.test(voiceSoul) ? "" : voiceSoul;
       }
       /**
        * Build structured context via the context engine.
@@ -587007,10 +587078,11 @@ ${postCompactRestore.join("\n")}`);
 [Ephemeral skill-pack restore — current run only, do not persist]
 ${this._ephemeralSkillPackContext}
 Use skill_extract for targeted skill unpacking; do not load full skills into the main context unless necessary.` : "";
-        const stickyDynamicContextReminder = this._stickyDynamicContext ? `
+        const scopedStickyDynamicContext = this.stickyDynamicContextForActiveSurface();
+        const stickyDynamicContextReminder = scopedStickyDynamicContext ? `
 
 [Sticky dynamic context restore — surface/persona anchors]
-${this._stickyDynamicContext}` : "";
+${scopedStickyDynamicContext}` : "";
         const compactionMsg = {
           role: "system",
           // WO-CE-03: XML tags for structural clarity on small/medium models
@@ -587027,7 +587099,7 @@ ${fullSummary}
         this.persistCheckpoint(fullSummary);
         let narrowedHead = [...head];
         const EVIDENCE_RULE_COMPACT = `EVIDENCE RULE (PRIORITY 0): never claim something works or is true unless a tool result you saw this turn proves it. A command succeeding only means it ran — not that the intended effect happened; verify the end-state directly before claiming it. A negative, empty, or error result means failed or absent — report it, never explain it away with an untested theory. Never describe how you got a result (tool, command, or source) unless you actually used it. Do not assert relationships the output does not show. Say "I could not verify X" when it is unproven — that is the correct answer, not a guess.`;
-        const telegramPersonaHead = /Telegram|Voice Soul Context|Public Telegram voice profile/.test(this._stickyDynamicContext) ? `You are Omnius replying through Telegram. Your visible assistant text is sent to Telegram; keep it concise, scoped, and user-facing. Do not emit scratch notes, router decisions, internal status, or no_reply text. Use available tools when needed and call task_complete when the Telegram run is complete.
+        const telegramPersonaHead = this._isTelegramSurface() && /Telegram|Voice Soul Context|Public Telegram voice profile/.test(scopedStickyDynamicContext) ? `You are Omnius replying through Telegram. Your visible assistant text is sent to Telegram; keep it concise, scoped, and user-facing. Do not emit scratch notes, router decisions, internal status, or no_reply text. Use available tools when needed and call task_complete when the Telegram run is complete.
 
 ${EVIDENCE_RULE_COMPACT}
 
@@ -587182,7 +587254,12 @@ ${content.slice(0, 8e3)}
             while (trimmedRecent.length > 1 && trimmedRecent[0]?.role === "tool") {
               trimmedRecent = trimmedRecent.slice(1);
             }
-            result = [...head, compactionMsg, ...stickyToKeep, ...trimmedRecent];
+            result = [
+              ...narrowedHead,
+              compactionMsg,
+              ...stickyToKeep,
+              ...trimmedRecent
+            ];
           }
           if (trimmedRecent.length < filteredRecent.length) {
             this.emit({
@@ -592957,6 +593034,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";
@@ -596208,6 +596844,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,
@@ -596263,6 +596900,7 @@ __export(dist_exports3, {
   arcSummary: () => arcSummary,
   auditCompletionClaims: () => auditCompletionClaims,
   auditPerceptionClaims: () => auditPerceptionClaims,
+  buildAgentDeploymentPatternSummary: () => buildAgentDeploymentPatternSummary,
   buildAgentNotification: () => buildAgentNotification,
   buildAgentTypeSummary: () => buildAgentTypeSummary,
   buildCompletionScenarioDecomposition: () => buildCompletionScenarioDecomposition,
@@ -596342,6 +596980,8 @@ __export(dist_exports3, {
   generateUserTestingResult: () => generateUserTestingResult,
   generateUserTestingValidatorSkill: () => generateUserTestingValidatorSkill,
   generateWorkerSkillTemplate: () => generateWorkerSkillTemplate,
+  getAgentDeploymentPattern: () => getAgentDeploymentPattern,
+  getAgentDeploymentPatternRegistry: () => getAgentDeploymentPatternRegistry,
   getAgentType: () => getAgentType,
   getAgentTypeRegistry: () => getAgentTypeRegistry,
   getAllDefaultPricing: () => getAllDefaultPricing,
@@ -596394,6 +597034,7 @@ __export(dist_exports3, {
   parseTextToolCalls: () => parseTextToolCalls,
   partitionToolCalls: () => partitionToolCalls,
   persistAgentTaskSidecar: () => persistAgentTaskSidecar,
+  planAgentDeploymentPattern: () => planAgentDeploymentPattern,
   planConsolidation: () => planConsolidation,
   preprocessContextReferences: () => preprocessContextReferences,
   pressureCheck: () => pressureCheck,
@@ -596421,6 +597062,7 @@ __export(dist_exports3, {
   recordToolDecision: () => recordToolDecision,
   recordToolEvidence: () => recordToolEvidence,
   recordToolExecution: () => recordToolExecution,
+  registerAgentDeploymentPattern: () => registerAgentDeploymentPattern,
   registerAgentType: () => registerAgentType,
   registerCommand: () => registerCommand,
   registerHookHandler: () => registerHookHandler,
@@ -596515,6 +597157,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();
@@ -596653,7 +597296,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);
@@ -596661,17 +597304,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";
@@ -658503,23 +659146,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}
 ` : ""
@@ -658560,9 +659203,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) {
@@ -658909,12 +659552,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,
@@ -658922,7 +659565,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,
@@ -658935,7 +659578,7 @@ var init_dream_engine = __esm({
               } else {
                 const prompt = buildDreamPrompt(
                   mode,
-                  stage,
+                  stage2,
                   cycle,
                   totalCycles,
                   previousFindings,
@@ -658950,7 +659593,7 @@ var init_dream_engine = __esm({
               const durationMs = Date.now() - startMs;
               const cycleResult = {
                 cycle,
-                stage: stage.name,
+                stage: stage2.name,
                 ideas: [],
                 proposals: [],
                 filesGenerated: [],
@@ -658958,12 +659601,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);
@@ -666816,19 +667459,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);
@@ -678194,13 +678837,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);
           },
@@ -680203,6 +680846,7 @@ ${conversationStream}`
         );
         const requestTimeoutMs = config.timeoutMs ?? 3e5;
         const runner = new AgenticRunner(backend, {
+          surface: isAdminDM || isAdminGroup ? "telegram-admin" : "telegram-public",
           // Admin DMs are operator-directed work sessions. A hard turn cap turns
           // active tool progress into a false "completed" Telegram panel when the
           // model has not reached task_complete yet. Public/group runs stay bounded.
@@ -690308,7 +690952,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)`));
@@ -690324,7 +690968,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?)"));
@@ -690344,10 +690988,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"));
@@ -690368,7 +691012,7 @@ function openSocks5(targetHost, targetPort, timeoutMs) {
           return;
         }
         clearTimeout(timer);
-        stage = "ready";
+        stage2 = "ready";
         resolve74(sock);
       }
     });
@@ -717159,6 +717803,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",
@@ -717192,6 +717837,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") {
@@ -719068,6 +719734,7 @@ Only tools allowed by this profile are visible and executable.`
     ].filter(Boolean).join("");
   }
   const runner = new AgenticRunner(backend, {
+    surface: "tui",
     maxTurns: realtimeEnabled ? Math.min(effectiveMaxTurns, 8) : effectiveMaxTurns,
     maxTokens: realtimeEnabled ? 512 : 16384,
     temperature: realtimeEnabled ? 0.6 : 0,
@@ -721260,6 +721927,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",
@@ -721299,6 +721967,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") {
@@ -722040,6 +722729,7 @@ Respond to the scoped Telegram target when complete.`
       }
       const modelTier2 = getModelTier(currentConfig.model);
       const runner = new AgenticRunner(backend, {
+        surface: "background",
         // 0 = unlimited; halt only on task_complete or abort. Background
         // prompts may legitimately need many turns; an arbitrary cap stalls
         // them mid-task.

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.382",
+  "version": "1.0.384",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.382",
+      "version": "1.0.384",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.382",
+  "version": "1.0.384",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",