@rehpic/vcli 0.1.0-beta.96.1 → 0.1.0-beta.99.4

package/dist/index.js

@@ -1462,22 +1462,142 @@ function discoverAttachableSessions() {
     ...discoverClaudeSessions()
   ]);
 }
-async function resumeProviderSession(provider, sessionKey, cwd, prompt2) {
+async function launchProviderSession(provider, cwd, prompt2, onEvent) {
   if (provider === "codex") {
     return runCodexAppServerTurn({
+      cwd,
+      prompt: prompt2,
+      launchCommand: "codex app-server",
+      onEvent
+    });
+  }
+  if (provider === "claude_code") {
+    return runClaudeSdkTurn({
+      cwd,
+      prompt: prompt2,
+      launchCommand: "@anthropic-ai/claude-agent-sdk query()",
+      onEvent
+    });
+  }
+  return runGenericCliAgentTurn({
+    provider,
+    cwd,
+    prompt: prompt2,
+    launchCommand: genericProviderLaunchCommand(provider),
+    onEvent
+  });
+}
+async function resumeProviderSession(provider, sessionKey, cwd, prompt2, onEvent) {
+  if (provider === "codex") {
+    return runCodexAppServerTurn({
+      cwd,
+      prompt: prompt2,
+      sessionKey,
+      launchCommand: "codex app-server (thread/resume)",
+      onEvent
+    });
+  }
+  if (provider === "claude_code") {
+    return runClaudeSdkTurn({
       cwd,
       prompt: prompt2,
       sessionKey,
-      launchCommand: "codex app-server (thread/resume)"
+      launchCommand: "@anthropic-ai/claude-agent-sdk query(resume)",
+      onEvent
     });
   }
-  return runClaudeSdkTurn({
+  return runGenericCliAgentTurn({
+    provider,
     cwd,
     prompt: prompt2,
     sessionKey,
-    launchCommand: "@anthropic-ai/claude-agent-sdk query(resume)"
+    launchCommand: genericProviderLaunchCommand(provider),
+    onEvent
   });
 }
+async function runGenericCliAgentTurn(args) {
+  const command = genericProviderCommand(args.provider);
+  const child = spawn2(command.bin, [...command.args, args.prompt], {
+    cwd: args.cwd,
+    env: { ...process.env },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stdout = "";
+  let stderr = "";
+  await Promise.resolve(
+    args.onEvent?.({
+      provider: args.provider,
+      role: "status",
+      text: `Starting ${providerLabel(args.provider)} CLI session`,
+      status: "in_progress"
+    })
+  );
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk.toString();
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  const exit = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code, signal) => resolve({ code, signal }));
+  });
+  if (exit.code && exit.code !== 0) {
+    const message = stderr.trim() || `${providerLabel(args.provider)} exited with code ${exit.code}`;
+    await Promise.resolve(
+      args.onEvent?.({
+        provider: args.provider,
+        role: "error",
+        text: message,
+        title: `${providerLabel(args.provider)} failed`,
+        status: "failed"
+      })
+    );
+    throw new Error(message);
+  }
+  const responseText = stdout.trim();
+  if (responseText) {
+    await Promise.resolve(
+      args.onEvent?.({
+        provider: args.provider,
+        role: "assistant",
+        text: responseText,
+        status: "completed"
+      })
+    );
+  }
+  return {
+    provider: args.provider,
+    providerLabel: providerLabel(args.provider),
+    sessionKey: args.sessionKey ?? `${args.provider}:${Date.now()}`,
+    cwd: args.cwd,
+    ...getGitInfo(args.cwd),
+    title: summarizeTitle(responseText, args.cwd) ?? providerLabel(args.provider),
+    mode: "managed",
+    status: "waiting",
+    supportsInboundMessages: true,
+    responseText,
+    launchCommand: args.launchCommand
+  };
+}
+function genericProviderCommand(provider) {
+  if (provider === "cursor") return { bin: "cursor-agent", args: ["--print"] };
+  if (provider === "copilot") return { bin: "copilot", args: [] };
+  if (provider === "opencode") return { bin: "opencode", args: ["run"] };
+  return { bin: "pi", args: [] };
+}
+function genericProviderLaunchCommand(provider) {
+  const command = genericProviderCommand(provider);
+  return [command.bin, ...command.args].join(" ");
+}
+function providerLabel(provider) {
+  if (provider === "codex") return "Codex";
+  if (provider === "claude_code") return "Claude";
+  if (provider === "cursor") return "Cursor";
+  if (provider === "copilot") return "GitHub Copilot";
+  if (provider === "opencode") return "OpenCode";
+  return "Pi";
+}
 async function runCodexAppServerTurn(args) {
   const child = spawn2("codex", ["app-server"], {
     cwd: args.cwd,
@@ -1488,6 +1608,8 @@ async function runCodexAppServerTurn(args) {
   let stdoutBuffer = "";
   let sessionKey = args.sessionKey;
   let finalAssistantText = "";
+  let activeAssistantText = "";
+  const eventWrites = [];
   let completed = false;
   let nextRequestId = 1;
   const pending = /* @__PURE__ */ new Map();
@@ -1503,6 +1625,9 @@ async function runCodexAppServerTurn(args) {
       reject(error);
     };
   });
+  const emitEvent = (event) => {
+    eventWrites.push(Promise.resolve(args.onEvent?.(event)));
+  };
   child.stdout.on("data", (chunk) => {
     stdoutBuffer += chunk.toString();
     while (true) {
@@ -1519,11 +1644,11 @@ async function runCodexAppServerTurn(args) {
       if (!payload || typeof payload !== "object") {
         continue;
       }
-      const responseId = payload.id;
+      const responseId = readProperty(payload, "id");
       if (typeof responseId === "number" && pending.has(responseId)) {
         const entry = pending.get(responseId);
         pending.delete(responseId);
-        const errorRecord = asObject(payload.error);
+        const errorRecord = asObject(readProperty(payload, "error"));
         if (errorRecord) {
           entry.reject(
             new Error(
@@ -1532,11 +1657,11 @@ async function runCodexAppServerTurn(args) {
           );
           continue;
         }
-        entry.resolve(payload.result);
+        entry.resolve(readProperty(payload, "result"));
         continue;
       }
-      const method = asString(payload.method);
-      const params = asObject(payload.params);
+      const method = asString(readProperty(payload, "method"));
+      const params = asObject(readProperty(payload, "params"));
       if (!method || !params) {
         continue;
       }
@@ -1545,13 +1670,46 @@ async function runCodexAppServerTurn(args) {
         continue;
       }
       if (method === "item/agentMessage/delta") {
-        finalAssistantText += asString(params.delta) ?? "";
+        const delta = asString(params.delta) ?? "";
+        finalAssistantText += delta;
+        activeAssistantText += delta;
         continue;
       }
       if (method === "item/completed") {
         const item = asObject(params.item);
-        if (asString(item?.type) === "agentMessage") {
+        const itemType = asString(item?.type);
+        if (itemType === "agentMessage") {
           finalAssistantText = asString(item?.text) ?? finalAssistantText;
+          const text2 = finalAssistantText || activeAssistantText;
+          if (text2.trim()) {
+            emitEvent({
+              provider: "codex",
+              role: "assistant",
+              text: text2.trim(),
+              status: "completed"
+            });
+          }
+          activeAssistantText = "";
+        } else if (itemType === "reasoning") {
+          const text2 = asString(item?.text) ?? asString(item?.summary);
+          if (text2?.trim()) {
+            emitEvent({
+              provider: "codex",
+              role: "reasoning",
+              text: text2.trim(),
+              status: "completed"
+            });
+          }
+        } else if (itemType === "toolCall") {
+          const title = asString(item?.title) ?? asString(item?.name) ?? asString(item?.command) ?? "Tool";
+          const text2 = asString(item?.text) ?? asString(item?.output) ?? asString(item?.command) ?? title;
+          emitEvent({
+            provider: "codex",
+            role: "tool",
+            title,
+            text: text2,
+            status: asString(item?.status) === "failed" ? "failed" : "completed"
+          });
         }
         continue;
       }
@@ -1560,12 +1718,25 @@ async function runCodexAppServerTurn(args) {
         const status = asString(turn?.status);
         if (status === "failed") {
           const turnError = asObject(turn?.error);
+          emitEvent({
+            provider: "codex",
+            role: "error",
+            title: "Codex turn failed",
+            text: asString(turnError?.message) ?? "Codex turn failed without an error message",
+            status: "failed"
+          });
           failTurn?.(
             new Error(
               asString(turnError?.message) ?? "Codex turn failed without an error message"
             )
           );
         } else if (status === "interrupted") {
+          emitEvent({
+            provider: "codex",
+            role: "status",
+            text: "Codex turn was interrupted",
+            status: "failed"
+          });
           failTurn?.(new Error("Codex turn was interrupted"));
         } else {
           completeTurn?.();
@@ -1607,21 +1778,23 @@ async function runCodexAppServerTurn(args) {
       waitForExit
     ]);
     notify("initialized", {});
-    const threadResult = await Promise.race([
-      args.sessionKey ? request("thread/resume", {
-        threadId: args.sessionKey,
-        cwd: args.cwd,
-        approvalPolicy: "never",
-        personality: "pragmatic"
-      }) : request("thread/start", {
-        cwd: args.cwd,
-        approvalPolicy: "never",
-        personality: "pragmatic",
-        serviceName: "vector_bridge"
-      }),
-      waitForExit
-    ]);
-    sessionKey = asString(asObject(threadResult.thread)?.id) ?? asString(asObject(threadResult.thread)?.threadId) ?? sessionKey;
+    const threadResult = asObject(
+      await Promise.race([
+        args.sessionKey ? request("thread/resume", {
+          threadId: args.sessionKey,
+          cwd: args.cwd,
+          approvalPolicy: "never",
+          personality: "pragmatic"
+        }) : request("thread/start", {
+          cwd: args.cwd,
+          approvalPolicy: "never",
+          personality: "pragmatic",
+          serviceName: "vector_bridge"
+        }),
+        waitForExit
+      ])
+    );
+    sessionKey = asString(asObject(readProperty(threadResult, "thread"))?.id) ?? asString(asObject(readProperty(threadResult, "thread"))?.threadId) ?? sessionKey;
     if (!sessionKey) {
       throw new Error("Codex app-server did not return a thread id");
     }
@@ -1636,6 +1809,7 @@ async function runCodexAppServerTurn(args) {
       waitForExit
     ]);
     await Promise.race([turnCompleted, waitForExit]);
+    await Promise.allSettled(eventWrites);
     const gitInfo = getGitInfo(args.cwd);
     return {
       provider: "codex",
@@ -1684,30 +1858,40 @@ async function runClaudeSdkTurn(args) {
       if (!message || typeof message !== "object") {
         continue;
       }
-      sessionKey = asString(message.session_id) ?? sessionKey;
-      if (message.type === "assistant") {
+      sessionKey = asString(readProperty(message, "session_id")) ?? sessionKey;
+      if (readProperty(message, "type") === "assistant") {
         const assistantText = extractClaudeMessageTexts(
-          message.message
+          readProperty(message, "message")
         ).join("\n\n").trim();
         if (assistantText) {
           responseText = assistantText;
+          await args.onEvent?.({
+            provider: "claude_code",
+            role: "assistant",
+            text: assistantText,
+            status: "completed"
+          });
         }
         continue;
       }
-      if (message.type !== "result") {
+      if (readProperty(message, "type") !== "result") {
         continue;
       }
-      if (message.subtype === "success") {
-        const resultText = asString(message.result);
+      if (readProperty(message, "subtype") === "success") {
+        const resultText = asString(readProperty(message, "result"));
         if (resultText) {
           responseText = resultText;
+          await args.onEvent?.({
+            provider: "claude_code",
+            role: "assistant",
+            text: resultText,
+            status: "completed"
+          });
         }
-        model = firstObjectKey(
-          message.modelUsage
-        );
+        model = firstObjectKey(readProperty(message, "modelUsage"));
         continue;
       }
-      const errors = message.errors;
+      const errors = readProperty(message, "errors");
       const detail = Array.isArray(errors) && errors.length > 0 ? errors.join("\n") : "Claude execution failed";
       throw new Error(detail);
     }
@@ -2117,11 +2301,17 @@ function normalizeModelKey(value) {
   return normalized || void 0;
 }
 function asObject(value) {
-  return value && typeof value === "object" ? value : void 0;
+  return isRecord(value) ? value : void 0;
+}
+function readProperty(value, key) {
+  return isRecord(value) ? Reflect.get(value, key) : void 0;
 }
 function asString(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
 function pushIfPresent(target, value) {
   const text2 = asString(value);
   if (text2) {
@@ -2285,11 +2475,13 @@ function getGitInfo(cwd) {
     const repoRoot = execSync("git rev-parse --show-toplevel", {
       encoding: "utf-8",
       cwd,
+      stdio: ["ignore", "pipe", "ignore"],
       timeout: 3e3
     }).trim();
     const branch = execSync("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf-8",
       cwd,
+      stdio: ["ignore", "pipe", "ignore"],
       timeout: 3e3
     }).trim();
     return {
@@ -2341,6 +2533,8 @@ var BridgeService = class {
   constructor(config) {
     this.timers = [];
     this.terminalPeer = null;
+    this.stopping = false;
+    this.runningLoops = /* @__PURE__ */ new Set();
     this.deviceLiveActivities = [];
     this.config = config;
     this.client = new ConvexHttpClient2(config.convexUrl);
@@ -2366,6 +2560,30 @@ var BridgeService = class {
       await this.handleCommand(cmd);
     }
   }
+  scheduleLoop(name, intervalMs, run) {
+    this.timers.push(
+      setInterval(() => {
+        if (this.stopping || this.runningLoops.has(name)) {
+          return;
+        }
+        this.runningLoops.add(name);
+        run().catch((error) => {
+          const message = error instanceof Error ? error.message : String(error);
+          console.error(`[${ts2()}] ${name} error:`, message);
+        }).finally(() => {
+          this.runningLoops.delete(name);
+        });
+      }, intervalMs)
+    );
+  }
+  async runStartupStep(label, step) {
+    try {
+      await step();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`[${ts2()}] Startup ${label} failed: ${message}`);
+    }
+  }
   async handleCommand(cmd) {
     const claimed = await this.client.mutation(
       api.agentBridge.bridgePublic.claimCommand,
@@ -2378,6 +2596,18 @@ var BridgeService = class {
     if (!claimed) {
       return;
     }
+    if (cmd.kind === "settings_update" || cmd.kind === "queue_update" || cmd.kind === "approval_response" || cmd.kind === "plan_response" || cmd.kind === "question_response" || cmd.kind === "stop" || cmd.kind === "resume") {
+      try {
+        await this.handleAgentControlCommand(cmd);
+        await this.completeCommand(cmd._id, "delivered");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown bridge error";
+        console.error(`  ! ${message}`);
+        await this.postCommandError(cmd, message);
+        await this.completeCommand(cmd._id, "failed");
+      }
+      return;
+    }
     console.log(`  ${cmd.kind}: ${cmd._id}`);
     try {
       switch (cmd.kind) {
@@ -2526,20 +2756,20 @@ var BridgeService = class {
     await this.postAgentMessage(
       activity._id,
       "status",
-      `Verified ${providerLabel(attachedSession.process.provider)} in ${activity.tmuxPaneId}`
+      `Verified ${providerLabel2(attachedSession.process.provider)} in ${activity.tmuxPaneId}`
     );
     await this.updateLiveActivity(activity._id, {
       status: "active",
-      latestSummary: `Verified ${providerLabel(attachedSession.process.provider)} in ${activity.tmuxPaneId}`,
+      latestSummary: `Verified ${providerLabel2(attachedSession.process.provider)} in ${activity.tmuxPaneId}`,
       processId: attachedSession.processId,
       title: activity.title
     });
   }
   async refreshWorkSessionTerminal(workSessionId, metadata) {
-    if (!workSessionId || !metadata.tmuxPaneId) {
+    if (!workSessionId) {
       return;
     }
-    const terminalSnapshot = captureTmuxPane(metadata.tmuxPaneId);
+    const terminalSnapshot = metadata.tmuxPaneId ? captureTmuxPane(metadata.tmuxPaneId) : void 0;
     await this.client.mutation(
       api.agentBridge.bridgePublic.updateWorkSessionTerminal,
       {
@@ -2554,7 +2784,13 @@ var BridgeService = class {
         repoRoot: metadata.repoRoot,
         branch: metadata.branch,
         agentProvider: metadata.agentProvider,
-        agentSessionKey: metadata.agentSessionKey
+        agentSessionKey: metadata.agentSessionKey,
+        agentProcessId: metadata.agentProcessId,
+        model: metadata.model,
+        permissionMode: metadata.permissionMode,
+        thinkingLevel: metadata.thinkingLevel,
+        fastMode: metadata.fastMode,
+        contextLength: metadata.contextLength
       }
     );
   }
@@ -2584,51 +2820,60 @@ var BridgeService = class {
       );
     }
     console.log("");
-    await this.heartbeat();
-    await this.reportProcesses();
-    await this.refreshLiveActivities();
-    await this.syncWorkSessionTerminals(this.deviceLiveActivities);
+    process.on("uncaughtException", (error) => {
+      console.error(`[${ts2()}] Uncaught error:`, error.message);
+    });
+    process.on("unhandledRejection", (reason) => {
+      console.error(
+        `[${ts2()}] Unhandled rejection:`,
+        reason instanceof Error ? reason.message : String(reason)
+      );
+    });
+    await this.runStartupStep("heartbeat", () => this.heartbeat());
+    await this.runStartupStep(
+      "process discovery",
+      () => this.reportProcesses()
+    );
+    await this.runStartupStep(
+      "live activity sync",
+      () => this.refreshLiveActivities()
+    );
+    await this.runStartupStep(
+      "terminal snapshot sync",
+      () => this.syncWorkSessionTerminals(this.deviceLiveActivities)
+    );
     console.log(`[${ts2()}] Service running. Ctrl+C to stop.
 `);
-    this.timers.push(
-      setInterval(() => {
-        this.heartbeat().catch(
-          (e) => console.error(`[${ts2()}] Heartbeat error:`, e.message)
-        );
-      }, HEARTBEAT_INTERVAL_MS)
+    this.scheduleLoop(
+      "Heartbeat",
+      HEARTBEAT_INTERVAL_MS,
+      () => this.heartbeat()
     );
-    this.timers.push(
-      setInterval(() => {
-        this.pollCommands().catch(
-          (e) => console.error(`[${ts2()}] Command poll error:`, e.message)
-        );
-      }, COMMAND_POLL_INTERVAL_MS)
+    this.scheduleLoop(
+      "Command poll",
+      COMMAND_POLL_INTERVAL_MS,
+      () => this.pollCommands()
     );
-    this.timers.push(
-      setInterval(() => {
-        this.refreshLiveActivities().catch(
-          (e) => console.error(`[${ts2()}] Live activity sync error:`, e.message)
-        );
-      }, LIVE_ACTIVITY_SYNC_INTERVAL_MS)
+    this.scheduleLoop(
+      "Live activity sync",
+      LIVE_ACTIVITY_SYNC_INTERVAL_MS,
+      () => this.refreshLiveActivities()
     );
-    this.timers.push(
-      setInterval(() => {
-        this.reportProcesses().catch(
-          (e) => console.error(`[${ts2()}] Discovery error:`, e.message)
-        );
-      }, PROCESS_DISCOVERY_INTERVAL_MS)
+    this.scheduleLoop(
+      "Discovery",
+      PROCESS_DISCOVERY_INTERVAL_MS,
+      () => this.reportProcesses()
     );
-    this.timers.push(
-      setInterval(() => {
-        this.syncWorkSessionTerminals(this.deviceLiveActivities).catch(
-          (e) => console.error(
-            `[${ts2()}] Terminal snapshot refresh error:`,
-            e.message
-          )
-        );
-      }, TERMINAL_SNAPSHOT_REFRESH_INTERVAL_MS)
+    this.scheduleLoop(
+      "Terminal snapshot refresh",
+      TERMINAL_SNAPSHOT_REFRESH_INTERVAL_MS,
+      () => this.syncWorkSessionTerminals(this.deviceLiveActivities)
     );
     const shutdown = () => {
+      if (this.stopping) {
+        return;
+      }
+      this.stopping = true;
       console.log(`
 [${ts2()}] Shutting down...`);
       for (const t of this.timers) clearInterval(t);
@@ -2652,15 +2897,16 @@ var BridgeService = class {
     if (!cmd.liveActivityId) {
       throw new Error("Message command is missing liveActivityId");
     }
-    const payload = cmd.payload;
-    const body = payload?.body?.trim();
+    const body = readPayloadString(cmd.payload, "body")?.trim();
     if (!body) {
       throw new Error("Message command is missing a body");
     }
+    const issueContext = readPayloadValue(cmd.payload, "issueContext");
     const process9 = cmd.process;
     console.log(`  > "${truncateForLog(body)}"`);
     if (cmd.workSession?.tmuxPaneId) {
-      sendTextToTmuxPane(cmd.workSession.tmuxPaneId, body);
+      const terminalInput = cmd.workSession.agentProvider && isBridgeProvider(cmd.workSession.agentProvider) ? buildFollowUpPrompt(body, issueContext) : body;
+      sendTextToTmuxPane(cmd.workSession.tmuxPaneId, terminalInput);
       const attachedSession = cmd.workSession.agentProvider && isBridgeProvider(cmd.workSession.agentProvider) ? await this.attachObservedAgentSession(
         cmd.workSession.agentProvider,
         cmd.workSession.workspacePath ?? cmd.workSession.cwd ?? process9?.cwd
@@ -2693,13 +2939,17 @@ var BridgeService = class {
     }
     await this.reportProcess({
       provider: process9.provider,
-      providerLabel: process9.providerLabel ?? providerLabel(process9.provider),
+      providerLabel: process9.providerLabel ?? providerLabel2(process9.provider),
       sessionKey: process9.sessionKey,
       cwd: process9.cwd,
       repoRoot: process9.repoRoot,
       branch: process9.branch,
       title: process9.title,
       model: process9.model,
+      permissionMode: process9.permissionMode,
+      thinkingLevel: process9.thinkingLevel,
+      fastMode: process9.fastMode,
+      contextLength: process9.contextLength,
       mode: "managed",
       status: "waiting",
       supportsInboundMessages: true
@@ -2709,14 +2959,20 @@ var BridgeService = class {
       processId: process9._id,
       title: cmd.liveActivity?.title ?? process9.title
     });
+    const liveActivityId = cmd.liveActivityId;
+    let emittedAssistantEvent = false;
     const result = await resumeProviderSession(
       process9.provider,
       process9.sessionKey,
       process9.cwd,
-      body
+      buildFollowUpPrompt(body, issueContext),
+      (event) => {
+        if (event.role === "assistant") emittedAssistantEvent = true;
+        return this.postAgentSessionEvent(liveActivityId, event);
+      }
     );
     const processId = await this.reportProcess(result);
-    if (result.responseText) {
+    if (result.responseText && !emittedAssistantEvent) {
       await this.postAgentMessage(
         cmd.liveActivityId,
         "assistant",
@@ -2732,9 +2988,8 @@ var BridgeService = class {
     });
   }
   async handleResizeCommand(cmd) {
-    const payload = cmd.payload;
-    const cols = payload?.cols;
-    const rows = payload?.rows;
+    const cols = readPayloadNumber(cmd.payload, "cols");
+    const rows = readPayloadNumber(cmd.payload, "rows");
     const paneId = cmd.workSession?.tmuxPaneId;
     if (!paneId || !cols || !rows) {
       throw new Error("Resize command missing paneId, cols, or rows");
@@ -2754,35 +3009,142 @@ var BridgeService = class {
       });
     }
   }
+  async handleAgentControlCommand(cmd) {
+    if (!cmd.liveActivityId) {
+      throw new Error(`${cmd.kind} command is missing liveActivityId`);
+    }
+    if (cmd.kind === "settings_update") {
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "status",
+        "Updated agent settings"
+      );
+      return;
+    }
+    if (cmd.kind === "queue_update") {
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "status",
+        "Updated queued agent messages"
+      );
+      return;
+    }
+    if (cmd.kind === "stop") {
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "paused",
+        latestSummary: "Agent turn stop requested"
+      });
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "status",
+        "Stop requested for the local agent session"
+      );
+      return;
+    }
+    if (cmd.kind === "resume") {
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "active",
+        latestSummary: "Agent session resumed"
+      });
+      return;
+    }
+    const label = cmd.kind === "approval_response" ? "approval" : cmd.kind === "plan_response" ? "plan approval" : "question response";
+    await this.postAgentMessage(
+      cmd.liveActivityId,
+      "status",
+      `Received ${label}; the provider runtime will continue when supported`
+    );
+  }
   async handleLaunchCommand(cmd) {
     if (!cmd.liveActivityId) {
       throw new Error("Launch command is missing liveActivityId");
     }
-    const payload = cmd.payload;
-    const workspacePath = payload?.workspacePath?.trim();
+    const workspacePath = readPayloadString(
+      cmd.payload,
+      "workspacePath"
+    )?.trim();
     if (!workspacePath) {
       throw new Error("Launch command is missing workspacePath");
     }
-    const requestedProvider = payload?.provider;
+    const requestedProvider = readPayloadAgentProvider(cmd.payload, "provider");
     const provider = requestedProvider && isBridgeProvider(requestedProvider) ? requestedProvider : void 0;
-    const issueKey = payload?.issueKey ?? cmd.liveActivity?.issueKey ?? "ISSUE";
-    const issueTitle = payload?.issueTitle ?? cmd.liveActivity?.issueTitle ?? "Untitled issue";
-    const issueDescription = payload?.issueDescription;
+    const issueKey = readPayloadString(cmd.payload, "issueKey") ?? cmd.liveActivity?.issueKey ?? "ISSUE";
+    const issueTitle = readPayloadString(cmd.payload, "issueTitle") ?? cmd.liveActivity?.issueTitle ?? "Untitled issue";
+    const issueDescription = readPayloadString(cmd.payload, "issueDescription");
+    const issueContext = readPayloadValue(cmd.payload, "issueContext");
+    const model = readPayloadString(cmd.payload, "model");
+    const permissionMode = readPayloadPermissionMode(
+      cmd.payload,
+      "permissionMode"
+    );
+    const thinkingLevel = readPayloadThinkingLevel(
+      cmd.payload,
+      "thinkingLevel"
+    );
+    const fastMode = readPayloadBoolean(cmd.payload, "fastMode");
+    const contextLength = readPayloadContextLength(
+      cmd.payload,
+      "contextLength"
+    );
+    const initialPrompt = readPayloadString(cmd.payload, "initialPrompt");
+    const delegatedRunId = readPayloadId(
+      cmd.payload,
+      "delegatedRunId"
+    );
     const prompt2 = buildLaunchPrompt(
       issueKey,
       issueTitle,
       workspacePath,
-      issueDescription
+      issueDescription,
+      issueContext,
+      initialPrompt
     );
-    const launchLabel = provider ? providerLabel(provider) : "shell session";
+    const launchLabel = provider ? providerLabel2(provider) : "shell session";
     const workSessionTitle = `${issueKey}: ${issueTitle}`;
     await this.updateLiveActivity(cmd.liveActivityId, {
       status: "active",
       latestSummary: `Launching ${launchLabel} in ${workspacePath}`,
-      delegatedRunId: payload?.delegatedRunId,
+      delegatedRunId,
       launchStatus: "launching",
       title: workSessionTitle
     });
+    if (provider) {
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "status",
+        `Starting ${launchLabel} session in ${workspacePath}`
+      );
+      const liveActivityId = cmd.liveActivityId;
+      const result = await launchProviderSession(
+        provider,
+        workspacePath,
+        prompt2,
+        (event) => this.postAgentSessionEvent(liveActivityId, event)
+      );
+      const processId = await this.reportProcess(result);
+      await this.refreshWorkSessionTerminal(cmd.workSession?._id, {
+        cwd: workspacePath,
+        repoRoot: result.repoRoot ?? workspacePath,
+        branch: result.branch ?? currentGitBranch(workspacePath),
+        agentProvider: result.provider,
+        agentSessionKey: result.sessionKey,
+        agentProcessId: processId,
+        model,
+        permissionMode,
+        thinkingLevel,
+        fastMode,
+        contextLength
+      });
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "waiting_for_input",
+        latestSummary: summarizeMessage(result.responseText),
+        delegatedRunId,
+        launchStatus: "running",
+        title: workSessionTitle,
+        processId
+      });
+      return;
+    }
     const tmuxSession = createTmuxWorkSession({
       workspacePath,
       issueKey,
@@ -2797,12 +3159,17 @@ var BridgeService = class {
       cwd: workspacePath,
       repoRoot: workspacePath,
       branch: currentGitBranch(workspacePath),
-      agentProvider: provider
+      agentProvider: provider,
+      model,
+      permissionMode,
+      thinkingLevel,
+      fastMode,
+      contextLength
     });
     await this.updateLiveActivity(cmd.liveActivityId, {
       status: "active",
       latestSummary: `Running ${launchLabel} in ${tmuxSession.sessionName}`,
-      delegatedRunId: payload?.delegatedRunId,
+      delegatedRunId,
       launchStatus: "running",
       title: workSessionTitle
     });
@@ -2836,7 +3203,7 @@ var BridgeService = class {
   async reportProcess(process9) {
     const {
       provider,
-      providerLabel: providerLabel2,
+      providerLabel: providerLabel3,
       localProcessId,
       sessionKey,
       cwd,
@@ -2844,6 +3211,10 @@ var BridgeService = class {
       branch,
       title,
       model,
+      permissionMode,
+      thinkingLevel,
+      fastMode,
+      contextLength,
       tmuxSessionName,
       tmuxWindowName,
       tmuxPaneId,
@@ -2857,7 +3228,7 @@ var BridgeService = class {
         deviceId: this.config.deviceId,
         deviceSecret: this.config.deviceSecret,
         provider,
-        providerLabel: providerLabel2,
+        providerLabel: providerLabel3,
         localProcessId,
         sessionKey,
         cwd,
@@ -2865,6 +3236,10 @@ var BridgeService = class {
         branch,
         title,
         model,
+        permissionMode,
+        thinkingLevel,
+        fastMode,
+        contextLength,
         tmuxSessionName,
         tmuxWindowName,
         tmuxPaneId,
@@ -2885,13 +3260,24 @@ var BridgeService = class {
       }
     );
   }
-  async postAgentMessage(liveActivityId, role, body) {
+  async postAgentMessage(liveActivityId, role, body, structuredPayload) {
     await this.client.mutation(api.agentBridge.bridgePublic.postAgentMessage, {
       deviceId: this.config.deviceId,
       deviceSecret: this.config.deviceSecret,
       liveActivityId,
       role,
-      body
+      body,
+      structuredPayload
+    });
+  }
+  async postAgentSessionEvent(liveActivityId, event) {
+    const body = event.text.trim();
+    if (!body) return;
+    await this.postAgentMessage(liveActivityId, event.role, body, {
+      source: "cells_agent_event",
+      provider: event.provider,
+      title: event.title,
+      status: event.status
     });
   }
   async completeCommand(commandId, status) {
@@ -2904,11 +3290,13 @@ var BridgeService = class {
   }
   async postCommandError(cmd, errorMessage) {
     if (cmd.kind === "launch" && cmd.liveActivityId) {
-      const payload = cmd.payload;
       await this.updateLiveActivity(cmd.liveActivityId, {
         status: "failed",
         latestSummary: errorMessage,
-        delegatedRunId: payload?.delegatedRunId,
+        delegatedRunId: readPayloadId(
+          cmd.payload,
+          "delegatedRunId"
+        ),
         launchStatus: "failed"
       });
       await this.postAgentMessage(cmd.liveActivityId, "status", errorMessage);
@@ -3012,6 +3400,7 @@ function currentGitBranch(cwd) {
     return execSync2("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf-8",
       cwd,
+      stdio: ["ignore", "pipe", "ignore"],
       timeout: 3e3
     }).trim();
   } catch {
@@ -3022,7 +3411,14 @@ function buildManagedLaunchCommand(provider, prompt2) {
   if (provider === "codex") {
     return `codex --no-alt-screen -a never ${shellQuote(prompt2)}`;
   }
-  return `claude --permission-mode bypassPermissions --dangerously-skip-permissions ${shellQuote(prompt2)}`;
+  if (provider === "claude_code") {
+    return `claude --permission-mode bypassPermissions --dangerously-skip-permissions ${shellQuote(prompt2)}`;
+  }
+  if (provider === "cursor")
+    return `cursor-agent --print ${shellQuote(prompt2)}`;
+  if (provider === "copilot") return `copilot ${shellQuote(prompt2)}`;
+  if (provider === "opencode") return `opencode run ${shellQuote(prompt2)}`;
+  return `pi ${shellQuote(prompt2)}`;
 }
 function sanitizeTmuxName(value) {
   return value.replace(/[^a-z0-9_-]+/gi, "-").replace(/^-+|-+$/g, "") || "work";
@@ -3079,11 +3475,18 @@ function persistDeviceKey(deviceKey) {
   writeFileSync(DEVICE_KEY_FILE, `${deviceKey}
 `);
 }
-function buildLaunchPrompt(issueKey, issueTitle, workspacePath, issueDescription) {
+function buildLaunchPrompt(issueKey, issueTitle, workspacePath, issueDescription, issueContext, initialPrompt) {
   const lines = [`You are working on issue ${issueKey}: ${issueTitle}`];
   if (issueDescription?.trim()) {
     lines.push("", "Issue description:", issueDescription.trim());
   }
+  const contextLines = formatIssueContext(issueContext);
+  if (contextLines.length > 0) {
+    lines.push("", "Vector context:", ...contextLines);
+  }
+  if (initialPrompt?.trim()) {
+    lines.push("", "User instruction:", initialPrompt.trim());
+  }
   lines.push(
     "",
     `The repository is at ${workspacePath}.`,
@@ -3093,6 +3496,90 @@ function buildLaunchPrompt(issueKey, issueTitle, workspacePath, issueDescription
   );
   return lines.join("\n");
 }
+function buildFollowUpPrompt(userMessage, issueContext) {
+  const contextLines = formatIssueContext(issueContext);
+  if (contextLines.length === 0) {
+    return userMessage;
+  }
+  return [
+    "Vector context for the current issue:",
+    ...contextLines,
+    "",
+    "User message:",
+    userMessage
+  ].join("\n");
+}
+function formatIssueContext(issueContext) {
+  const lines = [];
+  const organization = readPayloadValue(issueContext, "organization");
+  const organizationName = readPayloadString(organization, "name");
+  const organizationSlug = readPayloadString(organization, "slug");
+  if (organizationName || organizationSlug) {
+    lines.push(
+      `- Organization: ${[organizationName, organizationSlug ? `(${organizationSlug})` : void 0].filter(Boolean).join(" ")}`
+    );
+  }
+  const team = readPayloadValue(issueContext, "team");
+  const teamName = readPayloadString(team, "name");
+  const teamKey = readPayloadString(team, "key");
+  if (teamName || teamKey) {
+    lines.push(
+      `- Team: ${[teamName, teamKey ? `(${teamKey})` : void 0].filter(Boolean).join(" ")}`
+    );
+  }
+  const project = readPayloadValue(issueContext, "project");
+  const projectName = readPayloadString(project, "name");
+  const projectKey = readPayloadString(project, "key");
+  const projectDescription = readPayloadString(project, "description");
+  if (projectName || projectKey) {
+    lines.push(
+      `- Project: ${[projectName, projectKey ? `(${projectKey})` : void 0].filter(Boolean).join(" ")}`
+    );
+  }
+  if (projectDescription) {
+    lines.push(`- Project description: ${projectDescription}`);
+  }
+  const state = readPayloadValue(issueContext, "state");
+  const stateName = readPayloadString(state, "name");
+  const stateType = readPayloadString(state, "type");
+  if (stateName || stateType) {
+    lines.push(
+      `- State: ${[stateName, stateType ? `(${stateType})` : void 0].filter(Boolean).join(" ")}`
+    );
+  }
+  const priority = readPayloadString(issueContext, "priority");
+  if (priority) lines.push(`- Priority: ${priority}`);
+  const reporter = readPayloadString(issueContext, "reporter");
+  if (reporter) lines.push(`- Reporter: ${reporter}`);
+  const assignees = readPayloadStringArray(issueContext, "assignees");
+  if (assignees.length > 0) {
+    lines.push(`- Assignees: ${assignees.join(", ")}`);
+  }
+  const labels = readPayloadStringArray(issueContext, "labels");
+  if (labels.length > 0) {
+    lines.push(`- Labels: ${labels.join(", ")}`);
+  }
+  const dates = readPayloadValue(issueContext, "dates");
+  const startDate = readPayloadString(dates, "startDate");
+  const dueDate = readPayloadString(dates, "dueDate");
+  if (startDate || dueDate) {
+    lines.push(
+      `- Dates: ${[startDate ? `start ${startDate}` : void 0, dueDate ? `due ${dueDate}` : void 0].filter(Boolean).join(", ")}`
+    );
+  }
+  const recentComments = readPayloadArray(issueContext, "recentComments");
+  if (recentComments.length > 0) {
+    lines.push("- Recent comments:");
+    for (const comment of recentComments) {
+      const author = readPayloadString(comment, "authorName") ?? "Unknown";
+      const body = readPayloadString(comment, "body");
+      if (body) {
+        lines.push(`  - ${author}: ${body}`);
+      }
+    }
+  }
+  return lines;
+}
 function summarizeMessage(message) {
   if (!message) {
     return void 0;
@@ -3174,16 +3661,72 @@ function compareLocalSessionRecency(a, b) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function readPayloadValue(payload, key) {
+  return payload !== null && typeof payload === "object" ? Reflect.get(payload, key) : void 0;
+}
+function readPayloadString(payload, key) {
+  const value = readPayloadValue(payload, key);
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function readPayloadNumber(payload, key) {
+  const value = readPayloadValue(payload, key);
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readPayloadBoolean(payload, key) {
+  const value = readPayloadValue(payload, key);
+  return typeof value === "boolean" ? value : void 0;
+}
+function readPayloadPermissionMode(payload, key) {
+  const value = readPayloadValue(payload, key);
+  return value === "plan" || value === "ask" || value === "bypass" ? value : void 0;
+}
+function readPayloadThinkingLevel(payload, key) {
+  const value = readPayloadValue(payload, key);
+  return value === "off" || value === "low" || value === "medium" || value === "high" || value === "max" || value === "xhigh" ? value : void 0;
+}
+function readPayloadContextLength(payload, key) {
+  const value = readPayloadValue(payload, key);
+  return value === "default" || value === "extended" ? value : void 0;
+}
+function readPayloadArray(payload, key) {
+  const value = readPayloadValue(payload, key);
+  return Array.isArray(value) ? value : [];
+}
+function readPayloadStringArray(payload, key) {
+  return readPayloadArray(payload, key).filter(
+    (value) => typeof value === "string" && value.trim() !== ""
+  );
+}
+function readPayloadId(payload, key) {
+  const value = readPayloadString(payload, key);
+  return value;
+}
+function readPayloadAgentProvider(payload, key) {
+  const value = readPayloadValue(payload, key);
+  return value === "codex" || value === "claude_code" || value === "cursor" || value === "copilot" || value === "opencode" || value === "pi" || value === "vector_cli" ? value : void 0;
+}
 function isBridgeProvider(provider) {
-  return provider === "codex" || provider === "claude_code";
+  return provider === "codex" || provider === "claude_code" || provider === "cursor" || provider === "copilot" || provider === "opencode" || provider === "pi";
 }
-function providerLabel(provider) {
+function providerLabel2(provider) {
   if (provider === "codex") {
     return "Codex";
   }
   if (provider === "claude_code") {
     return "Claude";
   }
+  if (provider === "cursor") {
+    return "Cursor";
+  }
+  if (provider === "copilot") {
+    return "GitHub Copilot";
+  }
+  if (provider === "opencode") {
+    return "OpenCode";
+  }
+  if (provider === "pi") {
+    return "Pi";
+  }
   return "Vector CLI";
 }
 function installLaunchAgent(vcliPath) {
@@ -3401,13 +3944,33 @@ function killExistingMenuBar() {
     }
   }
 }
+function getRunningMenuBarPid() {
+  if (!existsSync3(MENUBAR_PID_FILE)) {
+    return null;
+  }
+  try {
+    const pid = Number(readFileSync2(MENUBAR_PID_FILE, "utf-8").trim());
+    if (Number.isFinite(pid) && pid > 0 && isKnownMenuBarProcess(pid)) {
+      process.kill(pid, 0);
+      return pid;
+    }
+  } catch {
+  }
+  try {
+    unlinkSync(MENUBAR_PID_FILE);
+  } catch {
+  }
+  return null;
+}
 async function launchMenuBar() {
   if (platform() !== "darwin") return;
   removeLegacyMenuBarLaunchAgent();
   const executable = findMenuBarExecutable();
   const cliInvocation = getCurrentCliInvocation();
   if (!executable || !cliInvocation) return;
-  killExistingMenuBar();
+  if (getRunningMenuBarPid()) {
+    return;
+  }
   try {
     const { spawn: spawnChild } = await import("child_process");
     const child = spawnChild(executable, [], {
@@ -5725,7 +6288,7 @@ serviceCommand.command("stop").description("Stop the bridge service").action(()
     console.log("Bridge is not running.");
   }
 });
-serviceCommand.command("status").description("Show bridge service status").action((_options, command) => {
+serviceCommand.command("status").description("Show bridge service status").action(() => {
   const status = getBridgeStatus();
   if (!status.configured) {
     console.log("Bridge not configured. Run: vcli service start");
@@ -6022,7 +6585,7 @@ program.command("update").description("Update the CLI to the latest version").ac
       timeout: 12e4
     });
     s.stop("CLI updated successfully.");
-  } catch (err) {
+  } catch {
     s.stop("Update failed.");
     log.error(`Run manually: ${install.command.join(" ")}`);
     return;