opencode-orchestrator 1.3.4 → 1.3.5

package/README.md

@@ -1,59 +1,44 @@
-
----
-
 <div align="center">
-  <img src="assets/logo.png" alt="logo" width="200" />
+  <img src="assets/logo.png" alt="OpenCode Orchestrator logo" width="160" />
   <h1>OpenCode Orchestrator</h1>
-  <p>Production-Grade Multi-Agent Orchestration Engine for High-Integrity Software Engineering</p>
+  <p>Multi-agent mission control for OpenCode.</p>
 
   [![MIT License](https://img.shields.io/badge/license-MIT-red.svg)](LICENSE)
   [![npm](https://img.shields.io/npm/v/opencode-orchestrator.svg)](https://www.npmjs.com/package/opencode-orchestrator)
   <!-- VERSION:START -->
-  **Version:** `1.3.4`
+  **Version:** `1.3.5`
   <!-- VERSION:END -->
 </div>
 
-
 ---
 
-## ⚡ Quick Start
+## 1. Install
 
 ```bash
 npm install -g opencode-orchestrator
 ```
 
-Install hooks are source-checkout safe, prefer `opencode.jsonc` when present, preserve sibling plugin entries, and skip automatic config mutation in CI environments.
+The install hook merges OpenCode config instead of replacing it, prefers `opencode.jsonc` when present, preserves existing plugin tuple options, and skips automatic config mutation in CI.
 
-To remove the plugin safely later, run:
+To remove the plugin from OpenCode config:
 
 ```bash
 npm explore -g opencode-orchestrator -- npm run cleanup:plugin
 npm uninstall -g opencode-orchestrator
 ```
 
-`npm uninstall -g` does not run dependency uninstall hooks in the npm 11 flow verified for this repo, so config cleanup is explicit.
-
-### Model, Permissions, and Concurrency
+Manual fallback: remove `"opencode-orchestrator"` or `["opencode-orchestrator", {...}]` from the `plugin` array in `opencode.json` or `opencode.jsonc`.
 
-The plugin does not force a model by default. OpenCode's model rules apply: primary agents use the global `model` unless the agent has its own `model`, and subagents use the invoking primary agent's model unless the subagent has its own `model`.
+## 2. Configure
 
-Recommended `opencode.jsonc` configuration:
+OpenCode supports plugin options as `["plugin-name", {...}]` tuples. Use that form for orchestrator-specific settings:
 
 ```jsonc
 {
   "$schema": "https://opencode.ai/config.json",
-  "model": "opencode/gpt-5.1-codex",
   "permission": {
     "question": "allow"
   },
-  "agent": {
-    "commander": {
-      "model": "opencode/gpt-5.1-codex"
-    },
-    "worker": {
-      "model": "anthropic/claude-opus-4-5-20251101"
-    }
-  },
   "plugin": [
     [
       "opencode-orchestrator",
@@ -75,371 +60,92 @@ Recommended `opencode.jsonc` configuration:
 }
 ```
 
-Global permissions are copied into the generated Commander, Planner, Worker, and Reviewer agents. Same-name agent config keeps user model/options and can override permission keys per agent. When `permission.question` is `allow`, orchestrator agents can still ask concise clarification questions if they are truly blocked.
-
-Inside an OpenCode environment:
-```bash
-/task "Implement a new authentication module with JWT and audit logs"
-```
-
-
----
-
-## 🚀 Engine Workflow
-
-**Hub-and-Spoke Architecture** with Work-Stealing Queues for parallel, context-isolated task execution.
-```
-╔══════════════════════════════════════════════════════════════════════════════╗
-║                           USER INPUT /task "..."                              ║
-╚══════════════════════════════════════════════════════════════════════════════╝
-                                         │
-                                         ▼
-╔══════════════════════════════════════════════════════════════════════════════╗
-║  ┌─────────────────────────────────────────────────────────────────────────┐ ║
-║  │                            C O M M A N D E R                           │ ║
-║  │                    [ Mission Analysis & Delegation ]                    │ ║
-║  │                                                                          │ ║
-║  │    • Interprets user intent    • Coordinates multi-agent workflow      │ ║
-║  │    • Monitors progress          • Manages work-stealing queues         │ ║
-║  └─────────────────────────────────────────────────────────────────────────┘ ║
-╚══════════════════════════════════════════════════════════════════════════════╝
-                                         │
-                         ┌───────────────┼───────────────┐
-                         ▼               ▼               ▼
-╔═════════════════╗  ╔═════════════════╗  ╔═════════════════╗
-║   P L A N N E R ║  ║     W O R K E R ║  ║    W O R K E R   ║
-║  [Architect]    ║  ║  [Implementer]  ║  ║  [Implementer]   ║
-║                 ║  ║                 ║  ║                 ║
-║  • Dependency   ║  ║  • File coding ║  ║  • File coding  ║
-║    analysis     ║  ║  • TDD workflow ║  ║  • TDD workflow ║
-║  • Roadmap gen ║  ║  • Documentation║  ║  • Documentation║
-║  • TODO.md      ║  ║                 ║  ║                 ║
-╚═════════════════╝  ╚═════════════════╝  ╚═════════════════╝
-         │                   │                     │
-         │    ┌──────────────┼─────────────────────┘
-         │    │              │
-         ▼    ▼              ▼
-╔══════════════════════════════════════╗
-║         SESSION POOL (MVCC Sync)   ║
-║   ┌─────────────────────────────────┐ ║
-║   │  Object Pool │ Buffer Pool      │ ║
-║   │  String Pool │ Connection Pool  │ ║
-║   └─────────────────────────────────┘ ║
-╚══════════════════════════════════════╝
-         │
-         ▼
-╔══════════════════════════════════════╗
-║       MSVP MONITOR / REVIEWER       ║
-║  ┌─────────────────────────────────┐ ║
-║  │  • Adaptive polling (500ms-5s) │ ║
-║  │  • Stability detection         │ ║
-║  │  • Unit test verification      │ ║
-║  └─────────────────────────────────┘ ║
-╚══════════════════════════════════════╝
-                 │
-                 ▼
-        ┌────────────────┐
-        │  ✨ COMPLETED  │
-        └────────────────┘
-```
-
----
-
-## 🏗️ Architecture Layers
+Optional model routing stays in normal OpenCode config. The plugin does not force a model:
 
-```
-┌─────────────────────────────────────────────────────────────────────────────┐
-│                           PRESENTATION LAYER                                │
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐  ┌─────────────────┐  │
-│  │ Task Toast  │  │ Progress    │  │ Notification│  │ Mission Summary │  │
-│  │ Manager     │  │ Notifier    │  │ Manager     │  │ Display         │  │
-│  └─────────────┘  └─────────────┘  └─────────────┘  └─────────────────┘  │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                           BUSINESS LOGIC LAYER                              │
-│  ┌───────────────────────────────────────────────────────────────────────┐  │
-│  │                    Parallel Agent Orchestration                        │  │
-│  │  ┌────────────┐  ┌────────────┐  ┌────────────┐  ┌────────────────┐  │  │
-│  │  │ Commander  │  │  Planner   │  │  Worker    │  │   Reviewer     │  │  │
-│  │  │   Agent    │  │   Agent    │  │   Agent    │  │     Agent      │  │  │
-│  │  └────────────┘  └────────────┘  └────────────┘  └────────────────┘  │  │
-│  └───────────────────────────────────────────────────────────────────────┘  │
-│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────────────────┐│
-│  │ Concurrency     │  │   Task Store   │  │    Hook System              ││
-│  │ Controller      │  │   (In-Memory)  │  │  [Early/Normal/Late Phases] ││
-│  └─────────────────┘  └─────────────────┘  └─────────────────────────────┘│
-├─────────────────────────────────────────────────────────────────────────────┤
-│                           INFRASTRUCTURE LAYER                              │
-│  ┌────────────────┐  ┌────────────────┐  ┌────────────────────────────┐  │
-│  │ Session Pool   │  │ Work-Stealing  │  │    Memory Pools           │  │
-│  │ [5 per agent]  │  │ [Chase-Lev]    │  │  ┌──────┐ ┌──────┐ ┌─────┐│  │
-│  │ [10 reuse max] │  │ [LIFO/FIFO]    │  │  │Object│ │String│ │Buffer││  │
-│  └────────────────┘  └────────────────┘  │  │ 200  │ │ intern│ │ 4KB ││  │
-│                                          │  └──────┘ └──────┘ └─────┘│  │
-│  ┌────────────────┐  ┌────────────────┐  └────────────────────────────┘  │
-│  │ MVCC State     │  │ Circuit Breaker │  ┌────────────────────────────┐  │
-│  │ [Atomic Sync]  │  │ [5 failures→open│  │ Rust Connection Pool     │  │
-│  │                │  │  [2 success→close│ │ [4 processes, 30s idle]   │  │
-│  └────────────────┘  └────────────────┘  └────────────────────────────┘  │
-├─────────────────────────────────────────────────────────────────────────────┤
-│                           SAFETY LAYER                                      │
-│  ┌────────────────┐  ┌────────────────┐  ┌─────────────────────────────┐ │
-│  │ RAII Pattern   │  │ Shutdown       │  │ Auto-Recovery               │ │
-│  │ [Zero Leaks]   │  │ Manager        │  │ [Exponential Backoff]       │ │
-│  │                │  │ [5s timeout]   │  │ [Rate limit handling]       │ │
-│  └────────────────┘  └────────────────┘  └─────────────────────────────┘ │
-└─────────────────────────────────────────────────────────────────────────────┘
+```jsonc
+{
+  "model": "provider/model-id",
+  "agent": {
+    "commander": {
+      "model": "provider/model-id"
+    },
+    "worker": {
+      "model": "provider/stronger-model-id"
+    }
+  }
+}
 ```
 
----
+Generated Commander, Planner, Worker, and Reviewer agents inherit global permissions. Same-name user agent config can still override specific model or permission keys.
 
-## 🧪 Test Utilities
+## 3. Run
 
-Reusable test helpers keep filesystem, task, and process-heavy flows deterministic:
+Inside OpenCode:
 
-```
-tests/harness/
-├── fixture.ts          Disposable tmpdir utilities
-│   ├── tmpdir()        async disposable with cleanup
-│   ├── tmpdirSync()    sync disposable with cleanup  
-│   ├── createMockFs()  In-memory fs mock
-│   └── waitFor()       Async condition waiter
-│
-├── builders.ts         Factory functions for test objects
-│   ├── createParallelTask()    Build ParallelTask instances
-│   ├── createBackgroundTask()  Build BackgroundTask instances
-│   └── createTodo()            Build Todo instances
-│
-├── mocks.ts           Mock utilities
-│   ├── mockConsole()         Spy on console.log/error
-│   ├── mockProcessExit()     Mock process.exit
-│   ├── useFakeTimers()       Time manipulation
-│   └── createMockEmitter()   EventEmitter spy
-│
-└── index.ts           Unified exports
+```bash
+/task "Implement the requested change and verify it"
 ```
 
-### Usage Example
-
-```typescript
-import { tmpdir, createParallelTask, mockConsole } from "@/tests/harness";
-
-describe("My test", () => {
-  let consoleMock;
-
-  beforeEach(() => {
-    consoleMock = mockConsole();
-    consoleMock.setup();
-  });
-
-  afterEach(() => {
-    consoleMock.restore();
-  });
-
-  it("should work", async () => {
-    await using tmp = await tmpdir({ git: true });
-    const task = createParallelTask({ description: "Test" });
-    expect(task.status).toBe("pending");
-  });
-});
+Mission controls:
+
+1. `/task ...` starts a persisted mission loop under `.opencode/`.
+2. `Esc`/OpenCode interrupt is respected by idle guards so the plugin does not immediately re-continue an interrupted turn.
+3. `/cancel` and `/stop` deactivate the current mission loop.
+4. The default mission iteration ceiling is `1,000,000,000`.
+
+## 4. How It Works
+
+```mermaid
+flowchart LR
+  U["/task input"] --> C["Commander"]
+  C --> P["Planner"]
+  C --> W["Worker pool"]
+  W --> R["Reviewer"]
+  P --> S["Mission state"]
+  W --> S
+  R --> V{"Verified?"}
+  V -- "no" --> C
+  V -- "yes" --> D["Done"]
 ```
 
----
-
-## ⚡ Elite Multi-Agent Swarm
-
-| Agent | Role | Core Responsibilities |
-|:------|:-----|:------------------------|
-| **Commander** | Mission Hub | Task decomposition, agent coordination, work-stealing orchestration, final mission seal |
-| **Planner** | Architect | Dependency analysis, roadmap generation, TODO.md creation via MVCC, file-level planning |
-| **Worker** | Implementer | High-throughput coding, TDD workflow, documentation, isolated file execution |
-| **Reviewer** | Auditor | Unit test verification, LSP/Lint validation, integration testing, quality gate |
----
-
-## 🛠️ Core Capabilities
-
-### 🔒 Atomic MVCC State Synchronization
-Solves the "Concurrent TODO Update" problem using **MVCC + Mutex**. Agents safely mark tasks complete in parallel without data loss or race conditions. Every state change is cryptographically hashed and logged.
+| Agent | Purpose |
+| --- | --- |
+| Commander | Interprets the mission, coordinates agents, and keeps the loop aligned. |
+| Planner | Breaks work into ordered steps and tracks dependencies. |
+| Worker | Implements scoped file changes with isolated context. |
+| Reviewer | Checks completion evidence, tests, and integration risk. |
 
-### 🧩 Advanced Hook Orchestration
-Execution flows governed by a **Priority-Phase Hook Registry**. Hooks are grouped into phases (`early`, `normal`, `late`) and executed via **Topological Sort** for predictable, dependency-aware ordering.
+Runtime evidence is written only when enabled:
 
-### 🎛️ Mission Loop Control
-`/task` starts a persisted mission loop under `.opencode/`. The loop watches TODO/checklist verification, background task state, compaction safety, recovery state, and stagnation signals before injecting compact continuation prompts that keep Commander aligned with the active objective.
+| Artifact | Purpose |
+| --- | --- |
+| `.opencode/mission-ledger.jsonl` | Bounded event trail for mission decisions. |
+| `.opencode/docs/brain/scratchpad.md` | Generated Markdown memory surface for active missions. |
+| `.opencode/docs/brain/knowledge-map.canvas` | Obsidian-compatible visual map of objective, evidence, and verification nodes. |
 
-The mission loop also writes a bounded runtime evidence trail to `.opencode/mission-ledger.jsonl` and a generated Markdown memory surface under `.opencode/docs/brain/`. Disable those artifacts with the `missionLoop.ledger` and `missionLoop.markdownMemory` plugin options when a project needs a quieter workspace.
-
-### 🛡️ Autonomous Recovery
-- **Self-healing loops** with adaptive stagnation detection
-- **Proactive Agency**: Smart monitoring that audits logs and plans ahead during background tasks
-- **Auto-retry with backoff**: Exponential backoff for transient failures
-
-### 🎯 State-Level Session Isolation
-Reused sessions in the **SessionPool** are explicitly reset via server-side compaction, ensuring previous task context never leaks into new tasks.
-
-### 🚀 Zero-Payload Turbo Mode
-Leverages `system.transform` to unshift agent instruction sets server-side, reducing initial message payloads by **90%+** and preventing context fragmentation.
-
-### 🧠 Hierarchical Memory System
-Maintains focus across thousands of conversation turns using a 4-tier memory structure with **EMA-based Context Gating** to preserve architectural truth while pruning noise.
-
-### 🔄 Adaptive Intelligence Loop
-- **Stagnation Detection**: Senses when no progress is made across iterations
-- **Diagnostic Intervention**: Forces "Diagnostic Mode" mandating log audits and strategy pivots
-- **Proactive Agency**: Mandates Speculative Planning during background task execution
-
-### 🧬 Knowledge Graph RAG (Second Brain)
-An autonomous **Obsidian-style evolutionary memory system** that gives agents persistent, searchable knowledge across sessions.
-
-Runtime context injection is active for orchestrated sessions through `experimental.chat.system.transform`, indexing `docs/**/*.md` and `.opencode/docs/**/*.md` with BM25/tag/graph fusion before prompt injection.
-
-During active missions, generated runtime memory is available at `.opencode/docs/brain/scratchpad.md`; `.opencode/docs/brain/knowledge-map.canvas` provides an Obsidian-compatible visual map of objective, runtime, verification, and recent evidence nodes.
-
-```
-  ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
-  │  📝 Ingest   │────▶│  🔍 Search   │────▶│  🧠 Recall   │
-  │  ──────────  │     │  ──────────  │     │  ──────────  │
-  │  YAML Parser │     │  BM25 Lexical│     │  RRF-Ranked  │
-  │  Tag HashMap │     │  Tag Index   │     │  Top-K Notes │
-  │  Wiki-Links  │     │  2-Hop Graph │     │  → Context   │
-  └──────┬───────┘     └──────────────┘     └──────────────┘
-         │
-         ▼
-  ┌──────────────┐     ┌──────────────┐     ┌──────────────┐
-  │  🔄 Evolve   │────▶│  🛡️ Guard    │────▶│  📦 Archive  │
-  │  ──────────  │     │  ──────────  │     │  ──────────  │
-  │  Fission     │     │  Cycle DFS   │     │  Orphan GC   │
-  │  Fusion      │     │  Write FIFO  │     │  MOC Hubs    │
-  │  (Auto-Split │     │  Keep-Pin    │     │  MD Export   │
-  │   & Merge)   │     │  Shield      │     │              │
-  └──────────────┘     └──────────────┘     └──────────────┘
-```
-
-**Six integrated modules** power the knowledge pipeline:
-
-| Module | Purpose |
-|:-------|:--------|
-| **TagIndexer** | O(1) YAML frontmatter parsing → tag-to-file HashMap |
-| **GraphParser** | `[[wiki-link]]` extraction, bi-directional adjacency graph |
-| **HybridSearch** | BM25 + Tag + 2-Hop Graph → **Reciprocal Rank Fusion** (k=60) |
-| **Scratchpad** | LRU register cache (64 slots, 4KB max) with markdown persistence |
-| **SafetyGuards** | Circular link DFS, async FIFO write queue, keep-pin shield |
-| **MemoryConsolidation** | Fission/Fusion/GC/MOC — pure functional analysis |
-
----
-
-## ⚙️ Performance Benchmarks
-
-| Metric | Improvement |
-|:-------|:------------|
-| CPU Utilization | 90%+ (up from 50-70%) |
-| Tool Call Speed | 10x faster (5-10ms vs 50-100ms) via Rust pool |
-| Session Creation | 90% faster (50ms vs 500ms) via session pooling |
-| Memory Usage | 60% reduction via object/string/buffer pooling |
-| GC Pressure | 80% reduction |
-| Token Efficiency | 40% reduction via Incremental State & System Transform |
-| Sync Accuracy | 99.95% via MVCC+Mutex |
-| Parallel Efficiency | 80% improvement (50% → 90%+) |
-
----
-
-## 🏗️ Infrastructure & Reliability
-
-### Resource Safety
-- **RAII Pattern**: Guaranteed resource cleanup with zero leaks
-- **ShutdownManager**: Priority-based graceful shutdown (5s timeout per handler)
-- **Atomic File Operations**: Temp file + rename for corruption-proof writes
-- **Automatic Backups**: Timestamped config backups with rollback support
-
-### Safety Features
-- **Circuit Breaker**: Auto-recovery from API failures (5 failures → open)
-- **Resource Pressure Detection**: Rejects low-priority tasks when memory > 80%
-- **Terminal Node Guard**: Prevents infinite recursion via depth limit
-- **Auto-Scaling**: Concurrency slots adjust based on success/failure rate
-
-### Technical Stack
-- **Runtime**: Node.js 24+ (TypeScript)
-- **Tools**: Rust-based CLI tools (grep, glob, ast) via connection pool
-- **Concurrency**: Chase-Lev work-stealing deque + priority queues
-- **Memory**: Object pooling + string interning + buffer pooling
-- **State Management**: MVCC + Mutex
-- **Safety**: RAII + circuit breaker + resource pressure detection
-- **Knowledge**: In-memory graph RAG with BM25/Tag/Graph search fusion
-
----
-
-## 🔧 Installation & Configuration
-
-### Safe Installation
-The installation process is **production-safe** with multiple protection layers:
-
-1. ✅ **Never overwrites** — always merges with existing config
-2. ✅ **Automatic backups** — timestamped, last 5 kept
-3. ✅ **Atomic writes** — temp file + rename (OS-level atomic)
-4. ✅ **Automatic rollback** — restores from backup on any failure
-5. ✅ **Cross-platform** — Windows (native, Git Bash, WSL2), macOS, Linux
-6. ✅ **CI-aware** — skips non-essential operations in CI environments
-7. ✅ **Timeout protection** — 30s timeout prevents hanging
-8. ✅ **Graceful degradation** — exits 0 on non-critical failures
-
-### Safe Removal
-OpenCode config cleanup is provided as an explicit command because global package uninstall does not invoke dependency uninstall hooks in the npm flow validated for this package.
+## 5. Developer Notes
 
 ```bash
-npm explore -g opencode-orchestrator -- npm run cleanup:plugin
-npm uninstall -g opencode-orchestrator
+npm run build
+npx tsc --noEmit
+npm test
+cargo test --workspace --all-targets
 ```
 
-Manual fallback:
-- Open `~/.config/opencode/opencode.json` or `opencode.jsonc`
-- Remove `"opencode-orchestrator"` from the `plugin` array
-
-### Configuration Logs
-- Unix: `/tmp/opencode-orchestrator.log`
-- Windows: `%TEMP%\opencode-orchestrator.log`
+Useful references:
 
----
-
-## 🧪 Testing & Stability
-
-### Test Utilities
-Reusable helpers under `tests/harness/` provide:
-- **Disposable tmpdir**: Automatic cleanup with `Symbol.asyncDispose` / `Symbol.dispose`
-- **Test builders**: Factory functions for `ParallelTask`, `BackgroundTask`, `Todo`
-- **Mock utilities**: Console, process, timers, file system, event emitter mocks
+1. OpenCode plugins: https://opencode.ai/docs/plugins/
+2. OpenCode config: https://opencode.ai/docs/config/
+3. OpenCode keybinds: https://opencode.ai/docs/keybinds/
+4. Project issues: https://github.com/agnusdei1207/opencode-orchestrator/issues
 
-```typescript
-import { tmpdir, createParallelTask, mockConsole } from "@/tests/harness";
+Config logs:
 
-await using tmp = await tmpdir({ git: true });
-const task = createParallelTask({ description: "Test" });
-```
-
-### TUI Stability
-- **Cleanup guarantees**: `initToastClient()` returns a cleanup function
-- **Timeout protection**: AbortController-based 2-10s timeout for async toast operations
-- **Error isolation**: Try/catch around all toast operations prevents cascade failures
+| Platform | Path |
+| --- | --- |
+| Unix | `/tmp/opencode-orchestrator.log` |
+| Windows | `%TEMP%\opencode-orchestrator.log` |
 
-### Cross-Platform Reliability
-- **Windows guard**: Proper handling of WSL2, Git Bash, native Windows paths
-- **Signal handling**: Graceful shutdown on SIGINT/SIGTERM
-- **Process isolation**: Child process cleanup with timeout
+## 6. License
 
----
-
-## 📚 Documentation
-
-- [System Architecture Deep-Dive →](docs/SYSTEM_ARCHITECTURE.md)
-- [Developer Notes →](docs/DEVELOPERS_NOTE.md)
-- [Knowledge RAG Roadmap →](docs/histories/2026/05/31/PLAN_SecondBrainOrchestration_2026-05-31.md)
-
----
-
-## 📄 License
-
-MIT License — see [LICENSE](LICENSE) for details.
-
----
-
-<div align="center">
-  <sub>Built with ⚡ for production-grade autonomous software engineering</sub>
-</div>
+MIT License. See [LICENSE](LICENSE).

package/dist/core/orchestrator/state.d.ts

@@ -4,7 +4,7 @@
 import { SessionState } from "./interfaces/session-state.js";
 export declare const state: {
     missionActive: boolean;
-    maxIterations: 10000;
+    maxIterations: 1000000000;
     maxRetries: 3;
     sessions: Map<string, SessionState>;
 };

package/dist/hooks/features/mission-loop.d.ts

@@ -11,6 +11,7 @@ export declare class MissionControlHook implements AssistantDoneHook, ChatMessag
     name: "MissionLoop";
     execute(ctx: HookContext, text: string): Promise<any>;
     private handleChatCommand;
+    private cancelMission;
     private handleMissionProgress;
     private buildContinuationResponse;
     private handleMissionComplete;

package/dist/index.js

@@ -199,7 +199,7 @@ var init_limits = __esm({
     "use strict";
     LIMITS = {
       /** Maximum mission loop iterations */
-      MAX_ITERATIONS: 1e4,
+      MAX_ITERATIONS: 1e9,
       /** Default scan limit for file listing */
       DEFAULT_SCAN_LIMIT: 20,
       /** Max message history to check for conclusion */
@@ -1477,6 +1477,9 @@ var init_session_events = __esm({
     "use strict";
     SESSION_EVENTS = {
       IDLE: "session.idle",
+      STATUS: "session.status",
+      UPDATED: "session.updated",
+      COMPACTED: "session.compacted",
       BUSY: "session.busy",
       ERROR: "session.error",
       DELETED: "session.deleted",
@@ -36896,6 +36899,9 @@ function ensureSessionInitialized(sessions, sessionID, directory) {
       startTime: now,
       lastStepTime: now,
       lastCompletedMessageID: void 0,
+      lastUserMessageAt: void 0,
+      lastAssistantCompletedAt: void 0,
+      lastAbortAt: void 0,
       tokens: { totalInput: 0, totalOutput: 0, estimatedCost: 0 }
     };
     if (directory) {
@@ -36950,6 +36956,14 @@ function isMissionActive(sessionID, directory) {
   }
   return false;
 }
+function deactivateMissionState(sessionID) {
+  const stateSession = state.sessions.get(sessionID);
+  if (stateSession) {
+    stateSession.enabled = false;
+  }
+  state.missionActive = false;
+  log(`[SessionManager] Mission Deactivated: ${sessionID}`);
+}
 var COST_PER_1K_INPUT = 3e-3;
 var COST_PER_1K_OUTPUT = 0.015;
 function updateSessionTokens(sessions, sessionID, inputLen, outputLen) {
@@ -37712,7 +37726,12 @@ var MissionControlHook = class {
   // -------------------------------------------------------------------------------
   async handleChatCommand(ctx, message) {
     const parsed = detectSlashCommand(message);
-    if (!parsed || parsed.command !== COMMAND_NAMES.TASK) return null;
+    if (!parsed) return null;
+    if (parsed.command === COMMAND_NAMES.CANCEL || parsed.command === COMMAND_NAMES.STOP) {
+      await this.cancelMission(ctx);
+      return { action: HOOK_ACTIONS.INTERCEPT };
+    }
+    if (parsed.command !== COMMAND_NAMES.TASK) return null;
     const command = COMMANDS[parsed.command];
     const { sessionID, sessions, directory } = ctx;
     log(MISSION_MESSAGES.START_LOG);
@@ -37730,6 +37749,17 @@ var MissionControlHook = class {
     }
     return { action: HOOK_ACTIONS.PROCESS };
   }
+  async cancelMission(ctx) {
+    const { sessionID, sessions, directory } = ctx;
+    log(MISSION_MESSAGES.CANCEL_LOG);
+    await cancelMissionLoop(directory, sessionID);
+    deactivateMissionState(sessionID);
+    clearSession2(sessionID);
+    const session = sessions.get(sessionID);
+    if (isRecord(session)) {
+      session.active = false;
+    }
+  }
   // -------------------------------------------------------------------------------
   // 2. Done Logic: Check Completion & Auto-Continue
   // -------------------------------------------------------------------------------
@@ -37782,6 +37812,9 @@ var MissionControlHook = class {
   // 4. Helper: Build Continuation Response
   // -------------------------------------------------------------------------------
   buildContinuationResponse(session, sessionID) {
+    if (!isMissionSessionState(session)) {
+      return { action: HOOK_ACTIONS.CONTINUE };
+    }
     const now = Date.now();
     const stepDuration = formatElapsedTime(session.lastStepTime, now);
     const totalElapsed = formatElapsedTime(session.startTime, now);
@@ -37839,6 +37872,12 @@ var MissionControlHook = class {
     }
   }
 };
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissionSessionState(value) {
+  return isRecord(value) && typeof value.step === "number" && typeof value.startTime === "number" && typeof value.lastStepTime === "number";
+}
 
 // src/hooks/custom/strict-role-guard.ts
 init_shared();
@@ -38557,6 +38596,13 @@ function handleSessionError2(sessionID, error95) {
   }
   cancelCountdown(sessionID);
 }
+function handleAbort(sessionID) {
+  const state2 = getState3(sessionID);
+  state2.isAborting = true;
+  state2.abortDetectedAt = Date.now();
+  cancelCountdown(sessionID);
+  log("[todo-continuation] Marked as aborting", { sessionID });
+}
 function cleanupSession2(sessionID) {
   cancelCountdown(sessionID);
   sessionStates2.delete(sessionID);
@@ -41137,11 +41183,11 @@ var CONCURRENCY_KEYS = [
   "providerConcurrency",
   "modelConcurrency"
 ];
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readLimitMap(value) {
-  if (!isRecord(value)) return void 0;
+  if (!isRecord2(value)) return void 0;
   const result = {};
   for (const [key, limit] of Object.entries(value)) {
     if (typeof limit === "number" && Number.isFinite(limit) && limit >= 0) {
@@ -41151,7 +41197,7 @@ function readLimitMap(value) {
   return Object.keys(result).length > 0 ? result : void 0;
 }
 function extractConcurrencyConfig(source) {
-  if (!isRecord(source)) return {};
+  if (!isRecord2(source)) return {};
   const config3 = {};
   if (typeof source.defaultConcurrency === "number" && source.defaultConcurrency >= 0) {
     config3.defaultConcurrency = source.defaultConcurrency;
@@ -41165,7 +41211,7 @@ function extractConcurrencyConfig(source) {
   return config3;
 }
 function hasConcurrencyConfig(source) {
-  if (!isRecord(source)) return false;
+  if (!isRecord2(source)) return false;
   return CONCURRENCY_KEYS.some((key) => source[key] !== void 0);
 }
 function mergeConcurrencyConfig(base, override) {
@@ -41189,14 +41235,14 @@ function mergeConcurrencyConfig(base, override) {
 
 // src/core/config/plugin-options.ts
 function parseOrchestratorPluginOptions(options) {
-  const source = isRecord2(options) ? options : {};
+  const source = isRecord3(options) ? options : {};
   return {
     concurrency: extractConcurrencyConfig(source),
     missionLoop: readMissionLoopOptions(source.missionLoop)
   };
 }
 function readMissionLoopOptions(value) {
-  if (!isRecord2(value)) return DEFAULT_MISSION_RUNTIME_OPTIONS;
+  if (!isRecord3(value)) return DEFAULT_MISSION_RUNTIME_OPTIONS;
   return {
     ledger: readBoolean(value.ledger, DEFAULT_MISSION_RUNTIME_OPTIONS.ledger),
     markdownMemory: readBoolean(value.markdownMemory, DEFAULT_MISSION_RUNTIME_OPTIONS.markdownMemory),
@@ -41212,7 +41258,7 @@ function readBoolean(value, fallback) {
 function readPositiveInteger(value, fallback) {
   return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -41259,6 +41305,7 @@ function createChatMessageHandler(ctx) {
     const sessionID = msgInput.sessionID;
     const agentName = (msgInput.agent || "").toLowerCase();
     log("[chat-message-handler] hook triggered", { sessionID, agent: agentName, textLength: originalText.length });
+    markUserMessage(sessions, sessionID);
     if (sessionID && !sessions.has(sessionID)) {
     }
     const hooks = HookRegistry.getInstance();
@@ -41269,6 +41316,7 @@ function createChatMessageHandler(ctx) {
     };
     const hookResult = await hooks.executeChat(hookContext, originalText);
     if (hookResult.action === HOOK_ACTIONS.INTERCEPT) {
+      parts.splice(0, parts.length);
       return;
     }
     if (hookResult.modifiedMessage) {
@@ -41276,6 +41324,11 @@ function createChatMessageHandler(ctx) {
     }
   };
 }
+function markUserMessage(sessions, sessionID) {
+  const session = sessions.get(sessionID);
+  if (!session) return;
+  session.lastUserMessageAt = Date.now();
+}
 
 // src/plugin-handlers/config-handler.ts
 init_shared();
@@ -41327,7 +41380,7 @@ This plugin runs in "Claude Code Compatibility Mode".
 }
 
 // src/plugin-handlers/config-handler.ts
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPermissionAction(value) {
@@ -41337,10 +41390,10 @@ function mergePermission(globalPermission, agentPermission) {
   if (agentPermission === void 0) {
     return globalPermission;
   }
-  if (isRecord3(globalPermission) && isRecord3(agentPermission)) {
+  if (isRecord4(globalPermission) && isRecord4(agentPermission)) {
     return { ...globalPermission, ...agentPermission };
   }
-  if (isPermissionAction(globalPermission) && isRecord3(agentPermission)) {
+  if (isPermissionAction(globalPermission) && isRecord4(agentPermission)) {
     return { "*": globalPermission, ...agentPermission };
   }
   return agentPermission;
@@ -42045,9 +42098,11 @@ async function handleMissionIdle(client, directory, sessionID, mainSessionID) {
   }, MISSION_CONTROL.DEFAULT_COUNTDOWN_SECONDS * 1e3);
 }
 function handleUserMessage2(sessionID) {
+  const state2 = sessionStateStore.getState(sessionID);
+  state2.isAborting = false;
   sessionStateStore.cancelCountdown(sessionID);
 }
-function handleAbort(sessionID) {
+function handleAbort2(sessionID) {
   const state2 = sessionStateStore.getState(sessionID);
   state2.isAborting = true;
   sessionStateStore.cancelCountdown(sessionID);
@@ -42148,7 +42203,7 @@ function createEventHandler(ctx) {
       const error95 = event.properties?.error;
       if (sessionID) {
         handleSessionError2(sessionID, error95);
-        handleAbort(sessionID);
+        handleAbort2(sessionID);
       }
       if (sessionID && error95) {
         const recovered = await handleSessionError(
@@ -42175,6 +42230,7 @@ function createEventHandler(ctx) {
       if (sessionID && role === MESSAGE_ROLES.ASSISTANT) {
         markRecoveryComplete(sessionID);
         if (messageInfo?.id && messageInfo.time?.completed) {
+          markAssistantCompleted(sessions, sessionID);
           await handleCompletedAssistantMessage(ctx, sessionID, messageInfo.id);
         }
       }
@@ -42186,35 +42242,75 @@ function createEventHandler(ctx) {
     if (event.type === SESSION_EVENTS.IDLE) {
       const sessionID = event.properties?.sessionID || "";
       if (sessionID) {
-        const isMainSession = sessions.has(sessionID);
-        if (isMainSession) {
-          setTimeout(async () => {
-            const session = sessions.get(sessionID);
-            if (session?.active) {
-              if (isLoopActive(directory, sessionID)) {
-                await handleMissionIdle(
-                  client,
-                  directory,
-                  sessionID,
-                  sessionID
-                ).catch(() => {
-                });
-              } else {
-                await handleSessionIdle(
-                  client,
-                  directory,
-                  sessionID,
-                  sessionID
-                ).catch(() => {
-                });
-              }
-            }
-          }, 500);
-        }
+        scheduleIdleContinuation(ctx, sessionID);
+      }
+    }
+    if (event.type === SESSION_EVENTS.STATUS) {
+      const properties = event.properties;
+      const sessionID = properties?.sessionID ?? "";
+      if (sessionID && properties?.status?.type === "idle") {
+        scheduleIdleContinuation(ctx, sessionID);
       }
     }
   };
 }
+function markAssistantCompleted(sessions, sessionID) {
+  const session = sessions.get(sessionID);
+  if (!session) return;
+  session.lastAssistantCompletedAt = Date.now();
+}
+function shouldContinueAfterIdle(session) {
+  if (!session?.active || !session.lastAssistantCompletedAt) {
+    return false;
+  }
+  if (session.lastUserMessageAt && session.lastAssistantCompletedAt < session.lastUserMessageAt) {
+    return false;
+  }
+  if (session.lastAbortAt && session.lastAssistantCompletedAt < session.lastAbortAt) {
+    return false;
+  }
+  return true;
+}
+function markAbort(sessions, sessionID) {
+  const session = sessions.get(sessionID);
+  if (session) {
+    session.lastAbortAt = Date.now();
+  }
+  handleAbort(sessionID);
+  handleAbort2(sessionID);
+}
+function scheduleIdleContinuation(ctx, sessionID) {
+  const { client, directory, sessions } = ctx;
+  if (!sessions.has(sessionID)) return;
+  setTimeout(async () => {
+    const session = sessions.get(sessionID);
+    if (!shouldContinueAfterIdle(session)) {
+      markAbort(sessions, sessionID);
+      return;
+    }
+    if (isLoopActive(directory, sessionID)) {
+      try {
+        await handleMissionIdle(
+          client,
+          directory,
+          sessionID,
+          sessionID
+        );
+      } catch {
+      }
+      return;
+    }
+    try {
+      await handleSessionIdle(
+        client,
+        directory,
+        sessionID,
+        sessionID
+      );
+    } catch {
+    }
+  }, 500);
+}
 
 // src/plugin-handlers/tool-execute-handler.ts
 init_logger();

package/dist/plugin-handlers/interfaces/session-state.d.ts

@@ -8,6 +8,9 @@ export interface SessionState {
     startTime: number;
     lastStepTime: number;
     lastCompletedMessageID?: string;
+    lastUserMessageAt?: number;
+    lastAssistantCompletedAt?: number;
+    lastAbortAt?: number;
     tokens: {
         totalInput: number;
         totalOutput: number;

package/dist/scripts/postinstall.js

@@ -1459,8 +1459,22 @@ function formatError(err, context) {
   return `Failed to ${context}: ${String(err)}`;
 }
 var PLUGIN_NAME = "opencode-orchestrator";
-function isOurPluginEntry(p) {
-  return p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPluginTuple(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && isRecord(value[1]);
+}
+function isPluginEntry(value) {
+  return typeof value === "string" || isPluginTuple(value);
+}
+function getPluginName(entry) {
+  return typeof entry === "string" ? entry : entry[0];
+}
+function isOurPluginEntry(entry) {
+  if (!isPluginEntry(entry)) return false;
+  const pluginName = getPluginName(entry);
+  return pluginName === PLUGIN_NAME || pluginName.startsWith(`${PLUGIN_NAME}@`);
 }
 function getConfigFileCandidates(configDir) {
   return [join(configDir, "opencode.jsonc"), join(configDir, "opencode.json")];
@@ -1578,8 +1592,8 @@ function validateConfig(config) {
       return false;
     }
     if (config.plugin) {
-      for (const p of config.plugin) {
-        if (typeof p !== "string") {
+      for (const entry of config.plugin) {
+        if (!isPluginEntry(entry)) {
           return false;
         }
       }
@@ -1672,10 +1686,7 @@ function registerInConfig(configDir) {
         config["$schema"] = "https://opencode.ai/config.json";
       }
     }
-    const hasPlugin = config.plugin.some((p) => {
-      if (typeof p !== "string") return false;
-      return isOurPluginEntry(p);
-    });
+    const hasPlugin = config.plugin.some((entry) => isOurPluginEntry(entry));
     if (hasPlugin) {
       log("Plugin already registered", { configFile });
       return { success: false, backupFile };
@@ -1693,7 +1704,7 @@ function registerInConfig(configDir) {
         throw new Error(`Verification parse failed: ${verifyParsed.parseError ?? "unknown parse error"}`);
       }
       const verifyConfig = verifyParsed.config;
-      if (!verifyConfig.plugin?.some((p) => isOurPluginEntry(p))) {
+      if (!verifyConfig.plugin?.some((entry) => isOurPluginEntry(entry))) {
         throw new Error("Verification failed: plugin not found after write");
       }
     } catch (verifyError) {
@@ -1760,7 +1771,7 @@ try {
       continue;
     }
     targetConfigDir = configDir;
-    if (existing.config.plugin?.some((p) => typeof p === "string" && isOurPluginEntry(p))) {
+    if (existing.config.plugin?.some((entry) => isOurPluginEntry(entry))) {
       alreadyRegistered = true;
       log("Plugin already registered in this location", { configFile: existing.file });
       break;

package/dist/scripts/preuninstall.js

@@ -1459,8 +1459,22 @@ function formatError(err, context) {
   return `Failed to ${context}: ${String(err)}`;
 }
 var PLUGIN_NAME = "opencode-orchestrator";
-function isOurPluginEntry(p) {
-  return p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPluginTuple(value) {
+  return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && isRecord(value[1]);
+}
+function isPluginEntry(value) {
+  return typeof value === "string" || isPluginTuple(value);
+}
+function getPluginName(entry) {
+  return typeof entry === "string" ? entry : entry[0];
+}
+function isOurPluginEntry(entry) {
+  if (!isPluginEntry(entry)) return false;
+  const pluginName = getPluginName(entry);
+  return pluginName === PLUGIN_NAME || pluginName.startsWith(`${PLUGIN_NAME}@`);
 }
 function getConfigFileCandidates(configDir) {
   return [join(configDir, "opencode.jsonc"), join(configDir, "opencode.json")];
@@ -1562,8 +1576,8 @@ function validateConfig(config) {
       return false;
     }
     if (config.plugin) {
-      for (const p of config.plugin) {
-        if (typeof p !== "string") {
+      for (const entry of config.plugin) {
+        if (!isPluginEntry(entry)) {
           return false;
         }
       }
@@ -1646,10 +1660,7 @@ function removeFromConfig(configDir) {
     }
     const originalLength = config.plugin.length;
     const originalPlugins = [...config.plugin];
-    config.plugin = config.plugin.filter((p) => {
-      if (typeof p !== "string") return true;
-      return !isOurPluginEntry(p);
-    });
+    config.plugin = config.plugin.filter((entry) => !isOurPluginEntry(entry));
     if (config.plugin.length === originalLength) {
       log("Plugin not found in config", { configFile });
       return { success: false, backupFile };
@@ -1671,9 +1682,7 @@ function removeFromConfig(configDir) {
         throw new Error(`Verification parse failed: ${verifyParsed.parseError ?? "unknown parse error"}`);
       }
       const verifyConfig = verifyParsed.config;
-      const stillHasPlugin = verifyConfig.plugin?.some(
-        (p) => typeof p === "string" && isOurPluginEntry(p)
-      );
+      const stillHasPlugin = verifyConfig.plugin?.some((entry) => isOurPluginEntry(entry));
       if (stillHasPlugin) {
         throw new Error("Verification failed: plugin still present after removal");
       }

package/dist/shared/core/constants/limits.d.ts

@@ -3,7 +3,7 @@
  */
 export declare const LIMITS: {
     /** Maximum mission loop iterations */
-    readonly MAX_ITERATIONS: 10000;
+    readonly MAX_ITERATIONS: 1000000000;
     /** Default scan limit for file listing */
     readonly DEFAULT_SCAN_LIMIT: 20;
     /** Max message history to check for conclusion */

package/dist/shared/loop/constants/loop.d.ts

@@ -11,7 +11,7 @@ export declare const LOOP: {
     /** Window to consider abort as recent */
     readonly ABORT_WINDOW_MS: number;
     /** Maximum iterations for mission loop */
-    readonly DEFAULT_MAX_ITERATIONS: 10000;
+    readonly DEFAULT_MAX_ITERATIONS: 1000000000;
     /** Rust tool timeout */
     readonly RUST_TOOL_TIMEOUT_MS: number;
 };

package/dist/shared/loop/constants/mission-control.d.ts

@@ -2,7 +2,7 @@
  * Mission Control Configuration
  */
 export declare const MISSION_CONTROL: {
-    readonly DEFAULT_MAX_ITERATIONS: 10000;
+    readonly DEFAULT_MAX_ITERATIONS: 1000000000;
     readonly DEFAULT_COUNTDOWN_SECONDS: 3;
     readonly STATE_FILE: "loop-state.json";
     readonly STOP_COMMAND: "/stop";
@@ -11,7 +11,7 @@ export declare const MISSION_CONTROL: {
 };
 /** @deprecated Use MISSION_CONTROL instead */
 export declare const MISSION: {
-    readonly DEFAULT_MAX_ITERATIONS: 10000;
+    readonly DEFAULT_MAX_ITERATIONS: 1000000000;
     readonly DEFAULT_COUNTDOWN_SECONDS: 3;
     readonly STATE_FILE: "loop-state.json";
     readonly STOP_COMMAND: "/stop";

package/dist/shared/loop/interfaces/mission-loop.d.ts

@@ -30,7 +30,7 @@ export interface MissionLoopState {
     lastContinuationAt?: string;
 }
 export interface MissionLoopOptions {
-    /** Maximum iterations before stopping (default: 1000) */
+    /** Maximum iterations before stopping (default: 1,000,000,000) */
     maxIterations?: number;
     /** Countdown seconds before auto-continue (default: 3) */
     countdownSeconds?: number;

package/dist/shared/session/constants/events/index.d.ts

@@ -10,6 +10,8 @@ export declare const EVENT_TYPES: {
     readonly CACHED: "document.cached";
     readonly EXPIRED: "document.expired";
     readonly IDLE: "session.idle";
+    readonly STATUS: "session.status";
+    readonly COMPACTED: "session.compacted";
     readonly BUSY: "session.busy";
     readonly ERROR: "session.error";
     readonly DELETED: "session.deleted";

package/dist/shared/session/constants/events/session-events.d.ts

@@ -3,6 +3,9 @@
  */
 export declare const SESSION_EVENTS: {
     readonly IDLE: "session.idle";
+    readonly STATUS: "session.status";
+    readonly UPDATED: "session.updated";
+    readonly COMPACTED: "session.compacted";
     readonly BUSY: "session.busy";
     readonly ERROR: "session.error";
     readonly DELETED: "session.deleted";

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": "1.3.4",
+  "version": "1.3.5",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {
@@ -59,9 +59,9 @@
     "sync:readme-version": "node scripts/sync-readme-version.mjs",
     "version": "node scripts/sync-readme-version.mjs --stage",
     "release:preflight": "node scripts/release-preflight.mjs",
-    "release:patch": "node scripts/release-auth-check.mjs && node scripts/release-version.mjs patch && npm run release:preflight && npm run docker:rust-dist && npm run publish:token",
-    "release:minor": "node scripts/release-auth-check.mjs && node scripts/release-version.mjs minor && npm run release:preflight && npm run docker:rust-dist && npm run publish:token",
-    "release:major": "node scripts/release-auth-check.mjs && node scripts/release-version.mjs major && npm run release:preflight && npm run docker:rust-dist && npm run publish:token",
+    "release:patch": "node scripts/release-auth-check.mjs && node scripts/release-version.mjs patch && npm run release:preflight && npm run docker:rust-dist && node scripts/release-sync-artifacts.mjs && npm run publish:token",
+    "release:minor": "node scripts/release-auth-check.mjs && node scripts/release-version.mjs minor && npm run release:preflight && npm run docker:rust-dist && node scripts/release-sync-artifacts.mjs && npm run publish:token",
+    "release:major": "node scripts/release-auth-check.mjs && node scripts/release-version.mjs major && npm run release:preflight && npm run docker:rust-dist && node scripts/release-sync-artifacts.mjs && npm run publish:token",
     "release:dry-run": "node scripts/release-preflight.mjs --allow-dirty --skip-branch --skip-version-check",
     "release:push-tags": "git push origin main && git push origin --tags",
     "release:clean": "shx rm -rf dist bin && docker compose down -v",