opencode-orchestrator 1.2.11 → 1.2.13

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

@@ -5,3 +5,4 @@ export * from "./types/index.js";
 export * from "./interfaces/index.js";
 export { ConcurrencyController } from "./concurrency.js";
 export { ParallelAgentManager, parallelAgentManager } from "./manager.js";
+export { taskWAL } from "./persistence/task-wal.js";

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

@@ -15,6 +15,7 @@ export declare class TaskPoller {
     private pruneExpiredTasks;
     private onTaskComplete?;
     private pollingInterval?;
+    private messageCache;
     constructor(client: OpencodeClient, store: TaskStore, concurrency: ConcurrencyController, notifyParentIfAllComplete: (parentSessionID: string) => Promise<void>, scheduleCleanup: (taskId: string) => void, pruneExpiredTasks: () => void, onTaskComplete?: ((task: ParallelTask) => void | Promise<void>) | undefined);
     start(): void;
     stop(): void;

package/dist/core/cleanup/cleanup-scheduler.d.ts

@@ -0,0 +1,11 @@
+export declare class CleanupScheduler {
+    private intervals;
+    private directory;
+    constructor(directory: string);
+    start(): void;
+    private schedule;
+    stop(): void;
+    compactWAL(): Promise<void>;
+    cleanDocs(): Promise<void>;
+    rotateHistory(): Promise<void>;
+}

package/dist/core/notification/task-toast-manager.d.ts

@@ -13,12 +13,14 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { ConcurrencyController } from "../agents/concurrency.js";
 import { type TaskStatus, type TrackedTask, type TaskCompletionInfo } from "../../shared/index.js";
+import type { TodoSyncService } from "../sync/todo-sync-service.js";
 export type { TaskStatus, TrackedTask, TaskCompletionInfo } from "../../shared/index.js";
 type OpencodeClient = PluginInput["client"];
 export declare class TaskToastManager {
     private tasks;
     private client;
     private concurrency;
+    private todoSync;
     /**
      * Initialize the manager with OpenCode client
      */
@@ -27,6 +29,10 @@ export declare class TaskToastManager {
      * Set concurrency controller (can be set after init)
      */
     setConcurrencyController(concurrency: ConcurrencyController): void;
+    /**
+     * Set TodoSyncService for TUI status synchronization
+     */
+    setTodoSync(service: TodoSyncService): void;
     /**
      * Add a new task and show consolidated toast
      */

package/dist/core/sync/todo-parser.d.ts

@@ -0,0 +1,5 @@
+import { type Todo } from "../../shared/index.js";
+/**
+ * Parses markdown content into Todo objects
+ */
+export declare function parseTodoMd(content: string): Todo[];

package/dist/core/sync/todo-sync-service.d.ts

@@ -0,0 +1,35 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+interface TrackedTaskTodo {
+    id: string;
+    description: string;
+    status: string;
+    agent: string;
+    isBackground: boolean;
+    parentSessionID?: string;
+}
+export declare class TodoSyncService {
+    private client;
+    private directory;
+    private todoPath;
+    private fileTodos;
+    private taskTodos;
+    private updateTimeout;
+    private watcher;
+    private activeSessions;
+    constructor(client: OpencodeClient, directory: string);
+    start(): Promise<void>;
+    registerSession(sessionID: string): void;
+    unregisterSession(sessionID: string): void;
+    private reloadFileTodos;
+    /**
+     * Called by TaskToastManager when tasks change
+     */
+    updateTaskStatus(task: TrackedTaskTodo): void;
+    removeTask(taskId: string): void;
+    private broadcastUpdate;
+    private scheduleUpdate;
+    private sendTodosToSession;
+    stop(): void;
+}
+export {};

package/dist/index.js

@@ -5978,15 +5978,15 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path10) {
-  if (!path10)
+function getElementAtPath(obj, path12) {
+  if (!path12)
     return obj;
-  return path10.reduce((acc, key) => acc?.[key], obj);
+  return path12.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises2 = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises2).then((results) => {
+  const promises4 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises4).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -6342,11 +6342,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path10, issues) {
+function prefixIssues(path12, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path10);
+    iss.path.unshift(path12);
     return iss;
   });
 }
@@ -6514,7 +6514,7 @@ function treeifyError(error92, _mapper) {
     return issue3.message;
   };
   const result = { errors: [] };
-  const processError = (error93, path10 = []) => {
+  const processError = (error93, path12 = []) => {
     var _a2, _b;
     for (const issue3 of error93.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
@@ -6524,7 +6524,7 @@ function treeifyError(error92, _mapper) {
       } else if (issue3.code === "invalid_element") {
         processError({ issues: issue3.issues }, issue3.path);
       } else {
-        const fullpath = [...path10, ...issue3.path];
+        const fullpath = [...path12, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -6556,8 +6556,8 @@ function treeifyError(error92, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path10) {
+  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path12) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18829,6 +18829,7 @@ var TaskToastManager = class {
   tasks = /* @__PURE__ */ new Map();
   client = null;
   concurrency = null;
+  todoSync = null;
   /**
    * Initialize the manager with OpenCode client
    */
@@ -18842,6 +18843,12 @@ var TaskToastManager = class {
   setConcurrencyController(concurrency) {
     this.concurrency = concurrency;
   }
+  /**
+   * Set TodoSyncService for TUI status synchronization
+   */
+  setTodoSync(service) {
+    this.todoSync = service;
+  }
   /**
    * Add a new task and show consolidated toast
    */
@@ -18857,6 +18864,7 @@ var TaskToastManager = class {
       sessionID: task.sessionID
     };
     this.tasks.set(task.id, trackedTask);
+    this.todoSync?.updateTaskStatus(trackedTask);
     this.showTaskListToast(trackedTask);
   }
   /**
@@ -18866,6 +18874,7 @@ var TaskToastManager = class {
     const task = this.tasks.get(id);
     if (task) {
       task.status = status;
+      this.todoSync?.updateTaskStatus(task);
     }
   }
   /**
@@ -18873,6 +18882,7 @@ var TaskToastManager = class {
    */
   removeTask(id) {
     this.tasks.delete(id);
+    this.todoSync?.removeTask(id);
   }
   /**
    * Get all running tasks (newest first)
@@ -20215,15 +20225,15 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema) {
   return mergeDefs2(schema._zod.def);
 }
-function getElementAtPath2(obj, path10) {
-  if (!path10)
+function getElementAtPath2(obj, path12) {
+  if (!path12)
     return obj;
-  return path10.reduce((acc, key) => acc?.[key], obj);
+  return path12.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises2 = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises2).then((results) => {
+  const promises4 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises4).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -20601,11 +20611,11 @@ function aborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path10, issues) {
+function prefixIssues2(path12, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path10);
+    iss.path.unshift(path12);
     return iss;
   });
 }
@@ -20788,7 +20798,7 @@ function formatError2(error92, mapper = (issue3) => issue3.message) {
 }
 function treeifyError2(error92, mapper = (issue3) => issue3.message) {
   const result = { errors: [] };
-  const processError = (error93, path10 = []) => {
+  const processError = (error93, path12 = []) => {
     var _a2, _b;
     for (const issue3 of error93.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
@@ -20798,7 +20808,7 @@ function treeifyError2(error92, mapper = (issue3) => issue3.message) {
       } else if (issue3.code === "invalid_element") {
         processError({ issues: issue3.issues }, issue3.path);
       } else {
-        const fullpath = [...path10, ...issue3.path];
+        const fullpath = [...path12, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -20830,8 +20840,8 @@ function treeifyError2(error92, mapper = (issue3) => issue3.message) {
 }
 function toDotPath2(_path) {
   const segs = [];
-  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path10) {
+  const path12 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path12) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -32808,13 +32818,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path10 = ref.slice(1).split("/").filter(Boolean);
-  if (path10.length === 0) {
+  const path12 = ref.slice(1).split("/").filter(Boolean);
+  if (path12.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path10[0] === defsKey) {
-    const key = path10[1];
+  if (path12[0] === defsKey) {
+    const key = path12[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -33625,6 +33635,7 @@ var TaskPoller = class {
     this.onTaskComplete = onTaskComplete;
   }
   pollingInterval;
+  messageCache = /* @__PURE__ */ new Map();
   start() {
     if (this.pollingInterval) return;
     log("[task-poller.ts] start() - polling started");
@@ -33717,7 +33728,16 @@ var TaskPoller = class {
   }
   async updateTaskProgress(task) {
     try {
+      const cached3 = this.messageCache.get(task.sessionID);
+      const statusResult = await this.client.session.status();
+      const sessionInfo = statusResult.data?.[task.sessionID];
+      const currentMsgCount = sessionInfo?.messageCount ?? 0;
+      if (cached3 && cached3.count === currentMsgCount) {
+        task.stablePolls = (task.stablePolls ?? 0) + 1;
+        return;
+      }
       const result = await this.client.session.messages({ path: { id: task.sessionID } });
+      this.messageCache.set(task.sessionID, { count: currentMsgCount, lastChecked: /* @__PURE__ */ new Date() });
       if (result.error) return;
       const messages = result.data ?? [];
       const assistantMsgs = messages.filter((m) => m.info?.role === MESSAGE_ROLES.ASSISTANT);
@@ -33741,9 +33761,8 @@ var TaskPoller = class {
         lastMessage: lastMessage?.slice(0, 100),
         lastUpdate: /* @__PURE__ */ new Date()
       };
-      const currentMsgCount = messages.length;
       if (task.lastMsgCount === currentMsgCount) {
-        task.stablePolls = (task.stablePolls ?? 0) + 1;
+        task.stablePolls = 0;
       } else {
         task.stablePolls = 0;
       }
@@ -37135,10 +37154,10 @@ async function resolveCommandPath(key, commandName) {
   const currentPending = pending.get(key);
   if (currentPending) return currentPending;
   const promise3 = (async () => {
-    const path10 = await findCommand(commandName);
-    cache[key] = path10;
+    const path12 = await findCommand(commandName);
+    cache[key] = path12;
     pending.delete(key);
-    return path10;
+    return path12;
   })();
   pending.set(key, promise3);
   return promise3;
@@ -37147,21 +37166,21 @@ async function resolveCommandPath(key, commandName) {
 // src/core/notification/os-notify/notifier.ts
 var execAsync2 = promisify2(exec2);
 async function notifyDarwin(title, message) {
-  const path10 = await resolveCommandPath(
+  const path12 = await resolveCommandPath(
     NOTIFICATION_COMMAND_KEYS.OSASCRIPT,
     NOTIFICATION_COMMANDS.OSASCRIPT
   );
-  if (!path10) return;
+  if (!path12) return;
   const escT = title.replace(/"/g, '\\"');
   const escM = message.replace(/"/g, '\\"');
-  await execAsync2(`${path10} -e 'display notification "${escM}" with title "${escT}" sound name "Glass"'`);
+  await execAsync2(`${path12} -e 'display notification "${escM}" with title "${escT}" sound name "Glass"'`);
 }
 async function notifyLinux(title, message) {
-  const path10 = await resolveCommandPath(
+  const path12 = await resolveCommandPath(
     NOTIFICATION_COMMAND_KEYS.NOTIFY_SEND,
     NOTIFICATION_COMMANDS.NOTIFY_SEND
   );
-  if (path10) await execAsync2(`${path10} "${title}" "${message}" 2>/dev/null`);
+  if (path12) await execAsync2(`${path12} "${title}" "${message}" 2>/dev/null`);
 }
 async function notifyWindows(title, message) {
   const ps = await resolveCommandPath(
@@ -37208,11 +37227,11 @@ init_os();
 async function playDarwin(soundPath) {
   if (!soundPath) return;
   try {
-    const path10 = await resolveCommandPath(
+    const path12 = await resolveCommandPath(
       NOTIFICATION_COMMAND_KEYS.AFPLAY,
       NOTIFICATION_COMMANDS.AFPLAY
     );
-    if (path10) exec3(`"${path10}" "${soundPath}"`);
+    if (path12) exec3(`"${path12}" "${soundPath}"`);
   } catch (err) {
     log(`[session-notify] Error playing sound (Darwin): ${err}`);
   }
@@ -38364,6 +38383,265 @@ var PluginManager = class _PluginManager {
   }
 };
 
+// src/core/sync/todo-sync-service.ts
+init_shared();
+import * as fs10 from "node:fs";
+import * as path9 from "node:path";
+
+// src/core/sync/todo-parser.ts
+function parseTodoMd(content) {
+  const lines = content.split("\n");
+  const todos = [];
+  const generateId = (text, index2) => {
+    return `file-task-${index2}-${text.substring(0, 10).replace(/[^a-zA-Z0-9]/g, "")}`;
+  };
+  let index = 0;
+  for (const line of lines) {
+    const match = line.match(/^\s*-\s*\[([ xX\/\-\.])\]\s*(.+)$/);
+    if (match) {
+      const [, statusChar, text] = match;
+      const content2 = text.trim();
+      let status = "pending";
+      switch (statusChar.toLowerCase()) {
+        case "x":
+          status = "completed";
+          break;
+        case "/":
+        case ".":
+          status = "in_progress";
+          break;
+        case "-":
+          status = "cancelled";
+          break;
+        case " ":
+        default:
+          status = "pending";
+          break;
+      }
+      todos.push({
+        id: generateId(content2, index),
+        content: content2,
+        status,
+        priority: "medium",
+        // Default priority for file items
+        createdAt: /* @__PURE__ */ new Date()
+      });
+      index++;
+    }
+  }
+  return todos;
+}
+
+// src/core/sync/todo-sync-service.ts
+var TodoSyncService = class {
+  client;
+  directory;
+  todoPath;
+  fileTodos = [];
+  taskTodos = /* @__PURE__ */ new Map();
+  updateTimeout = null;
+  watcher = null;
+  // We only want to sync to the "primary" session or all sessions?
+  // The design says `syncTaskStore(sessionID)`.
+  // Usually TUI TODO is per session.
+  // However, `todo.md` is global (project level).
+  // So we should probably broadcast to active sessions or just the one associated with the tasks?
+  // Current TUI limitation: we might need to know which session to update.
+  // For TUI sidebar, we usually update the session the user is looking at.
+  // But we don't know that.
+  // We will maintain a set of "active sessions" provided by index.ts or just update relevant ones.
+  // For Phase 1, we might just update the sessions we know about (parents of tasks) or register sessions.
+  activeSessions = /* @__PURE__ */ new Set();
+  constructor(client, directory) {
+    this.client = client;
+    this.directory = directory;
+    this.todoPath = path9.join(this.directory, PATHS.TODO);
+  }
+  async start() {
+    await this.reloadFileTodos();
+    if (fs10.existsSync(this.todoPath)) {
+      let timer;
+      this.watcher = fs10.watch(this.todoPath, (eventType) => {
+        if (eventType === "change" || eventType === "rename") {
+          clearTimeout(timer);
+          timer = setTimeout(() => {
+            this.reloadFileTodos().catch((err) => log(`[TodoSync] Error reloading: ${err}`));
+          }, 500);
+        }
+      });
+    }
+  }
+  registerSession(sessionID) {
+    this.activeSessions.add(sessionID);
+    this.scheduleUpdate(sessionID);
+  }
+  unregisterSession(sessionID) {
+    this.activeSessions.delete(sessionID);
+  }
+  async reloadFileTodos() {
+    try {
+      if (fs10.existsSync(this.todoPath)) {
+        const content = await fs10.promises.readFile(this.todoPath, "utf-8");
+        this.fileTodos = parseTodoMd(content);
+        this.broadcastUpdate();
+      }
+    } catch (error92) {
+      log(`[TodoSync] Failed to read todo.md: ${error92}`);
+    }
+  }
+  /**
+   * Called by TaskToastManager when tasks change
+   */
+  updateTaskStatus(task) {
+    this.taskTodos.set(task.id, task);
+    if (task.parentSessionID) {
+      this.scheduleUpdate(task.parentSessionID);
+    } else {
+      this.broadcastUpdate();
+    }
+  }
+  removeTask(taskId) {
+    const task = this.taskTodos.get(taskId);
+    if (task) {
+      this.taskTodos.delete(taskId);
+      if (task.parentSessionID) {
+        this.scheduleUpdate(task.parentSessionID);
+      } else {
+        this.broadcastUpdate();
+      }
+    }
+  }
+  broadcastUpdate() {
+    for (const sessionID of this.activeSessions) {
+      this.scheduleUpdate(sessionID);
+    }
+  }
+  scheduleUpdate(sessionID) {
+    this.sendTodosToSession(sessionID).catch((err) => {
+    });
+  }
+  async sendTodosToSession(sessionID) {
+    const taskTodosList = Array.from(this.taskTodos.values()).map((t) => {
+      let status = "pending";
+      const s = t.status.toLowerCase();
+      if (s.includes("run") || s.includes("wait") || s.includes("que")) status = "in_progress";
+      else if (s.includes("complete") || s.includes("done")) status = "completed";
+      else if (s.includes("fail") || s.includes("error")) status = "cancelled";
+      else if (s.includes("cancel")) status = "cancelled";
+      return {
+        id: `task-${t.id}`,
+        // Prefix to avoid collision
+        content: `[${t.agent.toUpperCase()}] ${t.description}`,
+        status,
+        priority: t.isBackground ? "low" : "high",
+        createdAt: /* @__PURE__ */ new Date()
+      };
+    });
+    const merged = [
+      ...this.fileTodos,
+      ...taskTodosList
+    ];
+    try {
+      await this.client.session.todo({
+        path: { id: sessionID },
+        // Standardize to id
+        body: { todos: merged }
+      });
+    } catch (error92) {
+    }
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+    }
+  }
+};
+
+// src/core/cleanup/cleanup-scheduler.ts
+import * as fs11 from "node:fs";
+import * as path10 from "node:path";
+init_shared();
+var CleanupScheduler = class {
+  intervals = /* @__PURE__ */ new Map();
+  directory;
+  constructor(directory) {
+    this.directory = directory;
+  }
+  start() {
+    this.schedule("wal-compact", () => this.compactWAL(), 10 * 60 * 1e3);
+    this.schedule("docs-clean", () => this.cleanDocs(), 60 * 60 * 1e3);
+    this.schedule("history-rotate", () => this.rotateHistory(), 24 * 60 * 60 * 1e3);
+    log(`[Cleanup] Scheduler started`);
+  }
+  schedule(name, fn, intervalMs) {
+    const timer = setInterval(() => {
+      fn().catch((err) => log(`[Cleanup] ${name} failed:`, err));
+    }, intervalMs);
+    if (timer.unref) timer.unref();
+    this.intervals.set(name, timer);
+  }
+  stop() {
+    for (const timer of this.intervals.values()) {
+      clearInterval(timer);
+    }
+    this.intervals.clear();
+    log(`[Cleanup] Scheduler stopped`);
+  }
+  async compactWAL() {
+    try {
+      const manager = parallelAgentManager.getInstance();
+      const activeTasks = manager.getAllTasks().filter((t) => t.status === TASK_STATUS.RUNNING || t.status === TASK_STATUS.PENDING);
+      await taskWAL.compact(activeTasks);
+    } catch (error92) {
+      log(`[Cleanup] Failed to compact WAL: ${error92}`);
+    }
+  }
+  async cleanDocs() {
+    try {
+      const stats2 = await stats();
+      if (stats2.totalSize > 10 * 1024 * 1024) {
+        const allDocs = await list();
+        allDocs.sort((a, b) => new Date(a.fetchedAt).getTime() - new Date(b.fetchedAt).getTime());
+        const toDelete = allDocs.slice(0, Math.floor(allDocs.length / 2));
+        for (const doc of toDelete) {
+          await remove(doc.url);
+        }
+        log(`[Cleanup] Pruned ${toDelete.length} documents due to size limit`);
+      }
+    } catch (error92) {
+    }
+  }
+  async rotateHistory() {
+    try {
+      const historyPath = path10.join(this.directory, ".opencode/archive/todo_history.jsonl");
+      if (!fs11.existsSync(historyPath)) return;
+      const stat = await fs11.promises.stat(historyPath);
+      if (stat.size === 0) return;
+      const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      const archivePath = path10.join(
+        this.directory,
+        `.opencode/archive/todo_history.${dateStr}.jsonl`
+      );
+      await fs11.promises.rename(historyPath, archivePath);
+      await fs11.promises.writeFile(historyPath, "");
+      const archiveDir = path10.dirname(historyPath);
+      const files = await fs11.promises.readdir(archiveDir);
+      const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1e3;
+      for (const file3 of files) {
+        if (file3.startsWith("todo_history.") && file3.endsWith(".jsonl")) {
+          const filePath = path10.join(archiveDir, file3);
+          const fStat = await fs11.promises.stat(filePath);
+          if (fStat.mtimeMs < cutoff) {
+            await fs11.promises.unlink(filePath);
+          }
+        }
+      }
+    } catch (error92) {
+      log(`[Cleanup] History rotation error: ${error92}`);
+    }
+  }
+};
+
 // src/plugin-handlers/tool-execute-pre-handler.ts
 function createToolExecuteBeforeHandler(ctx) {
   const { sessions, directory } = ctx;
@@ -38427,17 +38705,17 @@ function createChatMessageHandler(ctx) {
 init_shared();
 
 // src/utils/compatibility/claude.ts
-import fs10 from "fs";
-import path9 from "path";
+import fs12 from "fs";
+import path11 from "path";
 function findClaudeRules(startDir = process.cwd()) {
   try {
     let currentDir = startDir;
-    const root = path9.parse(startDir).root;
+    const root = path11.parse(startDir).root;
     while (true) {
-      const claudeMdPath = path9.join(currentDir, "CLAUDE.md");
-      if (fs10.existsSync(claudeMdPath)) {
+      const claudeMdPath = path11.join(currentDir, "CLAUDE.md");
+      if (fs12.existsSync(claudeMdPath)) {
         try {
-          const content = fs10.readFileSync(claudeMdPath, "utf-8");
+          const content = fs12.readFileSync(claudeMdPath, "utf-8");
           log(`[compatibility] Loaded CLAUDE.md from ${claudeMdPath}`);
           return formatRules("CLAUDE.md", content);
         } catch (e) {
@@ -38445,11 +38723,11 @@ function findClaudeRules(startDir = process.cwd()) {
         }
       }
       if (currentDir === root) break;
-      currentDir = path9.dirname(currentDir);
+      currentDir = path11.dirname(currentDir);
     }
-    const copilotPath = path9.join(startDir, ".github", "copilot-instructions.md");
-    if (fs10.existsSync(copilotPath)) {
-      return formatRules("Copilot Instructions", fs10.readFileSync(copilotPath, "utf-8"));
+    const copilotPath = path11.join(startDir, ".github", "copilot-instructions.md");
+    if (fs12.existsSync(copilotPath)) {
+      return formatRules("Copilot Instructions", fs12.readFileSync(copilotPath, "utf-8"));
     }
     return null;
   } catch (error92) {
@@ -39054,6 +39332,11 @@ var OrchestratorPlugin = async (input) => {
   await pluginManager.initialize(directory);
   const dynamicTools = pluginManager.getDynamicTools();
   taskToastManager.setConcurrencyController(parallelAgentManager2.getConcurrency());
+  const todoSync = new TodoSyncService(client, directory);
+  await todoSync.start();
+  taskToastManager.setTodoSync(todoSync);
+  const cleanupScheduler = new CleanupScheduler(directory);
+  cleanupScheduler.start();
   const handlerContext = {
     client,
     directory,
@@ -39110,7 +39393,20 @@ var OrchestratorPlugin = async (input) => {
     // -----------------------------------------------------------------
     // Event hook - handles OpenCode events
     // -----------------------------------------------------------------
-    event: createEventHandler(handlerContext),
+    // -----------------------------------------------------------------
+    // Event hook - handles OpenCode events
+    // -----------------------------------------------------------------
+    event: async (payload) => {
+      const result = await createEventHandler(handlerContext)(payload);
+      const { event } = payload;
+      if (event.type === "session.created" && event.properties) {
+        const sessionID = event.properties.sessionID || event.properties.id || event.properties.info?.sessionID;
+        if (sessionID) {
+          todoSync.registerSession(sessionID);
+        }
+      }
+      return result;
+    },
     // -----------------------------------------------------------------
     // chat.message hook - intercepts commands and sets up sessions
     // -----------------------------------------------------------------

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