openviber 0.4.3 → 0.5.1

package/dist/cli/index.js

@@ -35,10 +35,145 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // src/core/message.ts
-var ConversationHistory;
+var MessageQueue, ConversationHistory;
 var init_message = __esm({
   "src/core/message.ts"() {
     "use strict";
+    MessageQueue = class {
+      queue = [];
+      current;
+      processing = false;
+      listeners = /* @__PURE__ */ new Set();
+      nextId = 1;
+      /**
+       * Add message to queue
+       */
+      add(content, metadata) {
+        const message = {
+          id: `msg-${this.nextId++}`,
+          content,
+          status: "queued",
+          timestamp: Date.now(),
+          metadata
+        };
+        this.queue.push(message);
+        this.notify();
+        return message.id;
+      }
+      /**
+       * Get next message from queue
+       */
+      next() {
+        const message = this.queue.shift();
+        if (message) {
+          message.status = "processing";
+          this.current = message;
+          this.processing = true;
+          this.notify();
+        }
+        return message;
+      }
+      /**
+       * Mark current message as complete
+       */
+      complete(messageId) {
+        if (this.current?.id === messageId) {
+          this.current.status = "completed";
+          this.current = void 0;
+          this.processing = false;
+          this.notify();
+        }
+      }
+      /**
+       * Mark current message as error
+       */
+      error(messageId, error) {
+        if (this.current?.id === messageId) {
+          this.current.status = "error";
+          this.current.error = error;
+          this.current = void 0;
+          this.processing = false;
+          this.notify();
+        }
+      }
+      /**
+       * Remove message from queue
+       */
+      remove(messageId) {
+        const index = this.queue.findIndex((m) => m.id === messageId);
+        if (index > -1) {
+          this.queue.splice(index, 1);
+          this.notify();
+          return true;
+        }
+        return false;
+      }
+      /**
+       * Reorder queue
+       */
+      reorder(messageId, newIndex) {
+        const currentIndex = this.queue.findIndex((m) => m.id === messageId);
+        if (currentIndex > -1 && newIndex >= 0 && newIndex < this.queue.length) {
+          const [message] = this.queue.splice(currentIndex, 1);
+          this.queue.splice(newIndex, 0, message);
+          this.notify();
+        }
+      }
+      /**
+       * Edit queued message
+       */
+      edit(messageId, content) {
+        const message = this.queue.find((m) => m.id === messageId);
+        if (message && message.status === "queued") {
+          message.content = content;
+          message.edited = true;
+          this.notify();
+        }
+      }
+      /**
+       * Clear all queued messages
+       */
+      clear() {
+        this.queue = [];
+        this.notify();
+      }
+      /**
+       * Get queue state
+       */
+      getState() {
+        return {
+          current: this.current,
+          queue: [...this.queue],
+          processing: this.processing
+        };
+      }
+      /**
+       * Subscribe to queue changes
+       */
+      subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+      }
+      /**
+       * Check if queue is empty
+       */
+      isEmpty() {
+        return this.queue.length === 0;
+      }
+      /**
+       * Check if processing
+       */
+      isProcessing() {
+        return this.processing;
+      }
+      /**
+       * Notify listeners
+       */
+      notify() {
+        const state = this.getState();
+        this.listeners.forEach((listener) => listener(state));
+      }
+    };
     ConversationHistory = class {
       messages = [];
       add(message) {
@@ -4178,21 +4313,38 @@ import * as path8 from "path";
 import * as yaml2 from "yaml";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getDefaultSkillsPath() {
-  const cwdPath = path8.resolve(process.cwd(), "src/skills");
+  const userSkillsPath = path8.join(getViberRoot(), "skills");
   try {
-    fsSync.accessSync(cwdPath);
-    console.log(`[SkillRegistry] Using skills path (cwd): ${cwdPath}`);
-    return cwdPath;
+    fsSync.accessSync(userSkillsPath);
+    console.log(`[SkillRegistry] Using skills path (user): ${userSkillsPath}`);
+    return userSkillsPath;
   } catch {
-    const relativePath = path8.resolve(__dirname2, ".");
+    const bundledPath = path8.resolve(__dirname2, ".");
+    try {
+      fsSync.accessSync(bundledPath);
+      const hasSkillDirs = fsSync.readdirSync(bundledPath).some((f) => {
+        const skillMd = path8.join(bundledPath, f, "SKILL.md");
+        try {
+          fsSync.accessSync(skillMd);
+          return true;
+        } catch {
+          return false;
+        }
+      });
+      if (hasSkillDirs) {
+        console.log(`[SkillRegistry] Using skills path (bundled): ${bundledPath}`);
+        return bundledPath;
+      }
+    } catch {
+    }
+    const devPath = path8.resolve(process.cwd(), "src/skills");
     try {
-      fsSync.accessSync(relativePath);
-      console.log(`[SkillRegistry] Using skills path (relative): ${relativePath}`);
-      return relativePath;
+      fsSync.accessSync(devPath);
+      console.log(`[SkillRegistry] Using skills path (dev): ${devPath}`);
+      return devPath;
     } catch {
-      const viberPath = path8.join(getViberRoot(), "skills");
-      console.log(`[SkillRegistry] Using skills path (viber root): ${viberPath}`);
-      return viberPath;
+      console.log(`[SkillRegistry] Using skills path (default): ${userSkillsPath}`);
+      return userSkillsPath;
     }
   }
 }
@@ -4875,50 +5027,20 @@ var init_runtime = __esm({
 });
 
 // src/daemon/terminal.ts
-import { spawn, execSync } from "child_process";
+import { spawn, spawnSync, execSync } from "child_process";
 import { EventEmitter } from "events";
-function listSessions() {
-  try {
-    const out = execSync(
-      "tmux list-sessions -F '#{session_name}|#{session_windows}|#{session_attached}' 2>/dev/null",
-      { encoding: "utf8", stdio: "pipe" }
-    ).trim();
-    if (!out) return [];
-    return out.split("\n").map((line) => {
-      const [name, windows, attached] = line.split("|");
-      return {
-        name,
-        windows: parseInt(windows, 10) || 0,
-        attached: attached === "1"
-      };
-    });
-  } catch {
-    return [];
-  }
+import { randomUUID } from "crypto";
+function sanitizeName(input) {
+  return input.replace(SAFE_NAME_RE, "-");
 }
-function listPanes() {
-  try {
-    const out = execSync(
-      "tmux list-panes -a -F '#{session_name}|#{window_index}|#{window_name}|#{pane_index}|#{pane_current_command}' 2>/dev/null",
-      { encoding: "utf8", stdio: "pipe" }
-    ).trim();
-    if (!out) return [];
-    return out.split("\n").map((line) => {
-      const [session, window2, windowName, pane, command] = line.split("|");
-      return {
-        session,
-        window: window2,
-        windowName,
-        pane,
-        command,
-        target: `${session}:${window2}.${pane}`
-      };
-    });
-  } catch {
-    return [];
+function resolveAppTarget(target, appHint) {
+  if (target.includes("::")) {
+    const [appId, ...rest] = target.split("::");
+    return { appId, rawTarget: rest.join("::") };
   }
+  return { appId: appHint || "tmux", rawTarget: target };
 }
-function sendKeys(target, keys, pressEnter = false) {
+function sendTmuxKeys(target, keys, pressEnter = false) {
   try {
     const args = ["send-keys", "-t", target, keys];
     if (pressEnter) args.push("Enter");
@@ -4931,7 +5053,7 @@ function sendKeys(target, keys, pressEnter = false) {
     return false;
   }
 }
-function capturePane(target, lines = 500) {
+function captureTmuxPane(target, lines = 500) {
   const cmds = [
     `tmux capture-pane -t '${target}' -pae -S -${lines}`,
     `tmux capture-pane -t '${target}' -pe -S -${lines}`
@@ -4944,38 +5066,24 @@ function capturePane(target, lines = 500) {
   }
   return "";
 }
-function resizePane(target, cols, rows) {
-  try {
-    execSync(`tmux resize-pane -t '${target}' -x ${cols} -y ${rows}`, {
-      encoding: "utf8",
-      stdio: "pipe"
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-var TerminalStream, TerminalManager;
+var SAFE_NAME_RE, TmuxTerminalStream, TmuxTerminalApp, ShellTerminalApp, TerminalManager;
 var init_terminal = __esm({
   "src/daemon/terminal.ts"() {
     "use strict";
-    TerminalStream = class extends EventEmitter {
-      target;
-      catProcess = null;
-      pipePath;
-      isAttached = false;
+    SAFE_NAME_RE = /[^a-zA-Z0-9_.:-]/g;
+    TmuxTerminalStream = class extends EventEmitter {
       constructor(target) {
         super();
         this.target = target;
         this.pipePath = `/tmp/viber-term-${target.replace(/[^a-zA-Z0-9]/g, "-")}-${Date.now()}`;
       }
-      /**
-       * Start streaming the pane output
-       */
+      catProcess = null;
+      pipePath;
+      isAttached = false;
       async attach() {
         if (this.isAttached) return true;
         try {
-          const history = capturePane(this.target, 200);
+          const history = captureTmuxPane(this.target, 200);
           if (history) {
             this.emit("data", history);
           }
@@ -5005,9 +5113,6 @@ var init_terminal = __esm({
           return false;
         }
       }
-      /**
-       * Stop streaming
-       */
       detach() {
         if (!this.isAttached) return;
         try {
@@ -5016,12 +5121,6 @@ var init_terminal = __esm({
         }
         this.cleanup();
       }
-      /**
-       * Send input to the pane
-       */
-      sendInput(keys) {
-        return sendKeys(this.target, keys, false);
-      }
       cleanup() {
         this.isAttached = false;
         if (this.catProcess) {
@@ -5038,20 +5137,61 @@ var init_terminal = __esm({
         return this.isAttached;
       }
     };
-    TerminalManager = class {
+    TmuxTerminalApp = class {
+      id = "tmux";
+      label = "tmux";
       streams = /* @__PURE__ */ new Map();
-      /**
-       * List all available terminals
-       */
-      list() {
-        return {
-          sessions: listSessions(),
-          panes: listPanes()
-        };
+      isAvailable() {
+        try {
+          execSync("tmux -V", { stdio: "pipe" });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      listSessions() {
+        try {
+          const out = execSync(
+            "tmux list-sessions -F '#{session_name}|#{session_windows}|#{session_attached}' 2>/dev/null",
+            { encoding: "utf8", stdio: "pipe" }
+          ).trim();
+          if (!out) return [];
+          return out.split("\n").map((line) => {
+            const [name, windows, attached] = line.split("|");
+            return {
+              appId: this.id,
+              name,
+              windows: parseInt(windows, 10) || 0,
+              attached: attached === "1"
+            };
+          });
+        } catch {
+          return [];
+        }
+      }
+      listPanes() {
+        try {
+          const out = execSync(
+            "tmux list-panes -a -F '#{session_name}|#{window_index}|#{window_name}|#{pane_index}|#{pane_current_command}' 2>/dev/null",
+            { encoding: "utf8", stdio: "pipe" }
+          ).trim();
+          if (!out) return [];
+          return out.split("\n").map((line) => {
+            const [session, window2, windowName, pane, command] = line.split("|");
+            return {
+              appId: this.id,
+              session,
+              window: window2,
+              windowName,
+              pane,
+              command,
+              target: `${session}:${window2}.${pane}`
+            };
+          });
+        } catch {
+          return [];
+        }
       }
-      /**
-       * Attach to a pane and return the stream
-       */
       async attach(target, onData, onClose) {
         let stream = this.streams.get(target);
         if (stream && stream.attached) {
@@ -5059,7 +5199,7 @@ var init_terminal = __esm({
           stream.on("close", onClose);
           return true;
         }
-        stream = new TerminalStream(target);
+        stream = new TmuxTerminalStream(target);
         stream.on("data", onData);
         stream.on("close", () => {
           this.streams.delete(target);
@@ -5071,31 +5211,62 @@ var init_terminal = __esm({
         }
         return ok;
       }
-      /**
-       * Detach from a pane
-       */
       detach(target) {
         const stream = this.streams.get(target);
-        if (stream) {
-          stream.detach();
-          this.streams.delete(target);
-        }
+        if (!stream) return;
+        stream.detach();
+        this.streams.delete(target);
       }
-      /**
-       * Send input to a pane
-       */
       sendInput(target, keys) {
-        return sendKeys(target, keys, false);
+        return sendTmuxKeys(target, keys);
       }
-      /**
-       * Resize pane to match web terminal
-       */
       resize(target, cols, rows) {
-        return resizePane(target, cols, rows);
+        try {
+          execSync(`tmux resize-pane -t '${target}' -x ${cols} -y ${rows}`, {
+            encoding: "utf8",
+            stdio: "pipe"
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      createSession(sessionName, windowName = "main", cwd) {
+        const safeSession = sanitizeName(sessionName || "coding");
+        const safeWindow = sanitizeName(windowName || "main");
+        try {
+          execSync(`tmux has-session -t '${safeSession}' 2>/dev/null`, { stdio: "pipe" });
+          return { ok: true, appId: this.id, sessionName: safeSession, created: false };
+        } catch {
+        }
+        const args = ["new-session", "-d", "-s", safeSession, "-n", safeWindow];
+        if (cwd) {
+          args.push("-c", cwd);
+        }
+        const result = spawnSync("tmux", args, {
+          encoding: "utf8",
+          stdio: "pipe"
+        });
+        if (result.error) {
+          return {
+            ok: false,
+            appId: this.id,
+            sessionName: safeSession,
+            created: false,
+            error: `Failed to start tmux: ${result.error.message}`
+          };
+        }
+        if (result.status !== 0) {
+          return {
+            ok: false,
+            appId: this.id,
+            sessionName: safeSession,
+            created: false,
+            error: (result.stderr || result.stdout || "Failed to create tmux session").trim()
+          };
+        }
+        return { ok: true, appId: this.id, sessionName: safeSession, created: true };
       }
-      /**
-       * Detach all streams
-       */
       detachAll() {
         for (const stream of this.streams.values()) {
           stream.detach();
@@ -5103,6 +5274,177 @@ var init_terminal = __esm({
         this.streams.clear();
       }
     };
+    ShellTerminalApp = class {
+      id = "shell";
+      label = "shell";
+      sessions = /* @__PURE__ */ new Map();
+      isAvailable() {
+        return true;
+      }
+      listSessions() {
+        return Array.from(this.sessions.values()).map((state) => ({
+          appId: this.id,
+          name: state.sessionName,
+          windows: 1,
+          attached: state.listeners.size > 0
+        }));
+      }
+      listPanes() {
+        return Array.from(this.sessions.entries()).map(([id, state]) => ({
+          appId: this.id,
+          session: state.sessionName,
+          window: "0",
+          windowName: state.windowName,
+          pane: state.pane,
+          command: process.env.SHELL || "sh",
+          target: id
+        }));
+      }
+      async attach(target, onData, onClose) {
+        const state = this.sessions.get(target);
+        if (!state) return false;
+        state.listeners.add(onData);
+        state.closeListeners.add(onClose);
+        if (state.history.length > 0) {
+          onData(state.history.join(""));
+        }
+        return true;
+      }
+      detach(target) {
+        const state = this.sessions.get(target);
+        if (!state) return;
+        state.listeners.clear();
+        state.closeListeners.clear();
+      }
+      sendInput(target, keys) {
+        const state = this.sessions.get(target);
+        if (!state || !state.proc.stdin?.writable) return false;
+        state.proc.stdin.write(keys);
+        return true;
+      }
+      resize(_target, _cols, _rows) {
+        return true;
+      }
+      createSession(sessionName, windowName = "main", cwd) {
+        const safeSession = sanitizeName(sessionName || `shell-${Date.now()}`);
+        const shell = process.env.SHELL || "sh";
+        const target = `${safeSession}:${randomUUID().slice(0, 8)}`;
+        if (this.sessions.has(target)) {
+          return { ok: true, appId: this.id, sessionName: safeSession, created: false };
+        }
+        const proc = spawn(shell, [], {
+          cwd,
+          stdio: ["pipe", "pipe", "pipe"],
+          env: process.env
+        });
+        if (!proc.pid) {
+          return {
+            ok: false,
+            appId: this.id,
+            sessionName: safeSession,
+            created: false,
+            error: "Failed to start shell process"
+          };
+        }
+        const state = {
+          proc,
+          sessionName: safeSession,
+          windowName,
+          pane: "0",
+          history: [],
+          listeners: /* @__PURE__ */ new Set(),
+          closeListeners: /* @__PURE__ */ new Set()
+        };
+        const pushChunk = (chunk) => {
+          const text = chunk.toString();
+          state.history.push(text);
+          if (state.history.length > 200) {
+            state.history.shift();
+          }
+          for (const listener of state.listeners) {
+            listener(text);
+          }
+        };
+        proc.stdout?.on("data", pushChunk);
+        proc.stderr?.on("data", pushChunk);
+        proc.on("close", () => {
+          for (const onClose of state.closeListeners) {
+            onClose();
+          }
+          this.sessions.delete(target);
+        });
+        this.sessions.set(target, state);
+        return { ok: true, appId: this.id, sessionName: safeSession, created: true };
+      }
+      detachAll() {
+        for (const [id, state] of this.sessions.entries()) {
+          state.proc.kill();
+          this.sessions.delete(id);
+        }
+      }
+    };
+    TerminalManager = class {
+      apps = /* @__PURE__ */ new Map();
+      constructor(adapters) {
+        const defaultAdapters = adapters ?? [new TmuxTerminalApp(), new ShellTerminalApp()];
+        for (const adapter of defaultAdapters) {
+          this.apps.set(adapter.id, adapter);
+        }
+      }
+      list() {
+        const metadata = Array.from(this.apps.values()).map((app) => ({
+          id: app.id,
+          label: app.label,
+          available: app.isAvailable()
+        }));
+        const sessions = [];
+        const panes = [];
+        for (const app of this.apps.values()) {
+          if (!app.isAvailable()) continue;
+          sessions.push(...app.listSessions());
+          panes.push(...app.listPanes());
+        }
+        return { apps: metadata, sessions, panes };
+      }
+      async attach(target, onData, onClose, appHint) {
+        const { appId, rawTarget } = resolveAppTarget(target, appHint);
+        const app = this.apps.get(appId);
+        if (!app || !app.isAvailable()) return false;
+        return app.attach(rawTarget, onData, onClose);
+      }
+      detach(target, appHint) {
+        const { appId, rawTarget } = resolveAppTarget(target, appHint);
+        this.apps.get(appId)?.detach(rawTarget);
+      }
+      sendInput(target, keys, appHint) {
+        const { appId, rawTarget } = resolveAppTarget(target, appHint);
+        const app = this.apps.get(appId);
+        return !!app && app.isAvailable() ? app.sendInput(rawTarget, keys) : false;
+      }
+      resize(target, cols, rows, appHint) {
+        const { appId, rawTarget } = resolveAppTarget(target, appHint);
+        const app = this.apps.get(appId);
+        return !!app && app.isAvailable() ? app.resize(rawTarget, cols, rows) : false;
+      }
+      createSession(sessionName, windowName = "main", cwd, appId = "tmux") {
+        const app = this.apps.get(appId);
+        if (!app || !app.isAvailable()) {
+          return {
+            ok: false,
+            appId,
+            sessionName,
+            created: false,
+            error: `Terminal app '${appId}' is not available`
+          };
+        }
+        return app.createSession(sessionName, windowName, cwd);
+      }
+      detachAll() {
+        for (const app of this.apps.values()) {
+          app.detachAll();
+        }
+      }
+    };
   }
 });
 
@@ -5267,16 +5609,16 @@ var init_controller = __esm({
               this.handleTerminalList();
               break;
             case "terminal:attach":
-              await this.handleTerminalAttach(message.target);
+              await this.handleTerminalAttach(message.target, message.appId);
               break;
             case "terminal:detach":
-              this.handleTerminalDetach(message.target);
+              this.handleTerminalDetach(message.target, message.appId);
               break;
             case "terminal:input":
-              this.handleTerminalInput(message.target, message.keys);
+              this.handleTerminalInput(message.target, message.keys, message.appId);
               break;
             case "terminal:resize":
-              this.handleTerminalResize(message.target, message.cols, message.rows);
+              this.handleTerminalResize(message.target, message.cols, message.rows, message.appId);
               break;
           }
         } catch (error) {
@@ -5306,7 +5648,87 @@ var init_controller = __esm({
             },
             messages
           );
-          const finalText = await streamResult.text;
+          let finalText = "";
+          let pendingDelta = "";
+          let lastProgressAt = 0;
+          const flushProgress = (force = false) => {
+            if (!pendingDelta) return;
+            const now = Date.now();
+            if (!force && now - lastProgressAt < 250) return;
+            this.send({
+              type: "task:progress",
+              taskId,
+              event: {
+                kind: "text-delta",
+                delta: pendingDelta,
+                totalLength: finalText.length,
+                at: new Date(now).toISOString()
+              }
+            });
+            pendingDelta = "";
+            lastProgressAt = now;
+          };
+          this.send({
+            type: "task:progress",
+            taskId,
+            event: {
+              kind: "status",
+              phase: "executing",
+              message: "Agent execution started",
+              at: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          });
+          for await (const part of streamResult.fullStream) {
+            switch (part.type) {
+              case "text-delta":
+                if (part.text) {
+                  finalText += part.text;
+                  pendingDelta += part.text;
+                  flushProgress(false);
+                }
+                break;
+              case "tool-call":
+                this.send({
+                  type: "task:progress",
+                  taskId,
+                  event: {
+                    kind: "tool-call",
+                    toolName: part.toolName,
+                    toolCallId: part.toolCallId,
+                    at: (/* @__PURE__ */ new Date()).toISOString()
+                  }
+                });
+                break;
+              case "tool-result":
+                this.send({
+                  type: "task:progress",
+                  taskId,
+                  event: {
+                    kind: "tool-result",
+                    toolCallId: part.toolCallId,
+                    at: (/* @__PURE__ */ new Date()).toISOString()
+                  }
+                });
+                break;
+              case "error":
+                throw new Error(part.error?.message || "Task stream error");
+              case "finish":
+                flushProgress(true);
+                this.send({
+                  type: "task:progress",
+                  taskId,
+                  event: {
+                    kind: "status",
+                    phase: "verifying",
+                    message: "Agent execution finished, preparing final output",
+                    at: (/* @__PURE__ */ new Date()).toISOString()
+                  }
+                });
+                break;
+              default:
+                break;
+            }
+          }
           this.send({
             type: "task:completed",
             taskId,
@@ -5343,33 +5765,34 @@ var init_controller = __esm({
       }
       // ==================== Terminal Streaming ====================
       handleTerminalList() {
-        const { sessions, panes } = this.terminalManager.list();
-        this.send({ type: "terminal:list", sessions, panes });
+        const { apps, sessions, panes } = this.terminalManager.list();
+        this.send({ type: "terminal:list", apps, sessions, panes });
       }
-      async handleTerminalAttach(target) {
+      async handleTerminalAttach(target, appId) {
         console.log(`[Viber] Attaching to terminal: ${target}`);
         const ok = await this.terminalManager.attach(
           target,
           (data) => {
-            this.send({ type: "terminal:output", target, data });
+            this.send({ type: "terminal:output", target, appId, data });
           },
           () => {
-            this.send({ type: "terminal:detached", target });
-          }
+            this.send({ type: "terminal:detached", target, appId });
+          },
+          appId
         );
-        this.send({ type: "terminal:attached", target, ok });
+        this.send({ type: "terminal:attached", target, appId, ok });
       }
-      handleTerminalDetach(target) {
+      handleTerminalDetach(target, appId) {
         console.log(`[Viber] Detaching from terminal: ${target}`);
-        this.terminalManager.detach(target);
-        this.send({ type: "terminal:detached", target });
+        this.terminalManager.detach(target, appId);
+        this.send({ type: "terminal:detached", target, appId });
       }
-      handleTerminalInput(target, keys) {
-        this.terminalManager.sendInput(target, keys);
+      handleTerminalInput(target, keys, appId) {
+        this.terminalManager.sendInput(target, keys, appId);
       }
-      handleTerminalResize(target, cols, rows) {
-        const ok = this.terminalManager.resize(target, cols, rows);
-        this.send({ type: "terminal:resized", target, ok });
+      handleTerminalResize(target, cols, rows, appId) {
+        const ok = this.terminalManager.resize(target, cols, rows, appId);
+        this.send({ type: "terminal:resized", target, appId, ok });
       }
       // ==================== Communication ====================
       send(message) {
@@ -5521,7 +5944,7 @@ var init_antigravity = __esm({
 
 // src/skills/cursor-agent/index.ts
 import { z as z9 } from "zod";
-import { execSync as execSync2, spawnSync } from "child_process";
+import { execSync as execSync2, spawnSync as spawnSync2 } from "child_process";
 import * as path11 from "path";
 function runInTmux(goal, cwd, waitSeconds) {
   execSync2(
@@ -5532,17 +5955,17 @@ function runInTmux(goal, cwd, waitSeconds) {
     }
   );
   const cdCmd = cwd.includes(" ") ? `cd "${cwd.replace(/"/g, '\\"')}"` : `cd ${cwd}`;
-  spawnSync("tmux", ["send-keys", "-t", TMUX_SESSION, cdCmd, "Enter"], {
+  spawnSync2("tmux", ["send-keys", "-t", TMUX_SESSION, cdCmd, "Enter"], {
     encoding: "utf8",
     stdio: "pipe"
   });
   const sendArg = `agent -p ${JSON.stringify(goal)}`;
-  spawnSync("tmux", ["send-keys", "-t", TMUX_SESSION, sendArg, "Enter"], {
+  spawnSync2("tmux", ["send-keys", "-t", TMUX_SESSION, sendArg, "Enter"], {
     encoding: "utf8",
     stdio: "pipe"
   });
   execSync2("sleep 3", { encoding: "utf8", stdio: "pipe" });
-  spawnSync("tmux", ["send-keys", "-t", TMUX_SESSION, "a"], {
+  spawnSync2("tmux", ["send-keys", "-t", TMUX_SESSION, "a"], {
     encoding: "utf8",
     stdio: "pipe"
   });
@@ -5594,7 +6017,7 @@ var init_cursor_agent = __esm({
 
 // src/skills/tmux/index.ts
 import { z as z10 } from "zod";
-import { execSync as execSync3, spawnSync as spawnSync2 } from "child_process";
+import { execSync as execSync3, spawnSync as spawnSync3 } from "child_process";
 import * as path12 from "path";
 function safeTarget(t) {
   return t.replace(SAFE_RE, "-");
@@ -5606,11 +6029,11 @@ function runInTmux2(sessionName, command, cwd, waitSeconds) {
     { encoding: "utf8", stdio: "pipe" }
   );
   const cdCmd = cwd.includes(" ") ? `cd "${cwd.replace(/"/g, '\\"')}"` : `cd ${cwd}`;
-  spawnSync2("tmux", ["send-keys", "-t", safeSession, cdCmd, "Enter"], {
+  spawnSync3("tmux", ["send-keys", "-t", safeSession, cdCmd, "Enter"], {
     encoding: "utf8",
     stdio: "pipe"
   });
-  spawnSync2("tmux", ["send-keys", "-t", safeSession, command, "Enter"], {
+  spawnSync3("tmux", ["send-keys", "-t", safeSession, command, "Enter"], {
     encoding: "utf8",
     stdio: "pipe"
   });
@@ -5698,9 +6121,9 @@ function getTools3() {
           if (args.cwd) {
             newWinArgs.push("-c", path12.resolve(args.cwd));
           }
-          spawnSync2("tmux", newWinArgs, { encoding: "utf8", stdio: "pipe" });
+          spawnSync3("tmux", newWinArgs, { encoding: "utf8", stdio: "pipe" });
           if (args.command) {
-            spawnSync2("tmux", ["send-keys", "-t", session, args.command, "Enter"], {
+            spawnSync3("tmux", ["send-keys", "-t", session, args.command, "Enter"], {
               encoding: "utf8",
               stdio: "pipe"
             });
@@ -5736,9 +6159,9 @@ function getTools3() {
           if (args.cwd) {
             splitArgs.push("-c", path12.resolve(args.cwd));
           }
-          spawnSync2("tmux", splitArgs, { encoding: "utf8", stdio: "pipe" });
+          spawnSync3("tmux", splitArgs, { encoding: "utf8", stdio: "pipe" });
           if (args.command) {
-            spawnSync2("tmux", ["send-keys", "-t", t, args.command, "Enter"], {
+            spawnSync3("tmux", ["send-keys", "-t", t, args.command, "Enter"], {
               encoding: "utf8",
               stdio: "pipe"
             });
@@ -5767,7 +6190,7 @@ function getTools3() {
       execute: async (args) => {
         const t = safeTarget(args.target);
         try {
-          spawnSync2("tmux", ["send-keys", "-t", t, args.keys, ...args.pressEnter !== false ? ["Enter"] : []], {
+          spawnSync3("tmux", ["send-keys", "-t", t, args.keys, ...args.pressEnter !== false ? ["Enter"] : []], {
             encoding: "utf8",
             stdio: "pipe"
           });
@@ -5951,49 +6374,74 @@ var init_local_server = __esm({
             this.handleTerminalList(ws);
             break;
           case "terminal:attach":
-            this.handleTerminalAttach(ws, msg.target);
+            this.handleTerminalAttach(ws, msg.target, msg.appId);
             break;
           case "terminal:detach":
-            this.handleTerminalDetach(ws, msg.target);
+            this.handleTerminalDetach(ws, msg.target, msg.appId);
             break;
           case "terminal:input":
-            this.handleTerminalInput(msg.target, msg.keys);
+            this.handleTerminalInput(msg.target, msg.keys, msg.appId);
             break;
           case "terminal:resize":
-            this.handleTerminalResize(ws, msg.target, msg.cols, msg.rows);
+            this.handleTerminalResize(ws, msg.target, msg.cols, msg.rows, msg.appId);
+            break;
+          case "terminal:create-session":
+            this.handleTerminalCreateSession(
+              ws,
+              msg.sessionName,
+              msg.windowName,
+              msg.cwd,
+              msg.appId
+            );
             break;
           default:
             console.log(`[Viber] Unknown message type: ${msg.type}`);
         }
       }
       handleTerminalList(ws) {
-        const { sessions, panes } = this.terminalManager.list();
-        this.send(ws, { type: "terminal:list", sessions, panes });
+        const { apps, sessions, panes } = this.terminalManager.list();
+        this.send(ws, { type: "terminal:list", apps, sessions, panes });
       }
-      async handleTerminalAttach(ws, target) {
+      async handleTerminalAttach(ws, target, appId) {
         console.log(`[Viber] Attaching to terminal: ${target}`);
         const ok = await this.terminalManager.attach(
           target,
           (data) => {
-            this.send(ws, { type: "terminal:output", target, data });
+            this.send(ws, { type: "terminal:output", target, appId, data });
           },
           () => {
-            this.send(ws, { type: "terminal:detached", target });
-          }
+            this.send(ws, { type: "terminal:detached", target, appId });
+          },
+          appId
         );
-        this.send(ws, { type: "terminal:attached", target, ok });
+        this.send(ws, { type: "terminal:attached", target, appId, ok });
       }
-      handleTerminalDetach(ws, target) {
+      handleTerminalDetach(ws, target, appId) {
         console.log(`[Viber] Detaching from terminal: ${target}`);
-        this.terminalManager.detach(target);
-        this.send(ws, { type: "terminal:detached", target });
-      }
-      handleTerminalInput(target, keys) {
-        this.terminalManager.sendInput(target, keys);
-      }
-      handleTerminalResize(ws, target, cols, rows) {
-        const ok = this.terminalManager.resize(target, cols, rows);
-        this.send(ws, { type: "terminal:resized", target, ok });
+        this.terminalManager.detach(target, appId);
+        this.send(ws, { type: "terminal:detached", target, appId });
+      }
+      handleTerminalInput(target, keys, appId) {
+        this.terminalManager.sendInput(target, keys, appId);
+      }
+      handleTerminalResize(ws, target, cols, rows, appId) {
+        const ok = this.terminalManager.resize(target, cols, rows, appId);
+        this.send(ws, { type: "terminal:resized", target, appId, ok });
+      }
+      handleTerminalCreateSession(ws, sessionName, windowName, cwd, appId = "tmux") {
+        const result = this.terminalManager.createSession(
+          sessionName || "coding",
+          windowName || "main",
+          cwd,
+          appId
+        );
+        this.send(ws, {
+          type: "terminal:session-created",
+          ...result
+        });
+        if (result.ok) {
+          this.handleTerminalList(ws);
+        }
       }
       send(ws, msg) {
         if (ws.readyState === WebSocket3.OPEN) {
@@ -6173,7 +6621,9 @@ var init_hub = __esm({
               viberId: viber.id,
               goal,
               status: "pending",
-              createdAt: /* @__PURE__ */ new Date()
+              createdAt: /* @__PURE__ */ new Date(),
+              events: [],
+              partialText: ""
             };
             this.tasks.set(taskId, task);
             viber.ws.send(
@@ -6199,7 +6649,9 @@ var init_hub = __esm({
           goal: t.goal,
           status: t.status,
           createdAt: t.createdAt.toISOString(),
-          completedAt: t.completedAt?.toISOString()
+          completedAt: t.completedAt?.toISOString(),
+          eventCount: t.events.length,
+          partialText: t.partialText
         }));
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ tasks }));
@@ -6221,7 +6673,10 @@ var init_hub = __esm({
             result: task.result,
             error: task.error,
             createdAt: task.createdAt.toISOString(),
-            completedAt: task.completedAt?.toISOString()
+            completedAt: task.completedAt?.toISOString(),
+            events: task.events,
+            eventCount: task.events.length,
+            partialText: task.partialText
           })
         );
       }
@@ -6275,6 +6730,7 @@ var init_hub = __esm({
             this.handleTaskStarted(msg.taskId);
             break;
           case "task:progress":
+            this.handleTaskProgress(msg.taskId, msg.event);
             break;
           case "task:completed":
             this.handleTaskCompleted(msg.taskId, msg.result);
@@ -6320,9 +6776,27 @@ var init_hub = __esm({
           task.status = "completed";
           task.result = result;
           task.completedAt = /* @__PURE__ */ new Date();
+          if (typeof result?.text === "string") {
+            task.partialText = result.text;
+          }
           console.log(`[Hub] Task completed: ${taskId}`);
         }
       }
+      handleTaskProgress(taskId, event) {
+        const task = this.tasks.get(taskId);
+        if (!task) return;
+        const at = (/* @__PURE__ */ new Date()).toISOString();
+        task.events.push({ at, event });
+        if (task.events.length > 500) {
+          task.events.shift();
+        }
+        if (event?.kind === "text-delta" && typeof event?.delta === "string") {
+          task.partialText = (task.partialText || "") + event.delta;
+          if (task.partialText.length > 2e4) {
+            task.partialText = task.partialText.slice(-2e4);
+          }
+        }
+      }
       handleTaskError(taskId, error) {
         const task = this.tasks.get(taskId);
         if (task) {
@@ -6344,20 +6818,2017 @@ var init_hub = __esm({
   }
 });
 
-// src/cli/index.ts
-import "dotenv/config";
-import { program } from "commander";
-import * as os2 from "os";
-import * as fs7 from "fs/promises";
-import * as path13 from "path";
-var VERSION = "1.0.0";
-program.name("openviber").description("OpenViber - Workspace-first assistant runtime (vibers on your machines)").version(VERSION);
-program.command("start").description(
-  "Start viber with all apps (local mode, or connect to server with --server)"
-).option("-s, --server <url>", "Command center URL (enables connected mode)").option("-t, --token <token>", "Authentication token (or set VIBER_TOKEN)").option("-n, --name <name>", "Viber name", `${os2.hostname()}-viber`).option("--desktop", "Enable desktop control (UI-TARS)").option("--disable-app <apps...>", "Disable specific apps (comma-separated)").option("--no-apps", "Disable all apps").option("--reconnect-interval <ms>", "Reconnect interval in ms", "5000").option("--heartbeat-interval <ms>", "Heartbeat interval in ms", "30000").action(async (options) => {
-  const { JobScheduler: JobScheduler2 } = await Promise.resolve().then(() => (init_scheduler(), scheduler_exports));
-  const { ViberController: ViberController2 } = await Promise.resolve().then(() => (init_controller(), controller_exports));
-  const { EventEmitter: EventEmitter3 } = await import("events");
+// src/core/task.ts
+var Task;
+var init_task = __esm({
+  "src/core/task.ts"() {
+    "use strict";
+    Task = class _Task {
+      id;
+      title;
+      description;
+      status;
+      assignedTo;
+      priority;
+      estimatedTime;
+      actualTime;
+      dependencies;
+      steps;
+      tags;
+      metadata;
+      createdAt;
+      updatedAt;
+      startedAt;
+      completedAt;
+      error;
+      constructor({
+        id,
+        title,
+        description,
+        status = "pending" /* PENDING */,
+        assignedTo,
+        priority = "medium",
+        estimatedTime,
+        dependencies = [],
+        steps = [],
+        tags = [],
+        metadata = {}
+      }) {
+        this.id = id;
+        this.title = title;
+        this.description = description;
+        this.status = status;
+        this.assignedTo = assignedTo;
+        this.priority = priority;
+        this.estimatedTime = estimatedTime;
+        this.dependencies = dependencies;
+        this.steps = steps;
+        this.tags = tags;
+        this.metadata = metadata;
+        this.createdAt = /* @__PURE__ */ new Date();
+        this.updatedAt = /* @__PURE__ */ new Date();
+      }
+      start() {
+        if (this.status !== "pending" /* PENDING */) {
+          throw new Error(`Cannot start task in ${this.status} status`);
+        }
+        this.status = "running" /* RUNNING */;
+        this.startedAt = /* @__PURE__ */ new Date();
+        this.updatedAt = /* @__PURE__ */ new Date();
+      }
+      complete() {
+        if (this.status !== "running" /* RUNNING */) {
+          throw new Error(`Cannot complete task in ${this.status} status`);
+        }
+        this.status = "completed" /* COMPLETED */;
+        this.completedAt = /* @__PURE__ */ new Date();
+        this.updatedAt = /* @__PURE__ */ new Date();
+        if (this.startedAt) {
+          this.actualTime = this.calculateDuration(
+            this.startedAt,
+            this.completedAt
+          );
+        }
+      }
+      fail(error) {
+        this.status = "failed" /* FAILED */;
+        this.error = error;
+        this.completedAt = /* @__PURE__ */ new Date();
+        this.updatedAt = /* @__PURE__ */ new Date();
+      }
+      block(reason) {
+        this.status = "blocked" /* BLOCKED */;
+        this.error = reason;
+        this.updatedAt = /* @__PURE__ */ new Date();
+      }
+      cancel() {
+        this.status = "cancelled" /* CANCELLED */;
+        this.completedAt = /* @__PURE__ */ new Date();
+        this.updatedAt = /* @__PURE__ */ new Date();
+      }
+      isActionable(context) {
+        return this.status === "pending" /* PENDING */ && !this.hasBlockingDependencies(context);
+      }
+      hasBlockingDependencies(context) {
+        if (!context || !this.dependencies || this.dependencies.length === 0) {
+          return false;
+        }
+        return this.dependencies.some((dep) => {
+          if (dep.type === "optional") return false;
+          const status = context.getTaskStatus(dep.taskId);
+          return status !== "completed" /* COMPLETED */;
+        });
+      }
+      calculateDuration(start, end) {
+        const ms = end.getTime() - start.getTime();
+        const seconds = Math.floor(ms / 1e3);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0) {
+          return `${hours}h ${minutes % 60}m`;
+        } else if (minutes > 0) {
+          return `${minutes}m ${seconds % 60}s`;
+        } else {
+          return `${seconds}s`;
+        }
+      }
+      toJSON() {
+        return {
+          id: this.id,
+          title: this.title,
+          description: this.description,
+          status: this.status,
+          assignedTo: this.assignedTo,
+          priority: this.priority,
+          estimatedTime: this.estimatedTime,
+          actualTime: this.actualTime,
+          dependencies: this.dependencies,
+          steps: this.steps,
+          tags: this.tags,
+          metadata: this.metadata,
+          createdAt: this.createdAt.toISOString(),
+          updatedAt: this.updatedAt.toISOString(),
+          startedAt: this.startedAt?.toISOString(),
+          completedAt: this.completedAt?.toISOString(),
+          error: this.error
+        };
+      }
+      static fromJSON(data) {
+        const task = new _Task({
+          id: data.id,
+          title: data.title,
+          description: data.description,
+          status: data.status,
+          assignedTo: data.assignedTo,
+          priority: data.priority,
+          estimatedTime: data.estimatedTime,
+          dependencies: data.dependencies,
+          steps: data.steps,
+          tags: data.tags,
+          metadata: data.metadata
+        });
+        task.createdAt = new Date(data.createdAt);
+        task.updatedAt = new Date(data.updatedAt);
+        task.actualTime = data.actualTime;
+        task.error = data.error;
+        if (data.startedAt) {
+          task.startedAt = new Date(data.startedAt);
+        }
+        if (data.completedAt) {
+          task.completedAt = new Date(data.completedAt);
+        }
+        return task;
+      }
+    };
+  }
+});
+
+// src/core/plan.ts
+var Plan;
+var init_plan = __esm({
+  "src/core/plan.ts"() {
+    "use strict";
+    init_task();
+    Plan = class _Plan {
+      tasks;
+      goal;
+      createdAt;
+      updatedAt;
+      constructor({ tasks = [], goal }) {
+        this.tasks = tasks;
+        this.goal = goal;
+        this.createdAt = /* @__PURE__ */ new Date();
+        this.updatedAt = /* @__PURE__ */ new Date();
+      }
+      addTask(task) {
+        this.tasks.push(task);
+        this.updatedAt = /* @__PURE__ */ new Date();
+      }
+      removeTask(taskId) {
+        const index = this.tasks.findIndex((t) => t.id === taskId);
+        if (index >= 0) {
+          this.tasks.splice(index, 1);
+          this.updatedAt = /* @__PURE__ */ new Date();
+          return true;
+        }
+        return false;
+      }
+      getTaskById(taskId) {
+        return this.tasks.find((t) => t.id === taskId);
+      }
+      updateTaskStatus(taskId, status) {
+        const task = this.getTaskById(taskId);
+        if (task) {
+          task.status = status;
+          task.updatedAt = /* @__PURE__ */ new Date();
+          this.updatedAt = /* @__PURE__ */ new Date();
+          return true;
+        }
+        return false;
+      }
+      getNextActionableTask() {
+        return this.tasks.find(
+          (task) => task.isActionable({
+            getTaskStatus: (id) => this.getTaskById(id)?.status
+          })
+        );
+      }
+      getAllActionableTasks(maxTasks) {
+        const actionableTasks = this.tasks.filter(
+          (task) => task.isActionable({
+            getTaskStatus: (id) => this.getTaskById(id)?.status
+          })
+        );
+        return maxTasks ? actionableTasks.slice(0, maxTasks) : actionableTasks;
+      }
+      getTasksByStatus(status) {
+        return this.tasks.filter((task) => task.status === status);
+      }
+      getTasksByAssignee(assignee) {
+        return this.tasks.filter((task) => task.assignedTo === assignee);
+      }
+      isComplete() {
+        return this.tasks.every(
+          (task) => task.status === "completed" /* COMPLETED */ || task.status === "cancelled" /* CANCELLED */
+        );
+      }
+      hasFailedTasks() {
+        return this.tasks.some((task) => task.status === "failed" /* FAILED */);
+      }
+      hasBlockedTasks() {
+        return this.tasks.some((task) => task.status === "blocked" /* BLOCKED */);
+      }
+      getProgressSummary() {
+        const summary = {
+          totalTasks: this.tasks.length,
+          completedTasks: 0,
+          runningTasks: 0,
+          pendingTasks: 0,
+          failedTasks: 0,
+          blockedTasks: 0,
+          progressPercentage: 0
+        };
+        for (const task of this.tasks) {
+          switch (task.status) {
+            case "completed" /* COMPLETED */:
+              summary.completedTasks++;
+              break;
+            case "running" /* RUNNING */:
+              summary.runningTasks++;
+              break;
+            case "pending" /* PENDING */:
+              summary.pendingTasks++;
+              break;
+            case "failed" /* FAILED */:
+              summary.failedTasks++;
+              break;
+            case "blocked" /* BLOCKED */:
+              summary.blockedTasks++;
+              break;
+          }
+        }
+        if (summary.totalTasks > 0) {
+          summary.progressPercentage = summary.completedTasks / summary.totalTasks * 100;
+        }
+        return summary;
+      }
+      reorderTasks(fromIndex, toIndex) {
+        if (fromIndex < 0 || fromIndex >= this.tasks.length || toIndex < 0 || toIndex >= this.tasks.length) {
+          throw new Error("Invalid task indices");
+        }
+        const [task] = this.tasks.splice(fromIndex, 1);
+        this.tasks.splice(toIndex, 0, task);
+        this.updatedAt = /* @__PURE__ */ new Date();
+      }
+      toJSON() {
+        return {
+          tasks: this.tasks.map((task) => task.toJSON()),
+          goal: this.goal,
+          createdAt: this.createdAt.toISOString(),
+          updatedAt: this.updatedAt.toISOString()
+        };
+      }
+      static fromJSON(data) {
+        const plan = new _Plan({
+          goal: data.goal,
+          tasks: data.tasks.map((taskData) => Task.fromJSON(taskData))
+        });
+        plan.createdAt = new Date(data.createdAt);
+        plan.updatedAt = new Date(data.updatedAt);
+        return plan;
+      }
+    };
+  }
+});
+
+// src/core/collaboration.ts
+var AgentCollaborationManager, ParallelExecutionEngine, CollaborativePlanner;
+var init_collaboration = __esm({
+  "src/core/collaboration.ts"() {
+    "use strict";
+    AgentCollaborationManager = class {
+      space;
+      messageQueue;
+      // Agent ID -> messages
+      sharedContext;
+      listeners;
+      constructor(space) {
+        this.space = space;
+        this.messageQueue = /* @__PURE__ */ new Map();
+        this.sharedContext = {
+          spaceId: space.spaceId,
+          data: {},
+          updatedAt: /* @__PURE__ */ new Date(),
+          updatedBy: "system"
+        };
+        this.listeners = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Send a message from one agent to another
+       */
+      sendMessage(from, to, content, metadata) {
+        const message = {
+          from,
+          to,
+          content,
+          metadata,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        if (to === "broadcast") {
+          for (const agentId of this.space.agents.keys()) {
+            if (agentId !== from) {
+              this.queueMessage(agentId, message);
+            }
+          }
+        } else {
+          this.queueMessage(to, message);
+        }
+        this.notifyListeners(to, message);
+        if (to !== "broadcast") {
+          this.notifyListeners("broadcast", message);
+        }
+      }
+      /**
+       * Queue a message for an agent
+       */
+      queueMessage(agentId, message) {
+        if (!this.messageQueue.has(agentId)) {
+          this.messageQueue.set(agentId, []);
+        }
+        this.messageQueue.get(agentId).push(message);
+      }
+      /**
+       * Get pending messages for an agent
+       */
+      getMessages(agentId) {
+        const messages = this.messageQueue.get(agentId) || [];
+        this.messageQueue.set(agentId, []);
+        return messages;
+      }
+      /**
+       * Subscribe to messages for an agent
+       */
+      subscribe(agentId, callback) {
+        if (!this.listeners.has(agentId)) {
+          this.listeners.set(agentId, /* @__PURE__ */ new Set());
+        }
+        this.listeners.get(agentId).add(callback);
+        return () => {
+          const callbacks = this.listeners.get(agentId);
+          if (callbacks) {
+            callbacks.delete(callback);
+            if (callbacks.size === 0) {
+              this.listeners.delete(agentId);
+            }
+          }
+        };
+      }
+      /**
+       * Notify listeners of a new message
+       */
+      notifyListeners(agentId, message) {
+        const callbacks = this.listeners.get(agentId);
+        if (callbacks) {
+          callbacks.forEach((cb) => {
+            try {
+              cb(message);
+            } catch (error) {
+              console.error(`[AgentCollaborationManager] Listener error:`, error);
+            }
+          });
+        }
+      }
+      /**
+       * Update shared context
+       */
+      updateContext(agentId, updates) {
+        this.sharedContext.data = {
+          ...this.sharedContext.data,
+          ...updates
+        };
+        this.sharedContext.updatedAt = /* @__PURE__ */ new Date();
+        this.sharedContext.updatedBy = agentId;
+      }
+      /**
+       * Get shared context
+       */
+      getContext() {
+        return { ...this.sharedContext };
+      }
+      /**
+       * Get a specific value from shared context
+       */
+      getContextValue(key) {
+        return this.sharedContext.data[key];
+      }
+    };
+    ParallelExecutionEngine = class {
+      space;
+      maxConcurrency;
+      activeTasks;
+      constructor(space, maxConcurrency = 3) {
+        this.space = space;
+        this.maxConcurrency = maxConcurrency;
+        this.activeTasks = /* @__PURE__ */ new Map();
+      }
+      /**
+       * Execute multiple tasks in parallel
+       */
+      async executeParallel(tasks) {
+        const sortedTasks = [...tasks].sort(
+          (a, b) => (b.priority || 0) - (a.priority || 0)
+        );
+        const results = [];
+        const executing = [];
+        for (const task of sortedTasks) {
+          if (executing.length >= this.maxConcurrency) {
+            const completed = await Promise.race(executing);
+            const index = executing.findIndex(
+              (p) => p === Promise.resolve(completed)
+            );
+            if (index >= 0) {
+              executing.splice(index, 1);
+            }
+            results.push(completed);
+          }
+          const promise = this.executeTask(task);
+          executing.push(promise);
+          this.activeTasks.set(task.id, promise);
+        }
+        const remaining = await Promise.allSettled(executing);
+        for (const result of remaining) {
+          if (result.status === "fulfilled") {
+            results.push(result.value);
+          } else {
+            console.error("[ParallelExecutionEngine] Task failed:", result.reason);
+          }
+        }
+        this.activeTasks.clear();
+        return results;
+      }
+      /**
+       * Execute a single task
+       */
+      async executeTask(task) {
+        const startTime = Date.now();
+        try {
+          const agent = this.space.getAgent(task.agentId);
+          if (!agent) {
+            throw new Error(`Agent ${task.agentId} not found`);
+          }
+          const result = await agent.generateText({
+            messages: task.messages,
+            system: task.system,
+            spaceId: this.space.spaceId,
+            metadata: {
+              ...task.metadata,
+              parallelTaskId: task.id
+            }
+          });
+          const duration = Date.now() - startTime;
+          return {
+            taskId: task.id,
+            agentId: task.agentId,
+            result: {
+              text: result.text || "",
+              toolCalls: result.toolCalls,
+              reasoning: result.reasoning,
+              metadata: result.metadata
+            },
+            duration
+          };
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          return {
+            taskId: task.id,
+            agentId: task.agentId,
+            result: {
+              text: "",
+              metadata: { error: String(error) }
+            },
+            error: error instanceof Error ? error : new Error(String(error)),
+            duration
+          };
+        }
+      }
+      /**
+       * Cancel a running task
+       */
+      cancelTask(taskId) {
+        const task = this.activeTasks.get(taskId);
+        if (task) {
+          this.activeTasks.delete(taskId);
+        }
+      }
+      /**
+       * Get active task count
+       */
+      getActiveTaskCount() {
+        return this.activeTasks.size;
+      }
+    };
+    CollaborativePlanner = class {
+      space;
+      collaborationManager;
+      constructor(space, collaborationManager) {
+        this.space = space;
+        this.collaborationManager = collaborationManager;
+      }
+      /**
+       * Create a collaborative plan with multiple agents
+       */
+      async createCollaborativePlan(goal, agentIds) {
+        const context = this.collaborationManager.getContext();
+        const planningTasks = agentIds.map((agentId, index) => ({
+          id: `plan-${agentId}-${Date.now()}`,
+          agentId,
+          messages: [
+            {
+              role: "user",
+              content: `We need to create a collaborative plan for: ${goal}
+
+Shared context: ${JSON.stringify(context.data, null, 2)}
+
+You are one of ${agentIds.length} agents working together. Propose your part of the plan and identify dependencies on other agents.`
+            }
+          ],
+          priority: agentIds.length - index,
+          // First agent gets highest priority
+          metadata: {
+            planningSession: true,
+            goal,
+            otherAgents: agentIds.filter((id) => id !== agentId)
+          }
+        }));
+        const executionEngine = new ParallelExecutionEngine(this.space);
+        const results = await executionEngine.executeParallel(planningTasks);
+        const agentPlans = /* @__PURE__ */ new Map();
+        for (const result of results) {
+          if (!result.error) {
+            agentPlans.set(result.agentId, result.result);
+          }
+        }
+        const plan = this.mergePlans(agentPlans, goal);
+        const agentAssignments = this.assignTasks(plan, agentIds);
+        return { plan, agentAssignments };
+      }
+      /**
+       * Merge multiple agent plans into one
+       */
+      mergePlans(agentPlans, goal) {
+        const tasks = [];
+        let taskId = 1;
+        for (const [agentId, plan] of agentPlans.entries()) {
+          if (plan.text) {
+            const lines = plan.text.split("\n").filter(
+              (line) => line.trim().startsWith("-") || line.trim().match(/^\d+\./)
+            );
+            for (const line of lines) {
+              tasks.push({
+                id: `task-${taskId++}`,
+                description: line.replace(/^[-•\d.]+\s*/, "").trim(),
+                assignedAgent: agentId,
+                status: "pending"
+              });
+            }
+          }
+        }
+        return {
+          goal,
+          tasks,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      /**
+       * Assign tasks to agents
+       */
+      assignTasks(plan, agentIds) {
+        const assignments = /* @__PURE__ */ new Map();
+        for (const agentId of agentIds) {
+          assignments.set(agentId, []);
+        }
+        for (const task of plan.tasks) {
+          const agentId = task.assignedAgent || agentIds[0];
+          const tasks = assignments.get(agentId) || [];
+          tasks.push(task.id);
+          assignments.set(agentId, tasks);
+        }
+        return assignments;
+      }
+    };
+  }
+});
+
+// src/core/space.ts
+var space_exports2 = {};
+__export(space_exports2, {
+  Space: () => Space,
+  startSpace: () => startSpace
+});
+async function startSpace({
+  goal,
+  spaceId,
+  userId,
+  spaceRoot,
+  name,
+  model
+}) {
+  const id = spaceId || `proj_${Date.now().toString(36)}`;
+  const spaceConfig = {
+    name: name || goal.slice(0, 50),
+    autoSave: true,
+    checkpointInterval: 300
+  };
+  console.log(`[Space] Creating space - agents will be loaded on demand`);
+  const storage = await SpaceStorageFactory.create(id);
+  const agents = /* @__PURE__ */ new Map();
+  console.log(`[Space] Space initialized (agents loaded on demand)`);
+  const messageQueue = new MessageQueue();
+  const history = new ConversationHistory();
+  const space = new Space({
+    spaceId: id,
+    userId,
+    config: spaceConfig,
+    history,
+    messageQueue,
+    agents,
+    storage,
+    goal,
+    name: name || spaceConfig.name
+  });
+  const viberAgentConfig = {
+    name: "Viber",
+    description: "I manage this space and coordinate all work.",
+    provider: "openrouter",
+    model: model || "deepseek/deepseek-chat",
+    temperature: 0.7,
+    promptFile: "",
+    // ViberAgent doesn't use prompt files
+    skills: ["tmux", "cursor-agent"]
+  };
+  const viberAgent = new ViberAgent(viberAgentConfig, space, {
+    model,
+    spaceId: id
+  });
+  space.viberAgent = viberAgent;
+  await space.persistState();
+  return space;
+}
+var Space;
+var init_space2 = __esm({
+  "src/core/space.ts"() {
+    "use strict";
+    init_task();
+    init_viber_agent();
+    init_space();
+    init_message();
+    init_collaboration();
+    Space = class {
+      spaceId;
+      userId;
+      // User ID of space owner
+      config;
+      history;
+      // Legacy: primary task history
+      tasks;
+      // NEW: Multiple tasks
+      messageQueue;
+      agents;
+      storage;
+      goal;
+      name;
+      viberAgent;
+      createdAt;
+      updatedAt;
+      plan;
+      artifacts;
+      collaborationManager;
+      parallelEngine;
+      collaborativePlanner;
+      constructor({
+        spaceId,
+        userId,
+        config: config2,
+        history,
+        messageQueue,
+        agents,
+        storage,
+        goal,
+        name,
+        viberAgent
+      }) {
+        this.spaceId = spaceId;
+        this.userId = userId;
+        this.config = config2;
+        this.history = history;
+        this.tasks = /* @__PURE__ */ new Map();
+        this.messageQueue = messageQueue;
+        this.agents = agents;
+        this.storage = storage;
+        this.goal = goal;
+        this.name = name || `Space ${spaceId}`;
+        this.viberAgent = viberAgent;
+        this.createdAt = /* @__PURE__ */ new Date();
+        this.updatedAt = /* @__PURE__ */ new Date();
+        this.collaborationManager = new AgentCollaborationManager(this);
+        this.parallelEngine = new ParallelExecutionEngine(this);
+        this.collaborativePlanner = new CollaborativePlanner(
+          this,
+          this.collaborationManager
+        );
+      }
+      /**
+       * Get or create a task within this space
+       */
+      getOrCreateTask(taskId, title) {
+        if (!this.tasks.has(taskId)) {
+          const task = {
+            id: taskId,
+            spaceId: this.spaceId,
+            title: title || `Task ${taskId}`,
+            history: new ConversationHistory(),
+            artifactIds: [],
+            status: "active",
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          this.tasks.set(taskId, task);
+          console.log(`[Space] Created task ${taskId} in space ${this.spaceId}`);
+        }
+        return this.tasks.get(taskId);
+      }
+      /**
+       * Get task by ID
+       */
+      getTask(taskId) {
+        return this.tasks.get(taskId);
+      }
+      /**
+       * Get all tasks in this space
+       */
+      getAllTasks() {
+        return Array.from(this.tasks.values());
+      }
+      /**
+       * Update space task status (for conversation tasks, not Plan tasks)
+       */
+      updateSpaceTaskStatus(taskId, status) {
+        const task = this.tasks.get(taskId);
+        if (task) {
+          task.status = status;
+          task.updatedAt = /* @__PURE__ */ new Date();
+          return true;
+        }
+        return false;
+      }
+      getAgent(name) {
+        return this.agents.get(name);
+      }
+      registerAgent(name, agent) {
+        this.agents.set(name, agent);
+        console.log(`[Space] Registered agent: ${name} - ${agent.description}`);
+      }
+      complete() {
+        console.log(`Space ${this.spaceId} completed`);
+      }
+      getContext() {
+        const context = {
+          spaceId: this.spaceId,
+          goal: this.goal,
+          storagePath: this.storage.getSpacePath(),
+          agents: Array.from(this.agents.keys()),
+          historyLength: this.history.messages.length,
+          createdAt: this.createdAt.toISOString()
+        };
+        if (this.plan) {
+          context.plan = {
+            goal: this.goal,
+            totalTasks: this.plan.tasks.length,
+            progress: this.plan.getProgressSummary()
+          };
+        }
+        return context;
+      }
+      async createPlan(plan) {
+        this.plan = plan;
+        await this.persistState();
+        console.log(
+          `Created plan for space ${this.spaceId} with ${plan.tasks.length} tasks`
+        );
+      }
+      async updatePlan(plan) {
+        this.plan = plan;
+        this.updatedAt = /* @__PURE__ */ new Date();
+        await this.persistState();
+        console.log(`Updated plan for space ${this.spaceId}`);
+      }
+      async setName(name) {
+        this.name = name;
+        this.updatedAt = /* @__PURE__ */ new Date();
+        await this.persistState();
+        console.log(`Updated space ${this.spaceId} name to: ${name}`);
+      }
+      async getNextTask() {
+        if (!this.plan) {
+          return void 0;
+        }
+        return this.plan.getNextActionableTask();
+      }
+      async getParallelTasks(maxTasks = 3) {
+        if (!this.plan) {
+          return [];
+        }
+        return this.plan.getAllActionableTasks(maxTasks);
+      }
+      async updateTaskStatus(taskId, status) {
+        if (!this.plan) {
+          return false;
+        }
+        const success = this.plan.updateTaskStatus(taskId, status);
+        if (success) {
+          this.updatedAt = /* @__PURE__ */ new Date();
+          await this.persistState();
+          console.log(`Updated task ${taskId} status to ${status}`);
+        }
+        return success;
+      }
+      async assignTask(taskId, agentName) {
+        if (!this.plan) {
+          return false;
+        }
+        const task = this.plan.getTaskById(taskId);
+        if (!task) {
+          return false;
+        }
+        if (!this.agents.has(agentName)) {
+          console.error(`Agent '${agentName}' not found in space team`);
+          return false;
+        }
+        task.assignedTo = agentName;
+        this.updatedAt = /* @__PURE__ */ new Date();
+        await this.persistState();
+        console.log(`Assigned task ${taskId} to agent ${agentName}`);
+        return true;
+      }
+      isPlanComplete() {
+        if (!this.plan) {
+          return false;
+        }
+        return this.plan.isComplete();
+      }
+      hasFailedTasks() {
+        if (!this.plan) {
+          return false;
+        }
+        return this.plan.hasFailedTasks();
+      }
+      async persistState() {
+        console.log("[Space] State persistence handled by database adapter");
+      }
+      async loadState() {
+        try {
+          console.log("[Space] State loading handled by database adapter");
+          return false;
+        } catch (error) {
+          console.error("Failed to load space state:", error);
+        }
+        return false;
+      }
+      async loadPlan() {
+        if (await this.loadState()) {
+          return this.plan;
+        }
+        return void 0;
+      }
+      getState() {
+        const state = {
+          spaceId: this.spaceId,
+          name: this.name,
+          goal: this.goal,
+          createdAt: this.createdAt.toISOString(),
+          updatedAt: this.updatedAt.toISOString(),
+          teamSize: this.agents.size
+        };
+        if (this.plan) {
+          const taskStats = {
+            total: this.plan.tasks.length,
+            completed: this.plan.tasks.filter(
+              (t) => t.status === "completed" /* COMPLETED */
+            ).length,
+            running: this.plan.tasks.filter((t) => t.status === "running" /* RUNNING */).length,
+            pending: this.plan.tasks.filter((t) => t.status === "pending" /* PENDING */).length,
+            failed: this.plan.tasks.filter((t) => t.status === "failed" /* FAILED */).length
+          };
+          state.tasks = taskStats;
+          state.progressPercentage = taskStats.total > 0 ? taskStats.completed / taskStats.total * 100 : 0;
+        }
+        return state;
+      }
+    };
+  }
+});
+
+// src/core/viber-agent.ts
+import { generateText as generateText2, Output } from "ai";
+import { z as z11 } from "zod";
+var ViberAgent;
+var init_viber_agent = __esm({
+  "src/core/viber-agent.ts"() {
+    "use strict";
+    init_agent();
+    init_factory();
+    init_plan();
+    init_task();
+    ViberAgent = class extends Agent {
+      space;
+      spaceId;
+      abortController;
+      singleAgentId;
+      // If set, bypass planning
+      constructor(config2, space, options) {
+        const xConfig = {
+          ...config2,
+          name: "X",
+          description: `I am X, the conversational representative for this space. I manage all aspects of the space and coordinate with other agents to achieve our goals.`
+        };
+        super(xConfig);
+        this.space = space;
+        this.spaceId = space.spaceId;
+        this.singleAgentId = options?.singleAgentId;
+      }
+      /**
+       * Getter for space (needed for external access)
+       */
+      getSpace() {
+        return this.space;
+      }
+      /**
+       * Override getSystemPrompt to include plan and artifacts context
+       */
+      getSystemPrompt(context) {
+        const basePrompt = super.getSystemPrompt(context);
+        return basePrompt + this.getPlanContext() + this.getArtifactsContext();
+      }
+      /**
+       * Generate text - uses new AI SDK-style signature
+       */
+      async generateText(options) {
+        return super.generateText({
+          ...options,
+          spaceId: this.space.spaceId,
+          metadata: {
+            spaceName: this.space.name,
+            spaceGoal: this.space.goal,
+            ...options.metadata
+          }
+        });
+      }
+      /**
+       * ViberAgent streamText - Orchestration Layer
+       * Responsibilities: History management, agent delegation, persistence
+       */
+      async streamText(options) {
+        const {
+          messages,
+          system: systemMessage,
+          spaceId,
+          metadata = {},
+          ...restOptions
+        } = options;
+        console.log("[ViberAgent] Orchestration layer: starting streamText");
+        const mode = metadata?.mode;
+        if (!mode || mode !== "agent") {
+          throw new Error("ViberAgent only supports 'agent' mode");
+        }
+        await this.updateSpaceHistory(messages, metadata);
+        const streamResult = await this.handleAgentMode(
+          messages,
+          systemMessage,
+          spaceId,
+          metadata,
+          restOptions
+        );
+        if (spaceId) {
+          this.handleMessagePersistence(streamResult, messages, spaceId, metadata);
+        }
+        return streamResult;
+      }
+      /**
+       * Agent Mode Handler - Direct delegation with performance optimization
+       * Supports both single agent and parallel execution
+       */
+      async handleAgentMode(messages, systemMessage, spaceId, metadata, restOptions) {
+        const parallelAgents = metadata.parallelAgents;
+        if (parallelAgents && parallelAgents.length > 1) {
+          return this.handleParallelExecution(
+            parallelAgents,
+            messages,
+            systemMessage,
+            spaceId,
+            metadata,
+            restOptions
+          );
+        }
+        const targetAgent = metadata.requestedAgent;
+        if (!targetAgent) {
+          throw new Error("Agent mode requires requestedAgent in metadata");
+        }
+        console.log(
+          `[ViberAgent] Agent mode: direct delegation to '${targetAgent}'`
+        );
+        let agent = this.space.getAgent(targetAgent);
+        if (!agent) {
+          console.log(`[ViberAgent] Loading agent '${targetAgent}' on demand`);
+          const dataAdapter = getServerDataAdapter();
+          const agentConfig = await dataAdapter.getAgent(targetAgent);
+          if (!agentConfig) {
+            throw new Error(`Agent '${targetAgent}' not found`);
+          }
+          agent = new Agent(agentConfig);
+          this.space.registerAgent(targetAgent, agent);
+        }
+        const taskId = metadata?.taskId || metadata?.conversationId || "default";
+        const task = this.space.getOrCreateTask(taskId);
+        const fullHistory = task.history.getMessages();
+        const messagesForAgent = fullHistory.length > 0 ? this.optimizeContextForAgent(fullHistory) : this.optimizeContextForAgent(messages);
+        console.log(
+          `[ViberAgent] Agent mode: using ${messagesForAgent.length} messages from history`
+        );
+        return await agent.streamText({
+          messages: messagesForAgent,
+          system: systemMessage,
+          spaceId,
+          metadata: {
+            ...metadata,
+            delegationType: "direct",
+            userId: this.space.userId
+            // Pass space owner ID for tracking
+          },
+          ...restOptions
+        });
+      }
+      /**
+       * Handle parallel execution of multiple agents
+       */
+      async handleParallelExecution(agentIds, messages, systemMessage, spaceId, metadata, restOptions) {
+        console.log(`[ViberAgent] Parallel execution: ${agentIds.length} agents`);
+        const dataAdapter = getServerDataAdapter();
+        for (const agentId of agentIds) {
+          if (!this.space.getAgent(agentId)) {
+            const agentConfig = await dataAdapter.getAgent(agentId);
+            if (!agentConfig) {
+              throw new Error(`Agent '${agentId}' not found`);
+            }
+            const agent = new Agent(agentConfig);
+            this.space.registerAgent(agentId, agent);
+          }
+        }
+        if (!this.space.parallelEngine) {
+          throw new Error("Parallel execution engine not initialized");
+        }
+        const tasks = agentIds.map((agentId, index) => ({
+          id: `parallel-${agentId}-${Date.now()}-${index}`,
+          agentId,
+          messages: this.optimizeContextForAgent(messages),
+          system: systemMessage,
+          metadata: {
+            ...metadata,
+            delegationType: "parallel",
+            userId: this.space.userId,
+            parallelIndex: index
+          },
+          priority: agentIds.length - index
+          // First agent gets highest priority
+        }));
+        const results = await this.space.parallelEngine.executeParallel(tasks);
+        return {
+          text: results.map((r) => `[${r.agentId}]: ${r.result.text}`).join("\n\n"),
+          toolCalls: results.flatMap((r) => r.result.toolCalls || []),
+          metadata: {
+            ...metadata,
+            parallelResults: results,
+            agentCount: agentIds.length
+          }
+        };
+      }
+      /**
+       * Update space history with new messages
+       * Now supports per-task history
+       */
+      async updateSpaceHistory(messages, metadata) {
+        const taskId = metadata?.taskId || metadata?.conversationId || "default";
+        const task = this.space.getOrCreateTask(taskId);
+        const existingMessages = task.history.getMessages();
+        const newMessages = messages.length > existingMessages.length ? messages.slice(existingMessages.length) : messages;
+        if (newMessages.length > 0) {
+          for (const msg of newMessages) {
+            const formattedMsg = {
+              ...msg,
+              content: typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content : [{ type: "text", text: msg.content }]
+            };
+            task.history.add(formattedMsg);
+          }
+          console.log(
+            `[ViberAgent] Updated task ${taskId} history with ${newMessages.length} new messages`
+          );
+        }
+      }
+      /**
+       * Optimize message context for single-agent performance
+       */
+      optimizeContextForAgent(messages) {
+        return messages.slice(-4);
+      }
+      /**
+       * Extract user prompt from messages for orchestration
+       */
+      extractPromptFromMessages(messages) {
+        const lastMessage = messages[messages.length - 1];
+        if (lastMessage?.role === "user") {
+          const content = lastMessage.content;
+          if (typeof content === "string") {
+            return content;
+          } else if (Array.isArray(content)) {
+            return content.filter((part) => part.type === "text" && part.text).map((part) => part.text).join(" ");
+          }
+        }
+        return "";
+      }
+      /**
+       * Handle message persistence after streaming completes
+       */
+      handleMessagePersistence(streamResult, messages, spaceId, metadata) {
+        (async () => {
+          try {
+            let finalText = "";
+            const toolInvocations = [];
+            for await (const part of streamResult.fullStream) {
+              switch (part.type) {
+                case "text-delta":
+                  if (part.text) {
+                    finalText += part.text;
+                  }
+                  break;
+                case "tool-call":
+                  toolInvocations.push({
+                    toolCallId: part.toolCallId,
+                    toolName: part.toolName,
+                    args: part.args
+                  });
+                  break;
+                case "tool-result":
+                  const toolCall = toolInvocations.find(
+                    (t) => t.toolCallId === part.toolCallId
+                  );
+                  if (toolCall) {
+                    toolCall.result = part.result;
+                  }
+                  break;
+                case "finish":
+                  break;
+                case "error":
+                  console.error("[ViberAgent] Stream error:", part.error);
+                  return;
+              }
+            }
+            const assistantMessage = {
+              role: "assistant",
+              content: [{ type: "text", text: finalText }],
+              id: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+              metadata: {
+                agentName: this.singleAgentId || "team",
+                spaceId,
+                timestamp: Date.now(),
+                ...metadata
+              },
+              ...toolInvocations.length > 0 && { toolInvocations }
+            };
+            const taskId = metadata?.taskId || metadata?.conversationId || "default";
+            const task = this.space.getOrCreateTask(taskId);
+            task.history.add(assistantMessage);
+          } catch (error) {
+            console.error("[ViberAgent] Failed to persist messages:", error);
+          }
+        })();
+      }
+      /**
+       * Save space to storage
+       */
+      async saveSpace() {
+        try {
+          console.log("[ViberAgent] Space persistence handled by database adapter");
+        } catch (error) {
+          console.error("[ViberAgent] Error saving space:", error);
+        }
+      }
+      /**
+       * Stop current operation
+       */
+      stop() {
+        this.space.messageQueue.clear();
+        if (this.abortController) {
+          this.abortController.abort();
+        }
+      }
+      /**
+       * Add message to queue (soft interrupt)
+       */
+      addMessage(message, metadata) {
+        return this.space.messageQueue.add(message, metadata);
+      }
+      /**
+       * Enrich context with space information
+       */
+      enrichContext(context) {
+        return {
+          spaceId: this.space.spaceId,
+          conversationHistory: this.space.history,
+          metadata: {
+            spaceName: this.space.name,
+            spaceGoal: this.space.goal,
+            ...context?.metadata
+          },
+          ...context
+        };
+      }
+      /**
+       * Create or update the space plan
+       */
+      async createPlan(goal) {
+        const planGoal = goal || this.space.goal;
+        const planSchema = z11.object({
+          tasks: z11.array(
+            z11.object({
+              id: z11.string(),
+              title: z11.string(),
+              description: z11.string(),
+              assignedTo: z11.string().optional(),
+              priority: z11.enum(["low", "medium", "high"]).default("medium"),
+              estimatedTime: z11.string().optional(),
+              dependencies: z11.array(
+                z11.object({
+                  taskId: z11.string(),
+                  type: z11.enum(["required", "optional"])
+                })
+              ).default([]),
+              tags: z11.array(z11.string()).default([])
+            })
+          )
+        });
+        const result = await generateText2({
+          model: this.getModel(),
+          system: this.getSystemPrompt() + "\n\nCreate a detailed plan to achieve the goal.",
+          prompt: `Goal: ${planGoal}
+
+Available agents: ${Array.from(
+            this.space.agents.keys()
+          ).join(", ")}`,
+          output: Output.object({ schema: planSchema })
+        });
+        const planData = result.output;
+        const tasks = planData.tasks.map(
+          (taskData) => new Task({
+            ...taskData,
+            status: "pending" /* PENDING */
+          })
+        );
+        const plan = new Plan({
+          goal: planGoal,
+          tasks
+        });
+        await this.space.createPlan(plan);
+        return plan;
+      }
+      /**
+       * Adapt the plan based on new information or user feedback
+       */
+      async adaptPlan(feedback) {
+        if (!this.space.plan) {
+          return this.createPlan(feedback);
+        }
+        const currentPlan = this.space.plan;
+        const progress = currentPlan.getProgressSummary();
+        const adaptSchema = z11.object({
+          preserveTasks: z11.array(z11.string()).describe("IDs of tasks to keep unchanged"),
+          modifyTasks: z11.array(
+            z11.object({
+              id: z11.string(),
+              changes: z11.object({
+                title: z11.string().optional(),
+                description: z11.string().optional(),
+                priority: z11.enum(["low", "medium", "high"]).optional(),
+                assignedTo: z11.string().optional()
+              })
+            })
+          ).describe("Tasks to modify"),
+          removeTasks: z11.array(z11.string()).describe("IDs of tasks to remove"),
+          addTasks: z11.array(
+            z11.object({
+              id: z11.string(),
+              title: z11.string(),
+              description: z11.string(),
+              assignedTo: z11.string().optional(),
+              priority: z11.enum(["low", "medium", "high"]).default("medium"),
+              dependencies: z11.array(
+                z11.object({
+                  taskId: z11.string(),
+                  type: z11.enum(["required", "optional"])
+                })
+              ).default([]),
+              tags: z11.array(z11.string()).default([])
+            })
+          ).describe("New tasks to add"),
+          reasoning: z11.string().describe("Explanation of the plan changes")
+        });
+        const prompt = `
+Current Plan Progress:
+- Total tasks: ${progress.totalTasks}
+- Completed: ${progress.completedTasks}
+- In Progress: ${progress.runningTasks}
+- Pending: ${progress.pendingTasks}
+
+Current Tasks:
+${currentPlan.tasks.map((t) => `- [${t.id}] ${t.title} (${t.status})`).join("\n")}
+
+User Feedback: ${feedback}
+
+Analyze the current plan and adapt it based on the user's feedback.
+Keep completed tasks unless explicitly asked to redo them.
+Preserve tasks that are still relevant.
+Modify, remove, or add tasks as needed to better achieve the goal.
+`;
+        const result = await generateText2({
+          model: this.getModel(),
+          system: this.getSystemPrompt() + "\n\nAdapt the existing plan based on user feedback.",
+          prompt,
+          output: Output.object({ schema: adaptSchema })
+        });
+        const adaptData = result.output;
+        const adaptedTasks = [];
+        for (const taskId of adaptData.preserveTasks) {
+          const task = currentPlan.tasks.find((t) => t.id === taskId);
+          if (task) {
+            adaptedTasks.push(task);
+          }
+        }
+        for (const modification of adaptData.modifyTasks) {
+          const task = currentPlan.tasks.find((t) => t.id === modification.id);
+          if (task) {
+            if (modification.changes.title) task.title = modification.changes.title;
+            if (modification.changes.description)
+              task.description = modification.changes.description;
+            if (modification.changes.priority)
+              task.priority = modification.changes.priority;
+            if (modification.changes.assignedTo)
+              task.assignedTo = modification.changes.assignedTo;
+            adaptedTasks.push(task);
+          }
+        }
+        for (const newTaskData of adaptData.addTasks) {
+          const newTask = new Task({
+            ...newTaskData,
+            status: "pending" /* PENDING */
+          });
+          adaptedTasks.push(newTask);
+        }
+        const adaptedPlan = new Plan({
+          goal: currentPlan.goal,
+          tasks: adaptedTasks
+        });
+        await this.space.createPlan(adaptedPlan);
+        console.log("[Plan Adaptation]", adaptData.reasoning);
+        return adaptedPlan;
+      }
+      /**
+       * Get plan context for system prompt
+       */
+      getPlanContext() {
+        if (!this.space.plan) {
+          return "\n\nNo active plan for this space yet.";
+        }
+        const summary = this.space.plan.getProgressSummary();
+        return `
+
+Current Plan Status:
+- Total tasks: ${summary.totalTasks}
+- Completed: ${summary.completedTasks}
+- Running: ${summary.runningTasks}
+- Pending: ${summary.pendingTasks}
+- Failed: ${summary.failedTasks}
+- Progress: ${summary.progressPercentage.toFixed(1)}%
+`;
+      }
+      /**
+       * Get artifacts context for system prompt
+       */
+      getArtifactsContext() {
+        if (!this.space.artifacts || this.space.artifacts.length === 0) {
+          return "";
+        }
+        const artifactsList = this.space.artifacts.map((a) => `- ${a.title || a.path} (${a.artifactType || "document"})`).join("\n");
+        return `
+
+Available Artifacts:
+${artifactsList}
+
+These artifacts are pre-loaded in the space and can be referenced in your responses.
+`;
+      }
+      /**
+       * Get ViberAgent summary
+       */
+      getSummary() {
+        const base = super.getSummary();
+        return {
+          ...base,
+          spaceId: this.space.spaceId,
+          spaceName: this.space.name,
+          spaceGoal: this.space.goal,
+          planStatus: this.space.plan?.getProgressSummary()
+        };
+      }
+      /**
+       * Static factory to start a new space
+       */
+      static async start(goal, options = {}) {
+        const { spaceId, model, singleAgentId } = options;
+        const id = spaceId || `proj_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const { startSpace: startSpace2 } = await Promise.resolve().then(() => (init_space2(), space_exports2));
+        const space = await startSpace2({
+          spaceId: id,
+          goal,
+          name: goal.slice(0, 50),
+          model
+        });
+        if (!space.viberAgent) {
+          throw new Error("Failed to initialize ViberAgent");
+        }
+        if (singleAgentId) {
+          space.viberAgent.singleAgentId = singleAgentId;
+        }
+        return space.viberAgent;
+      }
+      /**
+       * Static factory to resume an existing space
+       */
+      static async resume(spaceId, options = {}) {
+        const { model } = options;
+        const { SpaceStorageFactory: SpaceStorageFactory2 } = await Promise.resolve().then(() => (init_space(), space_exports));
+        const { startSpace: startSpace2 } = await Promise.resolve().then(() => (init_space2(), space_exports2));
+        const exists = await SpaceStorageFactory2.exists(spaceId);
+        if (!exists) {
+          throw new Error(`Space ${spaceId} not found`);
+        }
+        const storage = await SpaceStorageFactory2.create(spaceId);
+        const spaceData = await storage.readJSON("space.json");
+        if (!spaceData) {
+          throw new Error(`Failed to load space ${spaceId}`);
+        }
+        const space = await startSpace2({
+          spaceId,
+          goal: spaceData.goal,
+          name: spaceData.name,
+          model: model || spaceData.model
+        });
+        if (!space.viberAgent) {
+          throw new Error("Failed to initialize ViberAgent");
+        }
+        const agentId = options.singleAgentId || spaceData.singleAgentId;
+        if (agentId) {
+          space.viberAgent.singleAgentId = agentId;
+        }
+        const messages = await storage.readJSON("messages.json");
+        if (messages && Array.isArray(messages)) {
+          space.history.clear();
+          for (const msg of messages) {
+            const normalizedMsg = { ...msg };
+            if (typeof msg.content === "string") {
+              normalizedMsg.content = [{ type: "text", text: msg.content }];
+            }
+            space.history.add(normalizedMsg);
+          }
+        }
+        return space.viberAgent;
+      }
+    };
+  }
+});
+
+// src/channels/manager.ts
+var manager_exports = {};
+__export(manager_exports, {
+  ChannelManager: () => ChannelManager,
+  channelManager: () => channelManager
+});
+import { EventEmitter as EventEmitter3 } from "events";
+var ChannelManager, channelManager;
+var init_manager = __esm({
+  "src/channels/manager.ts"() {
+    "use strict";
+    init_viber_agent();
+    ChannelManager = class extends EventEmitter3 {
+      channels = /* @__PURE__ */ new Map();
+      conversations = /* @__PURE__ */ new Map();
+      /**
+       * Register a channel
+       */
+      register(channel) {
+        if (this.channels.has(channel.id)) {
+          console.warn(`[ChannelManager] Channel ${channel.id} already registered`);
+          return;
+        }
+        this.channels.set(channel.id, channel);
+        console.log(`[ChannelManager] Registered channel: ${channel.id}`);
+      }
+      /**
+       * Unregister a channel
+       */
+      unregister(id) {
+        this.channels.delete(id);
+        console.log(`[ChannelManager] Unregistered channel: ${id}`);
+      }
+      /**
+       * Get a channel by ID
+       */
+      getChannel(id) {
+        return this.channels.get(id);
+      }
+      /**
+       * Start all registered channels
+       */
+      async startAll() {
+        for (const [id, channel] of this.channels) {
+          try {
+            await channel.start();
+            console.log(`[ChannelManager] Started channel: ${id}`);
+          } catch (error) {
+            console.error(`[ChannelManager] Failed to start channel ${id}:`, error);
+          }
+        }
+      }
+      /**
+       * Stop all registered channels
+       */
+      async stopAll() {
+        for (const [id, channel] of this.channels) {
+          try {
+            await channel.stop();
+            console.log(`[ChannelManager] Stopped channel: ${id}`);
+          } catch (error) {
+            console.error(`[ChannelManager] Failed to stop channel ${id}:`, error);
+          }
+        }
+      }
+      /**
+       * Route an inbound message to ViberAgent
+       */
+      async routeMessage(message) {
+        const { source, conversationId, content, userId } = message;
+        console.log(
+          `[ChannelManager] Routing message from ${source}: ${content.substring(0, 50)}...`
+        );
+        let conversation = this.conversations.get(conversationId);
+        if (!conversation) {
+          const agent = await ViberAgent.start(content, {
+            // Use conversation ID as space ID for isolation
+            spaceId: conversationId
+          });
+          conversation = {
+            channelId: source,
+            agent,
+            startedAt: /* @__PURE__ */ new Date()
+          };
+          this.conversations.set(conversationId, conversation);
+        }
+        try {
+          const result = await conversation.agent.streamText({
+            messages: [{ role: "user", content }],
+            metadata: { userId, source }
+          });
+          const channel = this.channels.get(source);
+          if (!channel) {
+            console.error(`[ChannelManager] Channel not found: ${source}`);
+            return;
+          }
+          for await (const chunk of result.fullStream) {
+            await channel.stream(conversationId, this.mapToStreamEvent(chunk));
+          }
+          await channel.stream(conversationId, {
+            type: "done",
+            agentId: conversation.agent.spaceId
+          });
+        } catch (error) {
+          console.error(`[ChannelManager] Error processing message:`, error);
+          const channel = this.channels.get(source);
+          if (channel) {
+            await channel.stream(conversationId, {
+              type: "error",
+              error: error.message,
+              agentId: conversation?.agent?.spaceId || "unknown"
+            });
+          }
+        }
+      }
+      /**
+       * Handle interrupt signal
+       */
+      async handleInterrupt(signal) {
+        const conversation = this.conversations.get(signal.conversationId);
+        if (conversation) {
+          conversation.agent.stop();
+          this.conversations.delete(signal.conversationId);
+          console.log(
+            `[ChannelManager] Interrupted conversation: ${signal.conversationId}`
+          );
+        }
+      }
+      /**
+       * Map AI SDK stream chunk to AgentStreamEvent
+       */
+      mapToStreamEvent(chunk) {
+        if (chunk.type === "text-delta") {
+          return {
+            type: "text-delta",
+            content: chunk.textDelta,
+            agentId: "viber"
+          };
+        }
+        if (chunk.type === "tool-call") {
+          return {
+            type: "tool-call",
+            tool: chunk.toolName,
+            args: chunk.args,
+            agentId: "viber"
+          };
+        }
+        if (chunk.type === "tool-result") {
+          return {
+            type: "tool-result",
+            tool: chunk.toolName,
+            result: chunk.result,
+            agentId: "viber"
+          };
+        }
+        return {
+          type: "state-change",
+          state: chunk.type,
+          agentId: "viber"
+        };
+      }
+    };
+    channelManager = new ChannelManager();
+  }
+});
+
+// src/channels/dingtalk.ts
+var dingtalk_exports = {};
+__export(dingtalk_exports, {
+  DingTalkChannel: () => DingTalkChannel
+});
+import crypto from "crypto";
+var DingTalkChannel;
+var init_dingtalk = __esm({
+  "src/channels/dingtalk.ts"() {
+    "use strict";
+    DingTalkChannel = class {
+      id = "dingtalk";
+      type = "webhook";
+      config;
+      sessionWebhooks = /* @__PURE__ */ new Map();
+      responseBuffers = /* @__PURE__ */ new Map();
+      constructor(config2) {
+        this.config = config2;
+      }
+      async start() {
+        console.log("[DingTalk] Channel started");
+      }
+      async stop() {
+        this.sessionWebhooks.clear();
+        this.responseBuffers.clear();
+        console.log("[DingTalk] Channel stopped");
+      }
+      /**
+       * Verify webhook signature
+       */
+      verifySignature(timestamp, sign) {
+        const stringToSign = timestamp + "\n" + this.config.appSecret;
+        const hmac = crypto.createHmac("sha256", this.config.appSecret);
+        hmac.update(stringToSign);
+        const expectedSign = hmac.digest("base64");
+        return sign === expectedSign;
+      }
+      /**
+       * Parse webhook payload to InboundMessage
+       */
+      parseWebhook(payload) {
+        this.sessionWebhooks.set(payload.conversationId, payload.sessionWebhook);
+        return {
+          id: payload.msgId,
+          source: this.id,
+          userId: payload.senderId,
+          conversationId: payload.conversationId,
+          content: payload.text?.content || "",
+          metadata: {
+            senderNick: payload.senderNick,
+            conversationType: payload.conversationType,
+            conversationTitle: payload.conversationTitle,
+            robotCode: payload.robotCode
+          }
+        };
+      }
+      async handleMessage(message) {
+        this.responseBuffers.set(message.conversationId, "");
+      }
+      async stream(conversationId, event) {
+        const sessionWebhook = this.sessionWebhooks.get(conversationId);
+        if (!sessionWebhook) {
+          console.error(
+            `[DingTalk] No session webhook for conversation: ${conversationId}`
+          );
+          return;
+        }
+        if (event.type === "text-delta") {
+          const current = this.responseBuffers.get(conversationId) || "";
+          this.responseBuffers.set(conversationId, current + event.content);
+        } else if (event.type === "done") {
+          const text = this.responseBuffers.get(conversationId) || "";
+          await this.sendMessage(sessionWebhook, {
+            msgtype: "markdown",
+            markdown: {
+              title: "Reply",
+              text
+            }
+          });
+          this.responseBuffers.delete(conversationId);
+        } else if (event.type === "error") {
+          await this.sendMessage(sessionWebhook, {
+            msgtype: "text",
+            text: { content: `Error: ${event.error}` }
+          });
+          this.responseBuffers.delete(conversationId);
+        }
+      }
+      /**
+       * Send message via DingTalk session webhook
+       */
+      async sendMessage(webhookUrl, message) {
+        try {
+          const response = await fetch(webhookUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(message)
+          });
+          if (!response.ok) {
+            const error = await response.text();
+            console.error("[DingTalk] Send message failed:", error);
+          }
+        } catch (error) {
+          console.error("[DingTalk] Send message error:", error);
+        }
+      }
+    };
+  }
+});
+
+// src/channels/wecom.ts
+var wecom_exports = {};
+__export(wecom_exports, {
+  WeComChannel: () => WeComChannel
+});
+import crypto2 from "crypto";
+var WeComCrypto, WeComChannel;
+var init_wecom = __esm({
+  "src/channels/wecom.ts"() {
+    "use strict";
+    WeComCrypto = class {
+      token;
+      aesKey;
+      corpId;
+      constructor(token, encodingAESKey, corpId) {
+        this.token = token;
+        this.corpId = corpId;
+        this.aesKey = Buffer.from(encodingAESKey + "=", "base64");
+      }
+      /**
+       * Verify callback URL signature
+       */
+      verifySignature(signature, timestamp, nonce, echostr) {
+        const sortedParams = [this.token, timestamp, nonce, echostr || ""].filter(Boolean).sort().join("");
+        const hash = crypto2.createHash("sha1").update(sortedParams).digest("hex");
+        return hash === signature;
+      }
+      /**
+       * Decrypt message
+       */
+      decrypt(encrypted) {
+        const decipher = crypto2.createDecipheriv(
+          "aes-256-cbc",
+          this.aesKey,
+          this.aesKey.subarray(0, 16)
+        );
+        decipher.setAutoPadding(false);
+        let decrypted = Buffer.concat([
+          decipher.update(Buffer.from(encrypted, "base64")),
+          decipher.final()
+        ]);
+        const padLen = decrypted[decrypted.length - 1];
+        decrypted = decrypted.subarray(0, decrypted.length - padLen);
+        const msgLen = decrypted.readUInt32BE(16);
+        const content = decrypted.subarray(20, 20 + msgLen).toString("utf-8");
+        return content;
+      }
+      /**
+       * Encrypt message for reply
+       */
+      encrypt(message) {
+        const random = crypto2.randomBytes(16);
+        const msgBuffer = Buffer.from(message, "utf-8");
+        const msgLen = Buffer.alloc(4);
+        msgLen.writeUInt32BE(msgBuffer.length);
+        const corpIdBuffer = Buffer.from(this.corpId, "utf-8");
+        const plaintext = Buffer.concat([
+          random,
+          msgLen,
+          msgBuffer,
+          corpIdBuffer
+        ]);
+        const blockSize = 32;
+        const padLen = blockSize - plaintext.length % blockSize;
+        const padding = Buffer.alloc(padLen, padLen);
+        const padded = Buffer.concat([plaintext, padding]);
+        const cipher = crypto2.createCipheriv(
+          "aes-256-cbc",
+          this.aesKey,
+          this.aesKey.subarray(0, 16)
+        );
+        cipher.setAutoPadding(false);
+        const encrypted = Buffer.concat([cipher.update(padded), cipher.final()]);
+        return encrypted.toString("base64");
+      }
+    };
+    WeComChannel = class {
+      id = "wecom";
+      type = "webhook";
+      config;
+      crypto;
+      accessToken = null;
+      tokenExpiry = 0;
+      responseBuffers = /* @__PURE__ */ new Map();
+      constructor(config2) {
+        this.config = config2;
+        this.crypto = new WeComCrypto(config2.token, config2.aesKey, config2.corpId);
+      }
+      async start() {
+        await this.refreshAccessToken();
+        console.log("[WeCom] Channel started");
+      }
+      async stop() {
+        this.accessToken = null;
+        this.responseBuffers.clear();
+        console.log("[WeCom] Channel stopped");
+      }
+      /**
+       * Verify URL callback (for WeCom verification)
+       */
+      verifyUrl(signature, timestamp, nonce, echostr) {
+        if (this.crypto.verifySignature(signature, timestamp, nonce, echostr)) {
+          return this.crypto.decrypt(echostr);
+        }
+        return null;
+      }
+      /**
+       * Parse XML webhook payload
+       */
+      parseWebhook(xmlContent, encrypted) {
+        const decrypted = this.crypto.decrypt(encrypted);
+        const getTag = (xml, tag) => {
+          const match = xml.match(new RegExp(`<${tag}><\\!\\[CDATA\\[(.+?)\\]\\]></${tag}>`));
+          return match ? match[1] : "";
+        };
+        const fromUser = getTag(decrypted, "FromUserName");
+        const content = getTag(decrypted, "Content");
+        const msgId = getTag(decrypted, "MsgId");
+        if (!content) return null;
+        return {
+          id: msgId || crypto2.randomUUID(),
+          source: this.id,
+          userId: fromUser,
+          conversationId: fromUser,
+          // Use user ID as conversation ID
+          content,
+          metadata: {
+            corpId: this.config.corpId,
+            agentId: this.config.agentId
+          }
+        };
+      }
+      async handleMessage(message) {
+        this.responseBuffers.set(message.conversationId, "");
+      }
+      async stream(conversationId, event) {
+        if (event.type === "text-delta") {
+          const current = this.responseBuffers.get(conversationId) || "";
+          this.responseBuffers.set(conversationId, current + event.content);
+        } else if (event.type === "done") {
+          const text = this.responseBuffers.get(conversationId) || "";
+          await this.sendMessage(conversationId, text);
+          this.responseBuffers.delete(conversationId);
+        } else if (event.type === "error") {
+          await this.sendMessage(conversationId, `Error: ${event.error}`);
+          this.responseBuffers.delete(conversationId);
+        }
+      }
+      /**
+       * Send message via WeCom API
+       */
+      async sendMessage(userId, content) {
+        const token = await this.getAccessToken();
+        const url = `https://qyapi.weixin.qq.com/cgi-bin/message/send?access_token=${token}`;
+        try {
+          const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              touser: userId,
+              msgtype: "markdown",
+              agentid: this.config.agentId,
+              markdown: { content }
+            })
+          });
+          const result = await response.json();
+          if (result.errcode !== 0) {
+            console.error("[WeCom] Send message failed:", result);
+          }
+        } catch (error) {
+          console.error("[WeCom] Send message error:", error);
+        }
+      }
+      /**
+       * Get access token (with caching)
+       */
+      async getAccessToken() {
+        if (this.accessToken && Date.now() < this.tokenExpiry) {
+          return this.accessToken;
+        }
+        await this.refreshAccessToken();
+        return this.accessToken;
+      }
+      /**
+       * Refresh access token from WeCom API
+       */
+      async refreshAccessToken() {
+        const url = `https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=${this.config.corpId}&corpsecret=${this.config.secret}`;
+        try {
+          const response = await fetch(url);
+          const result = await response.json();
+          if (result.errcode === 0) {
+            this.accessToken = result.access_token;
+            this.tokenExpiry = Date.now() + (result.expires_in - 300) * 1e3;
+          } else {
+            console.error("[WeCom] Get token failed:", result);
+          }
+        } catch (error) {
+          console.error("[WeCom] Get token error:", error);
+        }
+      }
+    };
+  }
+});
+
+// src/cli/index.ts
+import "dotenv/config";
+import { program } from "commander";
+import * as os2 from "os";
+import * as fs7 from "fs/promises";
+import * as path13 from "path";
+var VERSION = "1.0.0";
+program.name("openviber").description("OpenViber - Workspace-first assistant runtime (vibers on your machines)").version(VERSION);
+program.command("start").description(
+  "Start viber with all apps (local mode, or connect to server with --server)"
+).option("-s, --server <url>", "Command center URL (enables connected mode)").option("-t, --token <token>", "Authentication token (or set VIBER_TOKEN)").option("-n, --name <name>", "Viber name", `${os2.hostname()}-viber`).option("--desktop", "Enable desktop control (UI-TARS)").option("--disable-app <apps...>", "Disable specific apps (comma-separated)").option("--no-apps", "Disable all apps").option("--reconnect-interval <ms>", "Reconnect interval in ms", "5000").option("--heartbeat-interval <ms>", "Heartbeat interval in ms", "30000").action(async (options) => {
+  const { JobScheduler: JobScheduler2 } = await Promise.resolve().then(() => (init_scheduler(), scheduler_exports));
+  const { ViberController: ViberController2 } = await Promise.resolve().then(() => (init_controller(), controller_exports));
+  const { EventEmitter: EventEmitter4 } = await import("events");
   await Promise.resolve().then(() => (init_skills(), skills_exports));
   const viberId = await getViberId();
   const token = options.token || process.env.VIBER_TOKEN;
@@ -6533,6 +9004,166 @@ Viber Status
 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
     `);
 });
+program.command("onboard").description("Initialize OpenViber configuration (first-time setup)").action(async () => {
+  const configDir = path13.join(os2.homedir(), ".openviber");
+  const agentsDir = path13.join(configDir, "agents");
+  const jobsDir = path13.join(configDir, "jobs");
+  const spaceDir = path13.join(configDir, "space");
+  console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551               OPENVIBER SETUP                             \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+  console.log("Creating directories...");
+  await fs7.mkdir(configDir, { recursive: true });
+  await fs7.mkdir(agentsDir, { recursive: true });
+  await fs7.mkdir(jobsDir, { recursive: true });
+  await fs7.mkdir(spaceDir, { recursive: true });
+  console.log(`  \u2713 ${configDir}`);
+  console.log(`  \u2713 ${agentsDir}`);
+  console.log(`  \u2713 ${jobsDir}`);
+  console.log(`  \u2713 ${spaceDir}`);
+  const defaultAgentPath = path13.join(agentsDir, "default.yaml");
+  try {
+    await fs7.access(defaultAgentPath);
+    console.log(`
+  \u23ED agents/default.yaml already exists, skipping`);
+  } catch {
+    const defaultAgent = `# Default Viber Agent Configuration
+name: default
+description: General-purpose assistant
+
+# LLM Provider (openrouter recommended for multi-model access)
+provider: openrouter
+model: anthropic/claude-sonnet-4-20250514
+
+# System prompt
+systemPrompt: |
+  You are a helpful AI assistant running on the user's local machine.
+  You have access to files, terminal, and browser tools.
+  Be concise and helpful.
+
+# Tools available to this agent
+tools:
+  - file
+  - terminal
+  - browser
+
+# Working mode: "always-ask" | "agent-decides" | "always-execute"
+workingMode: agent-decides
+`;
+    await fs7.writeFile(defaultAgentPath, defaultAgent);
+    console.log(`
+  \u2713 Created agents/default.yaml`);
+  }
+  const taskPath = path13.join(spaceDir, "task.md");
+  try {
+    await fs7.access(taskPath);
+  } catch {
+    await fs7.writeFile(taskPath, "# Current Task\n\nNo active task.\n");
+    console.log(`  \u2713 Created space/task.md`);
+  }
+  const memoryPath = path13.join(spaceDir, "MEMORY.md");
+  try {
+    await fs7.access(memoryPath);
+  } catch {
+    await fs7.writeFile(memoryPath, "# Memory\n\nLong-term notes and context.\n");
+    console.log(`  \u2713 Created space/MEMORY.md`);
+  }
+  const viberId = await getViberId();
+  console.log(`
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+Setup complete!
+
+Your viber ID: ${viberId}
+Config directory: ${configDir}
+
+Next steps:
+  1. Set your API key:
+     export OPENROUTER_API_KEY="sk-or-v1-xxx"
+
+  2. Start your viber:
+     openviber start
+
+  3. Or run a quick task:
+     openviber run "Hello, what can you do?"
+
+Get an API key at: https://openrouter.ai/keys
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`);
+});
+program.command("gateway").description("Start the enterprise channel gateway (DingTalk, WeCom, etc.)").option("-p, --port <port>", "Gateway port", "6009").action(async (options) => {
+  const { channelManager: channelManager2 } = await Promise.resolve().then(() => (init_manager(), manager_exports));
+  const { DingTalkChannel: DingTalkChannel2 } = await Promise.resolve().then(() => (init_dingtalk(), dingtalk_exports));
+  const { WeComChannel: WeComChannel2 } = await Promise.resolve().then(() => (init_wecom(), wecom_exports));
+  console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                   GATEWAY STARTING                        \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+  const channels = [];
+  if (process.env.DINGTALK_APP_KEY && process.env.DINGTALK_APP_SECRET) {
+    channelManager2.register(
+      new DingTalkChannel2({
+        enabled: true,
+        appKey: process.env.DINGTALK_APP_KEY,
+        appSecret: process.env.DINGTALK_APP_SECRET,
+        robotCode: process.env.DINGTALK_ROBOT_CODE
+      })
+    );
+    channels.push("DingTalk");
+  }
+  if (process.env.WECOM_CORP_ID && process.env.WECOM_AGENT_SECRET && process.env.WECOM_TOKEN && process.env.WECOM_ENCODING_AES_KEY) {
+    channelManager2.register(
+      new WeComChannel2({
+        enabled: true,
+        corpId: process.env.WECOM_CORP_ID,
+        agentId: process.env.WECOM_AGENT_ID || "0",
+        secret: process.env.WECOM_AGENT_SECRET,
+        token: process.env.WECOM_TOKEN,
+        aesKey: process.env.WECOM_ENCODING_AES_KEY
+      })
+    );
+    channels.push("WeCom");
+  }
+  if (channels.length === 0) {
+    console.log(`
+No channels configured. Set environment variables to enable channels:
+
+DingTalk:
+  DINGTALK_APP_KEY, DINGTALK_APP_SECRET, DINGTALK_ROBOT_CODE
+
+WeCom:
+  WECOM_CORP_ID, WECOM_AGENT_ID, WECOM_AGENT_SECRET
+  WECOM_TOKEN, WECOM_ENCODING_AES_KEY (optional)
+
+Run 'openviber gateway' again after setting environment variables.
+`);
+    process.exit(1);
+  }
+  await channelManager2.startAll();
+  process.on("SIGINT", async () => {
+    console.log("\n[Gateway] Shutting down...");
+    await channelManager2.stopAll();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    console.log("\n[Gateway] Shutting down...");
+    await channelManager2.stopAll();
+    process.exit(0);
+  });
+  console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                   GATEWAY RUNNING                         \u2551
+\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563
+\u2551  Channels:     ${channels.join(", ").padEnd(41)}\u2551
+\u2551  Status:       \u25CF Ready                                    \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+
+Listening for messages from enterprise channels...
+Press Ctrl+C to stop.
+`);
+});
 async function getViberId() {
   const configDir = path13.join(os2.homedir(), ".openviber");
   const idFile = path13.join(configDir, "viber-id");