opencode-orchestrator 1.0.5 → 1.0.7

package/README.md

@@ -66,33 +66,59 @@ Built for "Infinite Missions," the OpenCode Orchestrator is engineered to handle
 ## 🏛️ Workflow Architecture
 
 ```
-        /extreme-mission "Build REST API"
-                │
-    ╔═══════════════════════════════════╗
-    ║  🎯 COMMANDER — "Start the task"  ║
-    ╚═══════════════╤═══════════════════╝
-                    │
-    ┌───────────────┼───────────────┐
-    ▼               ▼               ▼
-┌───────┐      ┌───────┐      ┌───────┐
-│PLANNER│      │WORKER │      │WORKER │   ← 🔥 50 PARALLEL
-│plan.md│      │auth.ts│      │api.ts │      TASKS CONCURRENTLY
-└───────┘      └───────┘      └───────┘
-    │               │               │
-    └───────────────┼───────────────┘
-                    ▼
-    ╔═══════════════════════════════════╗
-    ║  ✅ REVIEWER — "Verify everything"║
-    ╚═══════════════╤═══════════════════╝
-                    │
-           ┌────────┴────────┐
-           │ TODO 100%?      │
-           │ Issues = 0?     │
-           └────────┬────────┘
-             No ↙       ↘ Yes
-          ♻️ LOOP      ✅ COMPLETE
+              /extreme-mission "Build REST API"
+                          │
+          ╔═══════════════════════════════════════╗
+          ║     🎯 COMMANDER — Orchestrator       ║
+          ║        (Main Session - Single)        ║
+          ╚═══════════════════╤═══════════════════╝
+                              │
+          ┌───────────────────▼───────────────────┐
+          │      📋 PLANNER — Create Plan         │
+          │         (Single, Sync Call)           │
+          │    → Outputs: .opencode/todo.md       │
+          └───────────────────┬───────────────────┘
+                              │
+    ══════════════════════════╧══════════════════════════
+    ║                  🔥 PARALLEL ZONE                  ║
+    ══════════════════════════════════════════════════════
+          │               │               │
+          ▼               ▼               ▼
+    ┌──────────┐   ┌──────────┐   ┌──────────┐
+    │ 🔨 WORKER│   │ 🔨 WORKER│   │ 🔨 WORKER│  ← Up to 50
+    │  Task 1  │   │  Task 2  │   │  Task 3  │    concurrent
+    │ auth.ts  │   │  api.ts  │   │  db.ts   │    sessions
+    └────┬─────┘   └────┬─────┘   └────┬─────┘
+         │              │              │
+    ══════════════════════════════════════════════════════
+    ║                  ⏳ SYNC BARRIER                   ║
+    ══════════════════════════════════════════════════════
+                              │
+          ┌───────────────────▼───────────────────┐
+          │      ✅ REVIEWER — Verify All         │
+          │         (Single, Sync Call)           │
+          │    → Tests, Lint, Integration         │
+          └───────────────────┬───────────────────┘
+                              │
+                    ┌─────────┴─────────┐
+                    │   All Complete?   │
+                    │   Issues = 0?     │
+                    └─────────┬─────────┘
+                        No ↙     ↘ Yes
+                    ♻️ LOOP    🎖️ MISSION
+                   (back to     SEALED
+                   Commander)
 ```
 
+### Execution Model
+
+| Phase | Agent | Parallelism | Blocking |
+|:------|:------|:------------|:---------|
+| 1️⃣ Plan | Planner | **Single** | Sync (waits) |
+| 2️⃣ Execute | Workers | **Parallel** (up to 50) | Async (background) |
+| 3️⃣ Verify | Reviewer | **Single** | Sync (waits) |
+| 4️⃣ Loop | Commander | **Single** | Coordinates |
+
 ## Features
 
 | Feature | What It Does |

package/dist/agents/prompts/common/index.d.ts

@@ -12,3 +12,4 @@ export { VERIFICATION_REQUIREMENTS } from "./verification.js";
 export { CORE_PHILOSOPHY } from "./core-philosophy.js";
 export { SHARED_LSP_TOOLS } from "./lsp.js";
 export { SHARED_AST_TOOLS } from "./ast.js";
+export { MODULARITY_ENFORCEMENT } from "./modularity.js";

package/dist/agents/prompts/common/modularity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Modularity & Separation of Concerns (Anti-Monolith Strategy)
+ *
+ * This fragment enforces physical file separation to prevent monolithic output.
+ */
+export declare const MODULARITY_ENFORCEMENT: string;

package/dist/core/agents/config.d.ts

@@ -5,5 +5,5 @@ export declare const CONFIG: {
     readonly TASK_TTL_MS: number;
     readonly CLEANUP_DELAY_MS: number;
     readonly MIN_STABILITY_MS: number;
-    readonly POLL_INTERVAL_MS: 500;
+    readonly POLL_INTERVAL_MS: 2000;
 };

package/dist/core/agents/manager/task-launcher.d.ts

@@ -15,6 +15,19 @@ export declare class TaskLauncher {
     private onTaskError;
     private startPolling;
     constructor(client: OpencodeClient, directory: string, store: TaskStore, concurrency: ConcurrencyController, onTaskError: (taskId: string, error: unknown) => void, startPolling: () => void);
-    launch(input: LaunchInput): Promise<ParallelTask>;
+    /**
+     * Unified launch method - handles both single and multiple tasks efficiently.
+     * All session creations happen in parallel immediately.
+     * Concurrency acquisition and prompt firing happen in the background.
+     */
+    launch(inputs: LaunchInput | LaunchInput[]): Promise<ParallelTask | ParallelTask[]>;
+    /**
+     * Prepare task: Create session and registration without blocking on concurrency
+     */
+    private prepareTask;
+    /**
+     * Background execution: Acquire slot and fire prompt
+     */
+    private executeBackground;
 }
 export {};

package/dist/core/agents/manager.d.ts

@@ -30,7 +30,7 @@ export declare class ParallelAgentManager {
     private eventHandler;
     private constructor();
     static getInstance(client?: OpencodeClient, directory?: string): ParallelAgentManager;
-    launch(input: LaunchInput): Promise<ParallelTask>;
+    launch(inputs: LaunchInput | LaunchInput[]): Promise<ParallelTask | ParallelTask[]>;
     resume(input: ResumeInput): Promise<ParallelTask>;
     getTask(id: string): ParallelTask | undefined;
     getRunningTasks(): ParallelTask[];

package/dist/index.js

@@ -293,12 +293,18 @@ var PARALLEL_TASK = {
   DEFAULT_CONCURRENCY: 3,
   MAX_CONCURRENCY: 10,
   // Sync polling (for delegate_task sync mode)
+  // Optimized: Reduced polling frequency while relying more on events
   SYNC_TIMEOUT_MS: 5 * TIME.MINUTE,
-  POLL_INTERVAL_MS: 500,
-  MIN_IDLE_TIME_MS: 5 * TIME.SECOND,
-  MIN_STABILITY_MS: 3 * TIME.SECOND,
-  STABLE_POLLS_REQUIRED: 3,
-  MAX_POLL_COUNT: 600,
+  POLL_INTERVAL_MS: 2e3,
+  // 500 → 2000ms (75% less API calls)
+  MIN_IDLE_TIME_MS: 3 * TIME.SECOND,
+  // 5s → 3s (faster detection)
+  MIN_STABILITY_MS: 2 * TIME.SECOND,
+  // 3s → 2s (faster stability)
+  STABLE_POLLS_REQUIRED: 2,
+  // 3 → 2 (faster completion)
+  MAX_POLL_COUNT: 150,
+  // 600 → 150 (adjusted for 2s interval)
   // Session naming
   SESSION_TITLE_PREFIX: "Parallel",
   // Labels for output
@@ -1610,10 +1616,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1974,11 +1980,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -2146,7 +2152,7 @@ function treeifyError(error45, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error46, path5 = []) => {
+  const processError = (error46, path6 = []) => {
     var _a, _b;
     for (const issue2 of error46.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -2156,7 +2162,7 @@ function treeifyError(error45, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -2188,8 +2194,8 @@ function treeifyError(error45, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path5) {
+  const path6 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path6) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -13679,6 +13685,34 @@ var SHARED_AST_TOOLS = `<ast_tools>
 - Always verify structural changes with \`${TOOL_NAMES.LSP_DIAGNOSTICS}\`.
 </ast_tools>`;
 
+// src/agents/prompts/common/modularity.ts
+var MODULARITY_ENFORCEMENT = `${PROMPT_TAGS.QUALITY_CHECKLIST.open}
+\u{1F3D7}\uFE0F UNIVERSAL ARCHITECTURAL MODULARITY (Language-Agnostic)
+
+To maintain a scalable and maintainable codebase, follow these structural principles regardless of the programming language:
+
+### 1. Structural Layering (The "Layer Separation" Rule)
+Physically separate code based on its functional role. Do not mix these layers in a single file:
+-   **Definitions & Contracts**: Data structures, types, interfaces, or schemas that define the "shape" of data.
+-   **Static Values & Constants**: Hard-coded values, configuration keys, translations, or design tokens.
+-   **Core Implementation**: The active logic, algorithms, functions, or classes that perform the work.
+-   **State & Storage**: Persistent data handling, database interactions, or memory management logic.
+
+### 2. Folder-Based Encapsulation (Feature-Oriented)
+-   **Group by Domain/Feature**: Instead of grouping by technical type (e.g., all "utils" in one flat folder), create a directory for each meaningful feature or domain.
+-   **Internal Structure**: For any feature complex enough to need multiple files, use a dedicated folder.
+-   **Public Interface**: Each folder should have a clear entry point (e.g., \`index\`, \`mod.rs\`, \`main\`, or exports) that acts as the "Receptionist" for that module, hiding internal complexity.
+
+### 3. Complexity Sharding
+If a single unit of code (file or module) starts to handle multiple distinct concerns, **shard it** into a directory:
+-   **High Cohesion**: Keep related code close together within the same folder.
+-   **Low Coupling**: Minimize dependencies between folders. Use "Shared/Common" directories only for truly universal helpers.
+
+### 4. Code "Mass" Limits
+-   Keep individual files concise and focused on a single responsibility. 
+-   If you have to scroll through "screens of code" to find a different type of logic, it belongs in a new file or sub-folder.
+${PROMPT_TAGS.QUALITY_CHECKLIST.close}`;
+
 // src/agents/prompts/commander/role.ts
 var COMMANDER_ROLE = `${PROMPT_TAGS.ROLE.open}
 You are ${AGENT_NAMES.COMMANDER}. Autonomous mission controller.
@@ -15295,6 +15329,7 @@ var commander = {
 // src/agents/subagents/planner.ts
 var systemPrompt2 = [
   PLANNER_ROLE,
+  MODULARITY_ENFORCEMENT,
   PLANNER_FORBIDDEN,
   PLANNER_REQUIRED,
   ENVIRONMENT_DISCOVERY,
@@ -15320,6 +15355,7 @@ var planner = {
 // src/agents/subagents/worker.ts
 var systemPrompt3 = [
   WORKER_ROLE,
+  MODULARITY_ENFORCEMENT,
   WORKER_FORBIDDEN,
   WORKER_REQUIRED,
   ANTI_HALLUCINATION_CORE,
@@ -15347,6 +15383,7 @@ var worker = {
 // src/agents/subagents/reviewer.ts
 var systemPrompt4 = [
   REVIEWER_ROLE,
+  MODULARITY_ENFORCEMENT,
   REVIEWER_FORBIDDEN,
   REVIEWER_REQUIRED,
   REVIEWER_VERIFICATION,
@@ -16229,7 +16266,7 @@ var TaskStore = class {
     return Array.from(this.tasks.values());
   }
   getRunning() {
-    return this.getAll().filter((t) => t.status === TASK_STATUS.RUNNING);
+    return this.getAll().filter((t) => t.status === TASK_STATUS.RUNNING || t.status === TASK_STATUS.PENDING);
   }
   getByParent(parentSessionID) {
     return this.getAll().filter((t) => t.parentSessionID === parentSessionID);
@@ -16948,74 +16985,111 @@ var TaskLauncher = class {
     this.onTaskError = onTaskError;
     this.startPolling = startPolling;
   }
-  async launch(input) {
-    log("[task-launcher.ts] launch() called", { agent: input.agent, description: input.description, parent: input.parentSessionID });
-    const concurrencyKey = input.agent;
-    await this.concurrency.acquire(concurrencyKey);
-    log("[task-launcher.ts] concurrency acquired for", concurrencyKey);
-    try {
-      const createResult = await this.client.session.create({
-        body: { parentID: input.parentSessionID, title: `${PARALLEL_TASK.SESSION_TITLE_PREFIX}: ${input.description}` },
-        query: { directory: this.directory }
+  /**
+   * Unified launch method - handles both single and multiple tasks efficiently.
+   * All session creations happen in parallel immediately.
+   * Concurrency acquisition and prompt firing happen in the background.
+   */
+  async launch(inputs) {
+    const isArray = Array.isArray(inputs);
+    const taskInputs = isArray ? inputs : [inputs];
+    if (taskInputs.length === 0) return isArray ? [] : null;
+    log(`[task-launcher.ts] Batch launching ${taskInputs.length} task(s)`);
+    const startTime = Date.now();
+    const tasks = await Promise.all(taskInputs.map(
+      (input) => this.prepareTask(input).catch((error45) => {
+        log(`[task-launcher.ts] Failed to prepare task ${input.description}:`, error45);
+        return null;
+      })
+    ));
+    const successfulTasks = tasks.filter((t) => t !== null);
+    successfulTasks.forEach((task) => {
+      this.executeBackground(task).catch((error45) => {
+        log(`[task-launcher.ts] Background execution failed for ${task.id}:`, error45);
+        this.onTaskError(task.id, error45);
       });
-      if (createResult.error) {
-        this.concurrency.release(concurrencyKey);
-        throw new Error(`Failed to create session: ${createResult.error}`);
-      }
-      const sessionID = createResult.data.id;
-      const taskId = `${ID_PREFIX.TASK}${crypto.randomUUID().slice(0, 8)}`;
-      const depth = (input.depth ?? 0) + 1;
-      log("[task-launcher.ts] Creating task with depth", depth);
-      const task = {
+    });
+    const elapsed = Date.now() - startTime;
+    log(`[task-launcher.ts] Batch launch prepared: ${successfulTasks.length} tasks in ${elapsed}ms`);
+    if (successfulTasks.length > 0) {
+      this.startPolling();
+    }
+    return isArray ? successfulTasks : successfulTasks[0] || null;
+  }
+  /**
+   * Prepare task: Create session and registration without blocking on concurrency
+   */
+  async prepareTask(input) {
+    const createResult = await this.client.session.create({
+      body: {
+        parentID: input.parentSessionID,
+        title: `${PARALLEL_TASK.SESSION_TITLE_PREFIX}: ${input.description}`
+      },
+      query: { directory: this.directory }
+    });
+    if (createResult.error || !createResult.data?.id) {
+      throw new Error(`Session creation failed: ${createResult.error || "No ID"}`);
+    }
+    const sessionID = createResult.data.id;
+    const taskId = `${ID_PREFIX.TASK}${crypto.randomUUID().slice(0, 8)}`;
+    const task = {
+      id: taskId,
+      sessionID,
+      parentSessionID: input.parentSessionID,
+      description: input.description,
+      prompt: input.prompt,
+      agent: input.agent,
+      status: TASK_STATUS.PENDING,
+      // Start as PENDING
+      startedAt: /* @__PURE__ */ new Date(),
+      concurrencyKey: input.agent,
+      depth: (input.depth ?? 0) + 1
+    };
+    this.store.set(taskId, task);
+    this.store.trackPending(input.parentSessionID, taskId);
+    taskWAL.log(WAL_ACTIONS.LAUNCH, task).catch(() => {
+    });
+    const toastManager = getTaskToastManager();
+    if (toastManager) {
+      toastManager.addTask({
         id: taskId,
-        sessionID,
-        parentSessionID: input.parentSessionID,
         description: input.description,
-        prompt: input.prompt,
         agent: input.agent,
-        status: TASK_STATUS.RUNNING,
-        startedAt: /* @__PURE__ */ new Date(),
-        concurrencyKey,
-        depth
-      };
-      this.store.set(taskId, task);
-      this.store.trackPending(input.parentSessionID, taskId);
+        isBackground: true,
+        parentSessionID: input.parentSessionID,
+        sessionID
+      });
+    }
+    presets.sessionCreated(sessionID, input.agent);
+    return task;
+  }
+  /**
+   * Background execution: Acquire slot and fire prompt
+   */
+  async executeBackground(task) {
+    try {
+      await this.concurrency.acquire(task.agent);
+      task.status = TASK_STATUS.RUNNING;
+      task.startedAt = /* @__PURE__ */ new Date();
+      this.store.set(task.id, task);
       taskWAL.log(WAL_ACTIONS.LAUNCH, task).catch(() => {
       });
-      this.startPolling();
-      this.client.session.prompt({
-        path: { id: sessionID },
+      await this.client.session.prompt({
+        path: { id: task.sessionID },
         body: {
-          agent: input.agent,
+          agent: task.agent,
           tools: {
-            // Prevent recursive task spawning from subagents
             delegate_task: false,
             get_task_result: false,
             list_tasks: false,
             cancel_task: false
           },
-          parts: [{ type: PART_TYPES.TEXT, text: input.prompt }]
+          parts: [{ type: PART_TYPES.TEXT, text: task.prompt }]
         }
-      }).catch((error45) => {
-        log(`Prompt error for ${taskId}:`, error45);
-        this.onTaskError(taskId, error45);
       });
-      const toastManager = getTaskToastManager();
-      if (toastManager) {
-        toastManager.addTask({
-          id: taskId,
-          description: input.description,
-          agent: input.agent,
-          isBackground: true,
-          parentSessionID: input.parentSessionID,
-          sessionID
-        });
-      }
-      presets.sessionCreated(sessionID, input.agent);
-      log(`Launched ${taskId} in session ${sessionID}`);
-      return task;
+      log(`[task-launcher.ts] Task ${task.id} (${task.agent}) started running`);
     } catch (error45) {
-      this.concurrency.release(concurrencyKey);
+      this.concurrency.release(task.agent);
       throw error45;
     }
   }
@@ -17116,6 +17190,7 @@ var TaskPoller = class {
       const allStatuses = statusResult.data ?? {};
       for (const task of running) {
         try {
+          if (task.status === TASK_STATUS.PENDING) continue;
           const sessionStatus = allStatuses[task.sessionID];
           if (sessionStatus?.type === SESSION_STATUS.IDLE) {
             const elapsed2 = Date.now() - task.startedAt.getTime();
@@ -17468,9 +17543,9 @@ var ParallelAgentManager = class _ParallelAgentManager {
   // ========================================================================
   // Public API
   // ========================================================================
-  async launch(input) {
+  async launch(inputs) {
     this.cleaner.pruneExpiredTasks();
-    return this.launcher.launch(input);
+    return this.launcher.launch(inputs);
   }
   async resume(input) {
     return this.resumer.resume(input);
@@ -17761,15 +17836,28 @@ var createDelegateTaskTool = (manager, client) => tool({
     }
     if (resume) {
       try {
-        const task = await manager.resume({
+        const input = {
           sessionId: resume,
           prompt,
-          parentSessionID: ctx.sessionID
-        });
+          parentSessionID: ctx.sessionID,
+          agent,
+          // Assuming agent is needed for resume context
+          description
+          // Assuming description is needed for resume context
+        };
+        const launchResult = await manager.launch(input);
+        const task = Array.isArray(launchResult) ? launchResult[0] : launchResult;
+        if (!task) {
+          return `Failed to launch task: ${input.description}`;
+        }
+        const taskId = task.id;
         if (background === true) {
-          return `${OUTPUT_LABEL.RESUME} task: \`${task.id}\` (${task.agent}) in session \`${task.sessionID}\`
+          const message = `Launched ${input.agent} task: ${input.description}
+Task ID: ${taskId}
+Session: ${task.sessionID}`;
+          return `${OUTPUT_LABEL.RESUME} task: \`${taskId}\` (${task.agent}) in session \`${task.sessionID}\`
 
-Previous context preserved. Use \`get_task_result({ taskId: "${task.id}" })\` when complete.`;
+Previous context preserved. Use \`get_task_result({ taskId: "${taskId}" })\` when complete.`;
         }
         const startTime = Date.now();
         const session = sessionClient.session;
@@ -17789,12 +17877,13 @@ ${text || "(No output)"}`;
     }
     if (background === true) {
       try {
-        const task = await manager.launch({
+        const launchResult = await manager.launch({
           agent,
           description,
           prompt,
           parentSessionID: ctx.sessionID
         });
+        const task = Array.isArray(launchResult) ? launchResult[0] : launchResult;
         presets.taskStarted(task.id, agent);
         return `${OUTPUT_LABEL.SPAWNED} task: \`${task.id}\` (${agent})
 Session: \`${task.sessionID}\` (save for resume)`;
@@ -18841,10 +18930,10 @@ async function resolveCommandPath(key, commandName) {
   const currentPending = pending.get(key);
   if (currentPending) return currentPending;
   const promise2 = (async () => {
-    const path5 = await findCommand(commandName);
-    cache[key] = path5;
+    const path6 = await findCommand(commandName);
+    cache[key] = path6;
     pending.delete(key);
-    return path5;
+    return path6;
   })();
   pending.set(key, promise2);
   return promise2;
@@ -18903,21 +18992,21 @@ import { exec as exec2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 var execAsync2 = promisify2(exec2);
 async function notifyDarwin(title, message) {
-  const path5 = await resolveCommandPath(
+  const path6 = await resolveCommandPath(
     NOTIFICATION_COMMAND_KEYS.OSASCRIPT,
     NOTIFICATION_COMMANDS.OSASCRIPT
   );
-  if (!path5) return;
+  if (!path6) return;
   const escT = title.replace(/"/g, '\\"');
   const escM = message.replace(/"/g, '\\"');
-  await execAsync2(`${path5} -e 'display notification "${escM}" with title "${escT}" sound name "Glass"'`);
+  await execAsync2(`${path6} -e 'display notification "${escM}" with title "${escT}" sound name "Glass"'`);
 }
 async function notifyLinux(title, message) {
-  const path5 = await resolveCommandPath(
+  const path6 = await resolveCommandPath(
     NOTIFICATION_COMMAND_KEYS.NOTIFY_SEND,
     NOTIFICATION_COMMANDS.NOTIFY_SEND
   );
-  if (path5) await execAsync2(`${path5} "${title}" "${message}" 2>/dev/null`);
+  if (path6) await execAsync2(`${path6} "${title}" "${message}" 2>/dev/null`);
 }
 async function notifyWindows(title, message) {
   const ps = await resolveCommandPath(
@@ -18963,11 +19052,11 @@ import { exec as exec3 } from "node:child_process";
 async function playDarwin(soundPath) {
   if (!soundPath) return;
   try {
-    const path5 = await resolveCommandPath(
+    const path6 = await resolveCommandPath(
       NOTIFICATION_COMMAND_KEYS.AFPLAY,
       NOTIFICATION_COMMANDS.AFPLAY
     );
-    if (path5) exec3(`"${path5}" "${soundPath}"`);
+    if (path6) exec3(`"${path6}" "${soundPath}"`);
   } catch (err) {
     log(`[session-notify] Error playing sound (Darwin): ${err}`);
   }
@@ -20237,10 +20326,65 @@ function createEventHandler(ctx) {
   };
 }
 
+// src/utils/compatibility/claude.ts
+import fs6 from "fs";
+import path5 from "path";
+function findClaudeRules(startDir = process.cwd()) {
+  try {
+    let currentDir = startDir;
+    const root = path5.parse(startDir).root;
+    while (true) {
+      const claudeMdPath = path5.join(currentDir, "CLAUDE.md");
+      if (fs6.existsSync(claudeMdPath)) {
+        try {
+          const content = fs6.readFileSync(claudeMdPath, "utf-8");
+          log(`[compatibility] Loaded CLAUDE.md from ${claudeMdPath}`);
+          return formatRules("CLAUDE.md", content);
+        } catch (e) {
+          log(`[compatibility] Error reading CLAUDE.md: ${e}`);
+        }
+      }
+      if (currentDir === root) break;
+      currentDir = path5.dirname(currentDir);
+    }
+    const copilotPath = path5.join(startDir, ".github", "copilot-instructions.md");
+    if (fs6.existsSync(copilotPath)) {
+      return formatRules("Copilot Instructions", fs6.readFileSync(copilotPath, "utf-8"));
+    }
+    return null;
+  } catch (error45) {
+    log(`[compatibility] Error finding Claude rules: ${error45}`);
+    return null;
+  }
+}
+function formatRules(source, content) {
+  return `
+<project_rules source="${source}">
+${content}
+</project_rules>
+
+<claude_compatibility>
+These rules are from the project's ${source}. 
+You MUST follow them as strictly as if they were your system prompt.
+This plugin runs in "Claude Code Compatibility Mode".
+</claude_compatibility>
+`;
+}
+
 // src/plugin-handlers/config-handler.ts
 function createConfigHandler() {
-  const commanderPrompt = AGENTS[AGENT_NAMES.COMMANDER]?.systemPrompt || "";
   return async (config2) => {
+    const claudeRules = findClaudeRules();
+    const injectRules = (prompt) => {
+      if (!claudeRules) return prompt;
+      return `${prompt}
+
+${claudeRules}`;
+    };
+    const commanderPrompt = injectRules(AGENTS[AGENT_NAMES.COMMANDER]?.systemPrompt || "");
+    const plannerPrompt = injectRules(AGENTS[AGENT_NAMES.PLANNER]?.systemPrompt || "");
+    const workerPrompt = injectRules(AGENTS[AGENT_NAMES.WORKER]?.systemPrompt || "");
+    const reviewerPrompt = injectRules(AGENTS[AGENT_NAMES.REVIEWER]?.systemPrompt || "");
     const existingCommands = config2.command ?? {};
     const existingAgents = config2.agent ?? {};
     const orchestratorCommands = {};
@@ -20266,7 +20410,7 @@ function createConfigHandler() {
         description: "Strategic planning and research specialist",
         mode: "subagent",
         hidden: true,
-        prompt: AGENTS[AGENT_NAMES.PLANNER]?.systemPrompt || "",
+        prompt: plannerPrompt,
         maxTokens: AGENT_TOKENS.SUBAGENT_MAX_TOKENS,
         color: "#9B59B6"
       },
@@ -20274,7 +20418,7 @@ function createConfigHandler() {
         description: "Implementation and documentation specialist",
         mode: "subagent",
         hidden: true,
-        prompt: AGENTS[AGENT_NAMES.WORKER]?.systemPrompt || "",
+        prompt: workerPrompt,
         maxTokens: AGENT_TOKENS.SUBAGENT_MAX_TOKENS,
         color: "#E67E22"
       },
@@ -20282,7 +20426,7 @@ function createConfigHandler() {
         description: "Verification and context management specialist",
         mode: "subagent",
         hidden: true,
-        prompt: AGENTS[AGENT_NAMES.REVIEWER]?.systemPrompt || "",
+        prompt: reviewerPrompt,
         maxTokens: AGENT_TOKENS.SUBAGENT_MAX_TOKENS,
         color: "#27AE60"
       }

package/dist/shared/task/constants/parallel-task.d.ts

@@ -8,11 +8,11 @@ export declare const PARALLEL_TASK: {
     readonly DEFAULT_CONCURRENCY: 3;
     readonly MAX_CONCURRENCY: 10;
     readonly SYNC_TIMEOUT_MS: number;
-    readonly POLL_INTERVAL_MS: 500;
+    readonly POLL_INTERVAL_MS: 2000;
     readonly MIN_IDLE_TIME_MS: number;
     readonly MIN_STABILITY_MS: number;
-    readonly STABLE_POLLS_REQUIRED: 3;
-    readonly MAX_POLL_COUNT: 600;
+    readonly STABLE_POLLS_REQUIRED: 2;
+    readonly MAX_POLL_COUNT: 150;
     readonly SESSION_TITLE_PREFIX: "Parallel";
     readonly LABEL: "parallel";
     readonly GROUP_PREFIX: "parallel:";

package/dist/utils/compatibility/claude.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Find and read CLAUDE.md guidelines.
+ * Follows Claude Code's discovery logic:
+ * 1. CLAUDE.md in current directory or parents
+ * 2. .github/instructions/ *.md (checking main ones)
+ * 3. .cursor/rules/ *.md
+ * 4. .claude/rules/ *.md
+ */
+export declare function findClaudeRules(startDir?: string): string | null;

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.0.5",
+  "version": "1.0.7",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {