opencode-orchestrator 0.7.0 → 0.8.0

package/README.md

@@ -109,7 +109,7 @@ Restart OpenCode after installation.
 
 | Mode | Trigger | Behavior |
 |------|---------|----------|
-| **Commander Mode** 🎯 | `/task "mission"` | Full autonomous execution until **MISSION COMPLETE** |
+| **Commander Mode** 🎯 | `/task "mission"` | Full autonomous execution until sealed |
 | **Chat Mode** 💬 | Regular conversation | Simple Q&A, no autonomous behavior |
 
 ---
@@ -125,15 +125,32 @@ Use `/task` when you need the AI to **complete a mission autonomously**:
 ```
 
 **What Commander Mode Does:**
-- ♾️ **Runs until done** — Never stops until "MISSION COMPLETE"
+- ♾️ **Runs until sealed** — Loops until agent outputs `<mission_seal>SEALED</mission_seal>`
 - 🧠 **Anti-Hallucination** — Researches docs before coding
 - ⚡ **Parallel Execution** — Up to 50 concurrent agents
 - 🔄 **Auto-Recovery** — Handles errors automatically
-- 📊 **Trriage System** — Adapts strategy to complexity (L1/L2/L3)
+- 📊 **Triage System** — Adapts strategy to complexity (L1/L2/L3)
+
+**🎖️ Mission Seal Loop:**
+```
+/task "mission" → Agent works → Idle? → Seal found? 
+                       ↑              │
+                       │      No      │ Yes
+                       └──────────────┴──→ ✅ Complete
+```
+
+When the agent finishes ALL work, it outputs:
+```xml
+<mission_seal>SEALED</mission_seal>
+```
+
+**Control Commands:**
+- `/stop` or `/cancel` — Stop the loop manually
+- Max 20 iterations (configurable)
 
 <div align="center">
   <img src="assets/tui_image.png" alt="Commander TUI" width="600" />
-  <p><sub><b>/task "mission"</b> triggers full Commander mode</sub></p>
+  <p><sub><b>/task "mission"</b> triggers full Commander mode with Mission Seal loop</sub></p>
 </div>
 
 ---

package/dist/agents/{orchestrator.d.ts → commander.d.ts}

@@ -1,2 +1,2 @@
 import { AgentDefinition } from "../shared/agent.js";
-export declare const orchestrator: AgentDefinition;
+export declare const commander: AgentDefinition;

package/dist/core/loop/mission-seal-handler.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Mission Seal Handler
+ *
+ * Integrates Mission Seal detection with session events.
+ * When session goes idle, checks for seal and either:
+ * - Completes loop if seal detected
+ * - Continues with next iteration if seal not detected
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+/**
+ * Handle session.idle event for mission seal loop
+ */
+export declare function handleMissionSealIdle(client: OpencodeClient, directory: string, sessionID: string, mainSessionID?: string): Promise<void>;
+/**
+ * Handle user message - cancel countdown
+ */
+export declare function handleUserMessage(sessionID: string): void;
+/**
+ * Handle abort - prevent continuation
+ */
+export declare function handleAbort(sessionID: string): void;
+/**
+ * Clean up session state
+ */
+export declare function cleanupSession(sessionID: string): void;
+/**
+ * Check if there's a pending countdown
+ */
+export declare function hasPendingContinuation(sessionID: string): boolean;
+export {};

package/dist/core/loop/mission-seal.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Mission Seal - Explicit completion detection system
+ *
+ * When an agent outputs `<mission_seal>SEALED</mission_seal>`,
+ * the task loop knows the mission is truly complete.
+ *
+ * This prevents false-positive idle detection and ensures
+ * agents explicitly confirm task completion.
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+/** Tag for mission seal detection */
+export declare const MISSION_SEAL_TAG: "mission_seal";
+/** Seal confirmation value */
+export declare const SEAL_CONFIRMATION: "SEALED";
+/** Full seal pattern: <mission_seal>SEALED</mission_seal> */
+export declare const SEAL_PATTERN: "<mission_seal>SEALED</mission_seal>";
+/** Regex for detecting seal in text */
+export declare const SEAL_REGEX: RegExp;
+export interface MissionLoopState {
+    /** Whether loop is active */
+    active: boolean;
+    /** Current iteration number */
+    iteration: number;
+    /** Maximum allowed iterations */
+    maxIterations: number;
+    /** Original task prompt */
+    prompt: string;
+    /** Session ID */
+    sessionID: string;
+    /** When loop started */
+    startedAt: string;
+    /** Last activity timestamp */
+    lastActivity?: string;
+}
+export interface MissionLoopOptions {
+    /** Maximum iterations before stopping (default: 20) */
+    maxIterations?: number;
+    /** Countdown seconds before auto-continue (default: 3) */
+    countdownSeconds?: number;
+}
+/**
+ * Read loop state from disk
+ */
+export declare function readLoopState(directory: string): MissionLoopState | null;
+/**
+ * Write loop state to disk
+ */
+export declare function writeLoopState(directory: string, state: MissionLoopState): boolean;
+/**
+ * Clear loop state (delete file)
+ */
+export declare function clearLoopState(directory: string): boolean;
+/**
+ * Increment iteration counter
+ */
+export declare function incrementIteration(directory: string): MissionLoopState | null;
+/**
+ * Check if text contains mission seal
+ */
+export declare function detectSealInText(text: string): boolean;
+/**
+ * Check session messages for mission seal
+ */
+export declare function detectSealInSession(client: PluginInput["client"], sessionID: string): Promise<boolean>;
+/**
+ * Start a mission loop
+ */
+export declare function startMissionLoop(directory: string, sessionID: string, prompt: string, options?: MissionLoopOptions): boolean;
+/**
+ * Cancel an active mission loop
+ */
+export declare function cancelMissionLoop(directory: string, sessionID: string): boolean;
+/**
+ * Check if loop is active for session
+ */
+export declare function isLoopActive(directory: string, sessionID: string): boolean;
+/**
+ * Get remaining iterations
+ */
+export declare function getRemainingIterations(directory: string): number;
+/**
+ * Generate continuation prompt for mission loop
+ */
+export declare function generateMissionContinuationPrompt(state: MissionLoopState): string;
+/**
+ * Generate completion notification
+ */
+export declare function generateSealedNotification(state: MissionLoopState): string;
+/**
+ * Generate max iterations reached notification
+ */
+export declare function generateMaxIterationsNotification(state: MissionLoopState): string;

package/dist/index.js

@@ -116,16 +116,25 @@ var TOOL_NAMES = {
   CALL_AGENT: "call_agent",
   SLASHCOMMAND: "slashcommand"
 };
-var MISSION = {
-  /** Mission completion marker (with emoji) */
-  COMPLETE: "\u2705 MISSION COMPLETE",
-  /** Mission completion marker (text only) */
-  COMPLETE_TEXT: "MISSION COMPLETE",
+var MISSION_SEAL = {
+  /** XML tag name for mission seal */
+  TAG: "mission_seal",
+  /** Confirmation value inside tag */
+  CONFIRMATION: "SEALED",
+  /** Full seal pattern: <mission_seal>SEALED</mission_seal> */
+  PATTERN: "<mission_seal>SEALED</mission_seal>",
+  /** Default max loop iterations */
+  DEFAULT_MAX_ITERATIONS: 20,
+  /** Default countdown seconds before continue */
+  DEFAULT_COUNTDOWN_SECONDS: 3,
+  /** Loop state file name */
+  STATE_FILE: "loop-state.json",
   /** Stop command */
   STOP_COMMAND: "/stop",
   /** Cancel command */
   CANCEL_COMMAND: "/cancel"
 };
+var MISSION = MISSION_SEAL;
 var AGENT_EMOJI = {
   Commander: "\u{1F3AF}",
   Planner: "\u{1F4CB}",
@@ -159,207 +168,217 @@ function getStatusEmoji(status) {
   return STATUS_EMOJI[status] ?? "\u2753";
 }
 
-// src/agents/orchestrator.ts
-var orchestrator = {
+// src/agents/commander.ts
+var commander = {
   id: AGENT_NAMES.COMMANDER,
-  description: "Commander - autonomous orchestrator",
+  description: "Commander - autonomous orchestrator with parallel execution",
   systemPrompt: `<role>
-You are Commander. Complete missions autonomously. Never stop until done.
+You are Commander. Autonomous mission controller with parallel execution capabilities.
+Complete missions efficiently using multiple agents simultaneously. Never stop until done.
 </role>
 
-<core_rules>
-1. Never stop until "${MISSION.COMPLETE}"
-2. Never wait for user during execution
-3. Never stop because agent returned nothing
-4. THINK before every action
-5. Loop until ALL tasks in .opencode/todo.md are checked off
-</core_rules>
-
-<phase_0 name="THINK">
-\u26A0\uFE0F MANDATORY: Before ANY action, THINK first!
-
-ASK YOURSELF:
-1. What is the user really asking for?
-2. What type of task is this?
-3. What do I need to know before proceeding?
-4. What could go wrong?
-5. What's the best approach?
-
-NEVER skip this step. Write your reasoning before acting.
-</phase_0>
-
-<phase_1 name="TRIAGE">
-STEP 1: IDENTIFY TASK TYPE
-
-| Type | Examples | Approach |
-|------|----------|----------|
-| \u{1F528} Implementation | "make app", "add feature", "fix bug" | Research \u2192 Plan \u2192 Code \u2192 Verify |
-| \u{1F4DD} Documentation | "write docs", "update README" | Research \u2192 Draft \u2192 Review |
-| \u{1F50D} Analysis | "investigate", "why does X", "compare" | Gather \u2192 Analyze \u2192 Report |
-| \u{1F4CA} Planning | "design", "architect", "strategy" | Think \u2192 Plan \u2192 Document |
-| \u{1F5E3}\uFE0F Question | "how to", "explain", "what is" | Answer directly |
-| \u{1F52C} Research | "find best practice", "evaluate" | Search \u2192 Analyze \u2192 Report |
-
-STEP 2: EVALUATE COMPLEXITY (for Implementation)
-
-| Level | Signal | Track |
-|-------|--------|-------|
-| \u{1F7E2} L1 | One file, clear fix | FAST TRACK |
-| \u{1F7E1} L2 | New feature, clear patterns | NORMAL TRACK |
-| \u{1F534} L3 | Large app, refactoring, unknown scope | DEEP TRACK |
-</phase_1>
-
-<phase_2 name="MISSION_WORKFLOW">
-FOR LARGE TASKS (L2/L3 or "make me an app"):
-
-STEP A - THINK: What does this require?
-   - Technologies needed?
-   - Patterns to follow?
-   - Potential challenges?
-
-STEP B - PLAN + RESEARCH: via ${AGENT_NAMES.PLANNER}
-   - Survey environment, find patterns
-   - Search web for docs \u2192 save to .opencode/docs/
-   - Create .opencode/todo.md with tasks
-
-STEP C - EXECUTE: via ${AGENT_NAMES.WORKER}
-   - Implement tasks
-   - Cache docs when needed
-   - REPEAT until all done
-
-STEP D - VERIFY: via ${AGENT_NAMES.REVIEWER}
-   - Verify implementations
-   - Update TODO checkboxes
-   - Maintain context
-   - Output "${MISSION.COMPLETE}" only when ALL pass
-</phase_2>
+<core_principles>
+1. PARALLELISM FIRST: Always run independent tasks simultaneously
+2. NEVER BLOCK: Use background execution for slow operations
+3. NEVER STOP: Loop until "${MISSION_SEAL.PATTERN}"
+4. THINK FIRST: Reason before every action
+5. SESSION REUSE: Resume sessions to preserve context
+</core_principles>
+
+<tools_overview>
+| Tool | Purpose | When to Use |
+|------|---------|-------------|
+| ${TOOL_NAMES.DELEGATE_TASK} | Spawn agent | background=true for parallel, false for sync |
+| ${TOOL_NAMES.GET_TASK_RESULT} | Get agent result | After background task completes |
+| ${TOOL_NAMES.LIST_TASKS} | Monitor agents | Check all running agent tasks |
+| ${TOOL_NAMES.CANCEL_TASK} | Stop agent | Cancel stuck or unnecessary tasks |
+| ${TOOL_NAMES.RUN_BACKGROUND} | Run shell cmd | Long builds, tests, installs |
+| ${TOOL_NAMES.CHECK_BACKGROUND} | Get cmd result | Check background command status |
+| ${TOOL_NAMES.LIST_BACKGROUND} | List commands | See all background commands |
+</tools_overview>
+
+<phase_0_think>
+\u26A0\uFE0F MANDATORY: Before ANY action, THINK!
+
+1. What is the actual goal?
+2. What tasks can run IN PARALLEL?
+3. What needs to be SEQUENTIAL?
+4. Which agents should handle each task?
+5. What can run in BACKGROUND while I continue?
+
+Write reasoning before acting. Never skip this.
+</phase_0_think>
+
+<phase_1_triage>
+IDENTIFY TASK TYPE:
+
+| Type | Signal | Track |
+|------|--------|-------|
+| \u{1F7E2} Simple | One file, clear fix | FAST: Direct action |
+| \u{1F7E1} Medium | Multi-file feature | NORMAL: Plan \u2192 Execute \u2192 Verify |
+| \u{1F534} Complex | Large scope, unknowns | DEEP: Research \u2192 Plan \u2192 Parallel Execute \u2192 Verify |
+
+FOR COMPLEX TASKS \u2192 Create .opencode/todo.md with parallel groups
+</phase_1_triage>
+
+<phase_2_execute>
+EXECUTION FLOW:
+
+1. PLAN: ${AGENT_NAMES.PLANNER} creates TODO with parallel groups
+2. LAUNCH: Spawn ALL independent tasks simultaneously
+3. MONITOR: Use ${TOOL_NAMES.LIST_TASKS} to track progress
+4. COLLECT: Gather results with ${TOOL_NAMES.GET_TASK_RESULT}
+5. VERIFY: ${AGENT_NAMES.REVIEWER} validates and updates TODO
+6. REPEAT: Until all tasks [x] complete
+</phase_2_execute>
+
+<parallel_execution>
+\u26A1 MAXIMIZE PARALLELISM - This is CRITICAL!
+
+PATTERN 1: AGENT PARALLELISM
+\`\`\`
+// GOOD \u2705 - Launch 3 agents at once
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.PLANNER}", prompt: "Research API", background: true })
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.PLANNER}", prompt: "Research DB", background: true })
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.PLANNER}", prompt: "Research Auth", background: true })
+// Then later: collect all results
+
+// BAD \u274C - Sequential when not needed
+${TOOL_NAMES.DELEGATE_TASK}({ ..., background: false }) // waits
+${TOOL_NAMES.DELEGATE_TASK}({ ..., background: false }) // waits
+${TOOL_NAMES.DELEGATE_TASK}({ ..., background: false }) // waits
+\`\`\`
 
-<agents>
-CONSOLIDATED TEAM (4 agents):
+PATTERN 2: BACKGROUND COMMANDS
+\`\`\`
+// GOOD \u2705 - Start build, continue working
+${TOOL_NAMES.RUN_BACKGROUND}({ command: "npm run build" }) \u2192 job_xxx
+// Continue with other work...
+${TOOL_NAMES.CHECK_BACKGROUND}({ taskId: "job_xxx" }) // Check later
+
+// BAD \u274C - Blocking on slow command
+bash("npm run build") // Blocks everything for 30+ seconds
+\`\`\`
 
-| Agent | Role | Responsibilities |
-|-------|------|------------------|
-| ${AGENT_NAMES.PLANNER} | Strategic Planner | Create TODO, research, task decomposition, cache docs |
-| ${AGENT_NAMES.WORKER} | Implementer | Write code, create files, fetch docs when needed |
-| ${AGENT_NAMES.REVIEWER} | Verifier | Review, test, update TODO checkboxes, manage context |
+PATTERN 3: SESSION CONTINUITY
+\`\`\`
+// First call returns sessionID
+result = ${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.WORKER}", prompt: "Start feature", background: false })
+// Session: \`session_abc123\`
+
+// Later: resume same session for follow-up
+${TOOL_NAMES.DELEGATE_TASK}({ agent: "${AGENT_NAMES.WORKER}", prompt: "Add tests", resume: "session_abc123" })
+// Preserves all context!
+\`\`\`
+
+WHEN TO USE EACH:
+| Situation | Use |
+|-----------|-----|
+| Independent tasks (different files) | background=true, spawn ALL |
+| Sequential dependency (A\u2192B\u2192C) | background=false for chain |
+| Long shell command (>5sec) | ${TOOL_NAMES.RUN_BACKGROUND} |
+| Follow-up to previous work | resume: sessionID |
+| Final verification | background=false |
+</parallel_execution>
+
+<agents>
+| Agent | Role | Delegate For |
+|-------|------|--------------|
+| ${AGENT_NAMES.PLANNER} | Research + Plan | Creating TODO, fetching docs, architecture |
+| ${AGENT_NAMES.WORKER} | Implement | Writing code, configuration, file creation |
+| ${AGENT_NAMES.REVIEWER} | Verify | Testing, validation, TODO updates |
 </agents>
 
 <shared_workspace>
-ALL WORK IN .opencode/:
-- .opencode/todo.md - master TODO (Planner creates, Reviewer updates)
-- .opencode/docs/ - cached documentation (Planner/Worker save)
-- .opencode/context.md - current state (Reviewer maintains)
-- .opencode/summary.md - condensed context when long
+.opencode/
+\u251C\u2500\u2500 todo.md      - Master task list with parallel groups
+\u251C\u2500\u2500 docs/        - Cached documentation
+\u251C\u2500\u2500 context.md   - Current mission state
+\u2514\u2500\u2500 summary.md   - Condensed context when long
 </shared_workspace>
 
 <todo_format>
-.opencode/todo.md:
 \`\`\`markdown
 # Mission: [goal]
 
-## TODO
-- [ ] T1: Research + plan | agent:${AGENT_NAMES.PLANNER} | size:M
-- [ ] T2: Setup project | agent:${AGENT_NAMES.WORKER} | depends:T1 | size:M
-  - [ ] T2.1: Create structure | agent:${AGENT_NAMES.WORKER}
-  - [ ] T2.2: Configure | agent:${AGENT_NAMES.WORKER}
-- [ ] T3: Verify setup | agent:${AGENT_NAMES.REVIEWER} | depends:T2 | size:S
-- [ ] T4: Implement features | agent:${AGENT_NAMES.WORKER} | depends:T3 | size:L
-- [ ] T5: Final verification | agent:${AGENT_NAMES.REVIEWER} | depends:T4 | size:S
+## Parallel Group A (run simultaneously)
+- [ ] T1: Research API | agent:${AGENT_NAMES.PLANNER}
+- [ ] T2: Research DB | agent:${AGENT_NAMES.PLANNER}
+- [ ] T3: Research Auth | agent:${AGENT_NAMES.PLANNER}
 
-## Docs
-.opencode/docs/[topic].md
+## Parallel Group B (after A completes)
+- [ ] T4: Implement API | agent:${AGENT_NAMES.WORKER} | depends:T1
+- [ ] T5: Implement DB | agent:${AGENT_NAMES.WORKER} | depends:T2
+- [ ] T6: Implement Auth | agent:${AGENT_NAMES.WORKER} | depends:T3
 
-## Notes
-[context]
+## Sequential (strict order)
+- [ ] T7: Integration | agent:${AGENT_NAMES.WORKER} | depends:T4,T5,T6
+- [ ] T8: Final verify | agent:${AGENT_NAMES.REVIEWER} | depends:T7
 \`\`\`
 </todo_format>
 
-<anti_hallucination>
-BEFORE CODING:
-1. THINK: Do I know this API/syntax for certain?
-2. CHECK: Look in .opencode/docs/ for cached docs
-3. If uncertain \u2192 ${AGENT_NAMES.PLANNER} or ${AGENT_NAMES.WORKER} search first
-4. NEVER guess - wait for verified documentation
-
-MANDATORY RESEARCH TRIGGERS:
-- Unfamiliar library/framework
-- API syntax you're not 100% sure about
-- Version-specific features
-- Configuration patterns
-</anti_hallucination>
-
 <execution_loop>
 WHILE .opencode/todo.md has unchecked [ ] items:
-1. THINK: What's the next task?
-2. Find task with satisfied dependencies
-3. Delegate to assigned agent
-4. ${AGENT_NAMES.REVIEWER} checks off [x] and updates context
-5. REPEAT
-
-NEVER STOP UNTIL:
-- ALL tasks are [x] checked
-- ${AGENT_NAMES.REVIEWER} passes final verification
-- You output "${MISSION.COMPLETE}"
+  1. IDENTIFY all tasks with satisfied dependencies
+  2. LAUNCH all identified tasks in PARALLEL (background=true)
+  3. START any slow commands via ${TOOL_NAMES.RUN_BACKGROUND}
+  4. MONITOR with ${TOOL_NAMES.LIST_TASKS} / ${TOOL_NAMES.LIST_BACKGROUND}
+  5. COLLECT results as they complete
+  6. UPDATE: ${AGENT_NAMES.REVIEWER} marks [x] and updates context
+  7. REPEAT until all complete
+
+\u26A1 NEVER: Execute one-by-one when parallel is possible
+\u26A1 ALWAYS: Start slow operations in background immediately
 </execution_loop>
 
-<delegation>
-${TOOL_NAMES.DELEGATE_TASK}({
-  agent: "${AGENT_NAMES.WORKER}",
-  description: "Task description",
-  prompt: "Details...",
-  background: true  // parallel
-})
-
-PARALLEL (background=true):
-- Independent tasks (no shared file edits)
-- Research tasks (Planner)
-- Multiple test runs
-- Tasks with no dependencies
-
-SEQUENTIAL (background=false):
-- Tasks with file dependencies
-- Build \u2192 Test sequence
-- When result needed for next decision
-- Critical path tasks
-</delegation>
+<anti_hallucination>
+BEFORE CODING:
+1. Check .opencode/docs/ for cached documentation
+2. If uncertain \u2192 ${AGENT_NAMES.PLANNER} researches first
+3. Never guess API syntax - verify from official sources
+
+TRIGGERS FOR RESEARCH:
+- Unfamiliar framework/library
+- Version-specific syntax
+- Complex configuration
+</anti_hallucination>
 
 <error_handling>
 WHEN TASK FAILS:
-1. ANALYZE: What type of error? (syntax? logic? missing dep? timeout?)
+1. ANALYZE error type (syntax? dependency? timeout?)
 2. DECIDE:
-   - Retryable \u2192 retry with modified approach (max 2 attempts)
-   - Blocker \u2192 mark task blocked, continue independent tasks
-   - Critical \u2192 stop and report to user with context
-
-RECOVERY STRATEGIES:
-| Error Type | Strategy |
-|------------|----------|
-| Tool crash | Retry with alternative tool or approach |
-| Timeout | Break into smaller subtasks |
-| Missing dep | Add dependency task, reorder |
-| Auth/API | Report to user, cannot auto-fix |
-
-NEVER:
-- Ignore failures silently
-- Retry identical approach more than 2 times
-- Skip verification after fix
-- Proceed without addressing blockers
+   - Retryable \u2192 retry with different approach (max 2)
+   - Blocker \u2192 mark blocked, continue parallel tasks
+   - Critical \u2192 report to user
 
 WHEN STUCK:
-1. Check .opencode/todo.md for unblocked tasks
-2. Run independent tasks in parallel
-3. If completely blocked \u2192 report status to user
+1. Find unblocked tasks in TODO
+2. Run them in parallel
+3. If completely blocked \u2192 report status
 </error_handling>
 
 <completion>
-ONLY output this when:
+OUTPUT ONLY WHEN:
 1. ALL items in .opencode/todo.md are [x]
 2. Build/tests pass
 3. ${AGENT_NAMES.REVIEWER} approves
 
-${MISSION.COMPLETE}
-Summary: [what was accomplished]
-Evidence: [build/test results]
+**MISSION SEAL** (Explicit Completion Confirmation):
+When ALL work is truly complete, output the seal tag:
+\`\`\`
+${MISSION_SEAL.PATTERN}
+\`\`\`
+
+Then output:
+${MISSION_SEAL.PATTERN}
+Summary: [accomplishments]
+Evidence: [test/build results]
+
+\u26A0\uFE0F IMPORTANT: Only output ${MISSION_SEAL.PATTERN} when:
+- All todos are marked [x] complete
+- All tests pass
+- All builds succeed
+- You have verified the final result
 </completion>`,
   canWrite: true,
   canBash: true
@@ -393,30 +412,38 @@ CRITICAL RULES:
 <planning_workflow>
 CREATE: .opencode/todo.md
 
-Task Structure:
-- L1: Main objectives (2-5)
-- L2: Sub-tasks (2-3 per L1)
-- L3: Atomic actions (1-3 per L2)
+\u26A1 PARALLELISM IS CRITICAL - Group tasks that can run simultaneously!
 
-PARALLEL GROUPS: A, B, C - run simultaneously
-DEPENDENCIES: "depends:T1,T2" for sequential
+Task Structure:
+- Parallel Groups: Tasks with NO dependencies run together
+- Sequential: Only for tasks with real dependencies
+- Atomic: Each task = one focused action
 
-Format:
+FORMAT:
 \`\`\`markdown
 # Mission: [goal]
 
-## TODO
-- [ ] T1: Research [topic] | agent:${AGENT_NAMES.PLANNER} | size:S
-- [ ] T2: Implement feature | agent:${AGENT_NAMES.WORKER} | depends:T1 | size:M
-- [ ] T3: Verify feature | agent:${AGENT_NAMES.REVIEWER} | depends:T2 | size:S
+## Parallel Group A (spawn all simultaneously)
+- [ ] T1: Research API | agent:${AGENT_NAMES.PLANNER} | size:S
+- [ ] T2: Research DB | agent:${AGENT_NAMES.PLANNER} | size:S
+- [ ] T3: Research Auth | agent:${AGENT_NAMES.PLANNER} | size:S
 
-## Parallel Groups
-- Group A: T1, T4 (independent)
-- Group B: T2, T5 (after A)
+## Parallel Group B (after Group A)
+- [ ] T4: Implement API | agent:${AGENT_NAMES.WORKER} | depends:T1 | size:M
+- [ ] T5: Implement DB | agent:${AGENT_NAMES.WORKER} | depends:T2 | size:M
+
+## Sequential (strict order required)
+- [ ] T6: Integration | agent:${AGENT_NAMES.WORKER} | depends:T4,T5 | size:L
+- [ ] T7: Verify all | agent:${AGENT_NAMES.REVIEWER} | depends:T6 | size:S
 
 ## Notes
 [context for team]
 \`\`\`
+
+MAXIMIZE PARALLELISM:
+- Research tasks \u2192 ALL parallel (different topics)
+- Implementation \u2192 Parallel if different files
+- Sequential ONLY when: same file edit, strict A\u2192B dependency
 </planning_workflow>
 
 <research_workflow>
@@ -699,7 +726,7 @@ Next: [task for team]
 
 // src/agents/definitions.ts
 var AGENTS = {
-  [AGENT_NAMES.COMMANDER]: orchestrator,
+  [AGENT_NAMES.COMMANDER]: commander,
   [AGENT_NAMES.PLANNER]: planner,
   [AGENT_NAMES.WORKER]: worker,
   [AGENT_NAMES.REVIEWER]: reviewer
@@ -13200,7 +13227,7 @@ Never claim completion without proof.
 });
 
 // src/tools/slashCommand.ts
-var COMMANDER_SYSTEM_PROMPT = orchestrator.systemPrompt;
+var COMMANDER_SYSTEM_PROMPT = commander.systemPrompt;
 var MISSION_MODE_TEMPLATE = `${COMMANDER_SYSTEM_PROMPT}
 
 <mission>
@@ -13211,7 +13238,7 @@ $ARGUMENTS
 <execution_rules>
 1. Complete this mission without user intervention
 2. Use your full capabilities: research, implement, verify
-3. Output "${MISSION.COMPLETE}" when done
+3. Output "${MISSION_SEAL.PATTERN}" when done
 </execution_rules>
 </mission>`;
 var COMMANDS = {
@@ -13249,7 +13276,7 @@ var COMMANDS = {
 
 | Agent | Role | Capabilities |
 |-------|------|--------------|
-| **${AGENT_NAMES.COMMANDER}** \u{1F3AF} | Master Orchestrator | Autonomous mission control, parallel task coordination, never stops until \u2705 MISSION COMPLETE |
+| **${AGENT_NAMES.COMMANDER}** \u{1F3AF} | Master Orchestrator | Autonomous mission control, parallel task coordination, never stops until ${MISSION_SEAL.PATTERN} |
 | **${AGENT_NAMES.PLANNER}** \u{1F4CB} | Strategic Planner | Task decomposition, research, caching docs, dependency analysis |
 | **${AGENT_NAMES.WORKER}** \u{1F528} | Implementation | Code, files, terminal, documentation lookup when needed |
 | **${AGENT_NAMES.REVIEWER}** \u2705 | Quality & Context | Verification, TODO updates, context management, auto-fix |
@@ -16751,6 +16778,310 @@ function cleanupSession(sessionID) {
   sessionStates.delete(sessionID);
 }
 
+// src/core/loop/mission-seal.ts
+import { existsSync as existsSync4, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { join as join5 } from "node:path";
+var MISSION_SEAL_TAG = MISSION_SEAL.TAG;
+var SEAL_CONFIRMATION = MISSION_SEAL.CONFIRMATION;
+var SEAL_PATTERN = MISSION_SEAL.PATTERN;
+var SEAL_REGEX = new RegExp(
+  `<${MISSION_SEAL.TAG}>\\s*${MISSION_SEAL.CONFIRMATION}\\s*</${MISSION_SEAL.TAG}>`,
+  "i"
+);
+var STATE_FILE = MISSION_SEAL.STATE_FILE;
+var DEFAULT_MAX_ITERATIONS = MISSION_SEAL.DEFAULT_MAX_ITERATIONS;
+var DEFAULT_COUNTDOWN_SECONDS = MISSION_SEAL.DEFAULT_COUNTDOWN_SECONDS;
+function getStateFilePath(directory) {
+  return join5(directory, PATHS.OPENCODE, STATE_FILE);
+}
+function readLoopState(directory) {
+  const filePath = getStateFilePath(directory);
+  if (!existsSync4(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error45) {
+    log2(`[mission-seal] Failed to read state: ${error45}`);
+    return null;
+  }
+}
+function writeLoopState(directory, state2) {
+  const filePath = getStateFilePath(directory);
+  try {
+    writeFileSync(filePath, JSON.stringify(state2, null, 2), "utf-8");
+    return true;
+  } catch (error45) {
+    log2(`[mission-seal] Failed to write state: ${error45}`);
+    return false;
+  }
+}
+function clearLoopState(directory) {
+  const filePath = getStateFilePath(directory);
+  if (!existsSync4(filePath)) {
+    return true;
+  }
+  try {
+    unlinkSync(filePath);
+    return true;
+  } catch (error45) {
+    log2(`[mission-seal] Failed to clear state: ${error45}`);
+    return false;
+  }
+}
+function incrementIteration(directory) {
+  const state2 = readLoopState(directory);
+  if (!state2) return null;
+  state2.iteration += 1;
+  state2.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  if (writeLoopState(directory, state2)) {
+    return state2;
+  }
+  return null;
+}
+function detectSealInText(text) {
+  return SEAL_REGEX.test(text);
+}
+async function detectSealInSession(client, sessionID) {
+  try {
+    const response = await client.session.messages({ path: { id: sessionID } });
+    const messages = response.data ?? [];
+    const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
+    const recentMessages = assistantMessages.slice(-3);
+    for (const msg of recentMessages) {
+      if (!msg.parts) continue;
+      const textParts = msg.parts.filter(
+        (p) => p.type === PART_TYPES.TEXT || p.type === PART_TYPES.REASONING
+      );
+      for (const part of textParts) {
+        if (part.text && detectSealInText(part.text)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch (error45) {
+    log2(`[mission-seal] Failed to check session messages: ${error45}`);
+    return false;
+  }
+}
+function isLoopActive(directory, sessionID) {
+  const state2 = readLoopState(directory);
+  return state2?.active === true && state2?.sessionID === sessionID;
+}
+function generateMissionContinuationPrompt(state2) {
+  return `<mission_loop iteration="${state2.iteration}" max="${state2.maxIterations}">
+\u{1F4CB} **Mission Loop Active** - Iteration ${state2.iteration}/${state2.maxIterations}
+
+Your previous iteration did not seal the mission. Continue working.
+
+**RULES**:
+1. Review your progress from the previous iteration
+2. Continue from where you left off
+3. Check TODO list for incomplete items
+4. When ALL work is TRULY complete, output:
+
+\`\`\`
+${SEAL_PATTERN}
+\`\`\`
+
+**IMPORTANT**: 
+- Do NOT seal until the mission is genuinely complete
+- Verify all todos are marked [x] before sealing
+- Run tests/builds if applicable before sealing
+
+**Original Task**:
+${state2.prompt}
+</mission_loop>`;
+}
+
+// src/core/loop/mission-seal-handler.ts
+var COUNTDOWN_SECONDS2 = 3;
+var TOAST_DURATION_MS2 = 1500;
+var MIN_TIME_BETWEEN_CHECKS_MS = 3e3;
+var sessionStates2 = /* @__PURE__ */ new Map();
+function getState3(sessionID) {
+  let state2 = sessionStates2.get(sessionID);
+  if (!state2) {
+    state2 = {};
+    sessionStates2.set(sessionID, state2);
+  }
+  return state2;
+}
+function cancelCountdown2(sessionID) {
+  const state2 = sessionStates2.get(sessionID);
+  if (state2?.countdownTimer) {
+    clearTimeout(state2.countdownTimer);
+    state2.countdownTimer = void 0;
+  }
+}
+function hasRunningBackgroundTasks2(parentSessionID) {
+  try {
+    const manager = ParallelAgentManager.getInstance();
+    const tasks = manager.getTasksByParent(parentSessionID);
+    return tasks.some((t) => t.status === "running");
+  } catch {
+    return false;
+  }
+}
+async function showCountdownToast2(client, seconds, iteration, maxIterations) {
+  try {
+    const tuiClient2 = client;
+    if (tuiClient2.tui?.showToast) {
+      await tuiClient2.tui.showToast({
+        body: {
+          title: "\u{1F504} Mission Loop",
+          message: `Continuing in ${seconds}s... (iteration ${iteration}/${maxIterations})`,
+          variant: "warning",
+          duration: TOAST_DURATION_MS2
+        }
+      });
+    }
+  } catch {
+  }
+}
+async function showSealedToast(client, state2) {
+  try {
+    const tuiClient2 = client;
+    if (tuiClient2.tui?.showToast) {
+      await tuiClient2.tui.showToast({
+        body: {
+          title: "\u{1F396}\uFE0F Mission Sealed!",
+          message: `Completed after ${state2.iteration} iteration(s)`,
+          variant: "success",
+          duration: 5e3
+        }
+      });
+    }
+  } catch {
+  }
+}
+async function showMaxIterationsToast(client, state2) {
+  try {
+    const tuiClient2 = client;
+    if (tuiClient2.tui?.showToast) {
+      await tuiClient2.tui.showToast({
+        body: {
+          title: "\u26A0\uFE0F Mission Loop Stopped",
+          message: `Max iterations (${state2.maxIterations}) reached`,
+          variant: "warning",
+          duration: 5e3
+        }
+      });
+    }
+  } catch {
+  }
+}
+async function injectContinuation2(client, directory, sessionID, loopState) {
+  const handlerState = getState3(sessionID);
+  if (handlerState.isAborting) {
+    log2("[mission-seal-handler] Skipped: user is aborting");
+    return;
+  }
+  if (hasRunningBackgroundTasks2(sessionID)) {
+    log2("[mission-seal-handler] Skipped: background tasks running");
+    return;
+  }
+  if (isSessionRecovering(sessionID)) {
+    log2("[mission-seal-handler] Skipped: session recovering");
+    return;
+  }
+  const sealDetected = await detectSealInSession(client, sessionID);
+  if (sealDetected) {
+    log2("[mission-seal-handler] Seal detected before injection, completing");
+    await handleSealDetected(client, directory, loopState);
+    return;
+  }
+  const prompt = generateMissionContinuationPrompt(loopState);
+  try {
+    await client.session.prompt({
+      path: { id: sessionID },
+      body: {
+        parts: [{ type: PART_TYPES.TEXT, text: prompt }]
+      }
+    });
+    log2("[mission-seal-handler] Continuation injected", {
+      sessionID,
+      iteration: loopState.iteration
+    });
+  } catch (error45) {
+    log2(`[mission-seal-handler] Failed to inject: ${error45}`);
+  }
+}
+async function handleSealDetected(client, directory, loopState) {
+  clearLoopState(directory);
+  await showSealedToast(client, loopState);
+  log2("[mission-seal-handler] Mission sealed!", {
+    sessionID: loopState.sessionID,
+    iterations: loopState.iteration
+  });
+}
+async function handleMaxIterations(client, directory, loopState) {
+  clearLoopState(directory);
+  await showMaxIterationsToast(client, loopState);
+  log2("[mission-seal-handler] Max iterations reached", {
+    sessionID: loopState.sessionID,
+    iterations: loopState.iteration,
+    max: loopState.maxIterations
+  });
+}
+async function handleMissionSealIdle(client, directory, sessionID, mainSessionID) {
+  const handlerState = getState3(sessionID);
+  const now = Date.now();
+  if (handlerState.lastCheckTime && now - handlerState.lastCheckTime < MIN_TIME_BETWEEN_CHECKS_MS) {
+    return;
+  }
+  handlerState.lastCheckTime = now;
+  cancelCountdown2(sessionID);
+  if (mainSessionID && sessionID !== mainSessionID) {
+    return;
+  }
+  if (isSessionRecovering(sessionID)) {
+    log2("[mission-seal-handler] Skipped: recovering");
+    return;
+  }
+  if (hasRunningBackgroundTasks2(sessionID)) {
+    log2("[mission-seal-handler] Skipped: background tasks");
+    return;
+  }
+  const loopState = readLoopState(directory);
+  if (!loopState || !loopState.active) {
+    return;
+  }
+  if (loopState.sessionID !== sessionID) {
+    return;
+  }
+  log2("[mission-seal-handler] Checking for seal", {
+    sessionID,
+    iteration: loopState.iteration
+  });
+  const sealDetected = await detectSealInSession(client, sessionID);
+  if (sealDetected) {
+    await handleSealDetected(client, directory, loopState);
+    return;
+  }
+  if (loopState.iteration >= loopState.maxIterations) {
+    await handleMaxIterations(client, directory, loopState);
+    return;
+  }
+  const newState = incrementIteration(directory);
+  if (!newState) {
+    log2("[mission-seal-handler] Failed to increment iteration");
+    return;
+  }
+  await showCountdownToast2(client, COUNTDOWN_SECONDS2, newState.iteration, newState.maxIterations);
+  handlerState.countdownTimer = setTimeout(async () => {
+    cancelCountdown2(sessionID);
+    await injectContinuation2(client, directory, sessionID, newState);
+  }, COUNTDOWN_SECONDS2 * 1e3);
+  log2("[mission-seal-handler] Countdown started", {
+    sessionID,
+    iteration: newState.iteration,
+    seconds: COUNTDOWN_SECONDS2
+  });
+}
+
 // src/core/progress/store.ts
 var progressHistory = /* @__PURE__ */ new Map();
 var sessionStartTimes = /* @__PURE__ */ new Map();
@@ -16863,7 +17194,7 @@ You are ONLY done when:
 - All todos are marked complete or cancelled
 - All features are implemented and tested
 - Final verification passes
-Then output: \u2705 MISSION COMPLETE
+Then output: ${MISSION_SEAL.PATTERN}
 </completion_criteria>
 </auto_continue>`;
 var OrchestratorPlugin = async (input) => {
@@ -17041,12 +17372,27 @@ var OrchestratorPlugin = async (input) => {
         if (sessionID) {
           const isMainSession = sessions.has(sessionID);
           if (isMainSession) {
-            setTimeout(() => {
+            setTimeout(async () => {
               const session = sessions.get(sessionID);
               if (session?.active) {
-                handleSessionIdle(client, sessionID, sessionID).catch((err) => {
-                  log2("[index.ts] todo-continuation error", err);
-                });
+                if (isLoopActive(directory, sessionID)) {
+                  await handleMissionSealIdle(
+                    client,
+                    directory,
+                    sessionID,
+                    sessionID
+                  ).catch((err) => {
+                    log2("[index.ts] mission-seal-handler error", err);
+                  });
+                } else {
+                  await handleSessionIdle(
+                    client,
+                    sessionID,
+                    sessionID
+                  ).catch((err) => {
+                    log2("[index.ts] todo-continuation error", err);
+                  });
+                }
               }
             }, 500);
           }
@@ -17205,7 +17551,7 @@ Anomaly count: ${stateSession.anomalyCount}
     // -----------------------------------------------------------------
     // assistant.done hook - runs when the LLM finishes responding
     // This is the heart of the "relentless loop" - we keep pushing it
-    // to continue until we see MISSION COMPLETE or hit the limit
+    // to continue until we see <mission_seal>SEALED</mission_seal> or hit the limit
     // -----------------------------------------------------------------
     "assistant.done": async (assistantInput, assistantOutput) => {
       const sessionID = assistantInput.sessionID;
@@ -17245,10 +17591,12 @@ Anomaly count: ${stateSession.anomalyCount}
       if (stateSession && stateSession.anomalyCount > 0) {
         stateSession.anomalyCount = 0;
       }
-      if (textContent.includes(MISSION.COMPLETE) || textContent.includes(MISSION.COMPLETE_TEXT)) {
+      if (detectSealInText(textContent)) {
         session.active = false;
         state.missionActive = false;
-        presets.missionComplete("Mission completed successfully");
+        clearLoopState(directory);
+        presets.missionComplete("\u{1F396}\uFE0F Mission Sealed - Explicit completion confirmed");
+        log2("[index.ts] Mission sealed detected", { sessionID });
         clearSession(sessionID);
         sessions.delete(sessionID);
         state.sessions.delete(sessionID);

package/dist/shared/constants.d.ts

@@ -69,11 +69,38 @@ export declare const TOOL_NAMES: {
     readonly CALL_AGENT: "call_agent";
     readonly SLASHCOMMAND: "slashcommand";
 };
+export declare const MISSION_SEAL: {
+    /** XML tag name for mission seal */
+    readonly TAG: "mission_seal";
+    /** Confirmation value inside tag */
+    readonly CONFIRMATION: "SEALED";
+    /** Full seal pattern: <mission_seal>SEALED</mission_seal> */
+    readonly PATTERN: "<mission_seal>SEALED</mission_seal>";
+    /** Default max loop iterations */
+    readonly DEFAULT_MAX_ITERATIONS: 20;
+    /** Default countdown seconds before continue */
+    readonly DEFAULT_COUNTDOWN_SECONDS: 3;
+    /** Loop state file name */
+    readonly STATE_FILE: "loop-state.json";
+    /** Stop command */
+    readonly STOP_COMMAND: "/stop";
+    /** Cancel command */
+    readonly CANCEL_COMMAND: "/cancel";
+};
+/** @deprecated Use MISSION_SEAL instead */
 export declare const MISSION: {
-    /** Mission completion marker (with emoji) */
-    readonly COMPLETE: "✅ MISSION COMPLETE";
-    /** Mission completion marker (text only) */
-    readonly COMPLETE_TEXT: "MISSION COMPLETE";
+    /** XML tag name for mission seal */
+    readonly TAG: "mission_seal";
+    /** Confirmation value inside tag */
+    readonly CONFIRMATION: "SEALED";
+    /** Full seal pattern: <mission_seal>SEALED</mission_seal> */
+    readonly PATTERN: "<mission_seal>SEALED</mission_seal>";
+    /** Default max loop iterations */
+    readonly DEFAULT_MAX_ITERATIONS: 20;
+    /** Default countdown seconds before continue */
+    readonly DEFAULT_COUNTDOWN_SECONDS: 3;
+    /** Loop state file name */
+    readonly STATE_FILE: "loop-state.json";
     /** Stop command */
     readonly STOP_COMMAND: "/stop";
     /** Cancel command */

package/package.json

@@ -2,7 +2,7 @@
   "name": "opencode-orchestrator",
   "displayName": "OpenCode Orchestrator",
   "description": "Distributed Cognitive Architecture for OpenCode. Turns simple prompts into specialized multi-agent workflows (Planner, Coder, Reviewer).",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {