@rehpic/vcli 0.1.0-beta.59.1 → 0.1.0-beta.61.1

package/dist/index.js

@@ -742,6 +742,7 @@ import { dirname, extname, join as join3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { config as loadEnv } from "dotenv";
 import { Command } from "commander";
+import { ConvexHttpClient as ConvexHttpClient3 } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
 
 // ../../convex/_generated/api.js
@@ -1112,239 +1113,334 @@ import { randomUUID } from "crypto";
 
 // src/agent-adapters.ts
 import { execSync, spawn } from "child_process";
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { existsSync, readFileSync, readdirSync } from "fs";
 import { homedir as homedir2, userInfo } from "os";
 import { basename, join } from "path";
-var MAX_DISCOVERED_FILES_PER_PROVIDER = 30;
+var LSOF_PATHS = ["/usr/sbin/lsof", "/usr/bin/lsof"];
+var VECTOR_BRIDGE_CLIENT_VERSION = "0.1.0";
 function discoverAttachableSessions() {
   return dedupeSessions([
     ...discoverCodexSessions(),
     ...discoverClaudeSessions()
   ]);
 }
-async function launchProviderSession(provider, cwd, prompt2) {
-  if (provider === "codex") {
-    const stdout2 = await runCommand("codex", ["exec", "--json", prompt2], cwd);
-    return parseCodexRunResult(stdout2, cwd, "codex exec --json");
-  }
-  const stdout = await runCommand(
-    "claude",
-    ["-p", "--output-format", "json", prompt2],
-    cwd
-  );
-  return parseClaudeRunResult(stdout, cwd, "claude -p --output-format json");
-}
 async function resumeProviderSession(provider, sessionKey, cwd, prompt2) {
   if (provider === "codex") {
-    const stdout2 = await runCommand(
-      "codex",
-      ["exec", "resume", "--json", sessionKey, prompt2],
-      cwd
-    );
-    return parseCodexRunResult(stdout2, cwd, "codex exec resume --json");
+    return runCodexAppServerTurn({
+      cwd,
+      prompt: prompt2,
+      sessionKey,
+      launchCommand: "codex app-server (thread/resume)"
+    });
   }
-  const stdout = await runCommand(
-    "claude",
-    ["-p", "--resume", sessionKey, "--output-format", "json", prompt2],
-    cwd
-  );
-  return parseClaudeRunResult(
-    stdout,
+  return runClaudeSdkTurn({
     cwd,
-    "claude -p --resume --output-format json"
-  );
+    prompt: prompt2,
+    sessionKey,
+    launchCommand: "@anthropic-ai/claude-agent-sdk query(resume)"
+  });
 }
-async function runCommand(command, args, cwd) {
-  const child = spawn(command, args, {
-    cwd,
+async function runCodexAppServerTurn(args) {
+  const child = spawn("codex", ["app-server"], {
+    cwd: args.cwd,
     env: { ...process.env },
-    stdio: ["ignore", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"]
   });
-  let stdout = "";
   let stderr = "";
+  let stdoutBuffer = "";
+  let sessionKey = args.sessionKey;
+  let finalAssistantText = "";
+  let completed = false;
+  let nextRequestId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  let completeTurn;
+  let failTurn;
+  const turnCompleted = new Promise((resolve, reject) => {
+    completeTurn = () => {
+      completed = true;
+      resolve();
+    };
+    failTurn = (error) => {
+      completed = true;
+      reject(error);
+    };
+  });
   child.stdout.on("data", (chunk) => {
-    stdout += chunk.toString();
+    stdoutBuffer += chunk.toString();
+    while (true) {
+      const newlineIndex = stdoutBuffer.indexOf("\n");
+      if (newlineIndex < 0) {
+        break;
+      }
+      const line = stdoutBuffer.slice(0, newlineIndex).trim();
+      stdoutBuffer = stdoutBuffer.slice(newlineIndex + 1);
+      if (!line) {
+        continue;
+      }
+      const payload = tryParseJson(line);
+      if (!payload || typeof payload !== "object") {
+        continue;
+      }
+      const responseId = payload.id;
+      if (typeof responseId === "number" && pending.has(responseId)) {
+        const entry = pending.get(responseId);
+        pending.delete(responseId);
+        const errorRecord = asObject(payload.error);
+        if (errorRecord) {
+          entry.reject(
+            new Error(
+              `codex app-server error: ${asString(errorRecord.message) ?? "Unknown JSON-RPC error"}`
+            )
+          );
+          continue;
+        }
+        entry.resolve(payload.result);
+        continue;
+      }
+      const method = asString(payload.method);
+      const params = asObject(payload.params);
+      if (!method || !params) {
+        continue;
+      }
+      if (method === "thread/started") {
+        sessionKey = asString(asObject(params.thread)?.id) ?? asString(asObject(params.thread)?.threadId) ?? sessionKey;
+        continue;
+      }
+      if (method === "item/agentMessage/delta") {
+        finalAssistantText += asString(params.delta) ?? "";
+        continue;
+      }
+      if (method === "item/completed") {
+        const item = asObject(params.item);
+        if (asString(item?.type) === "agentMessage") {
+          finalAssistantText = asString(item?.text) ?? finalAssistantText;
+        }
+        continue;
+      }
+      if (method === "turn/completed") {
+        const turn = asObject(params.turn);
+        const status = asString(turn?.status);
+        if (status === "failed") {
+          const turnError = asObject(turn?.error);
+          failTurn?.(
+            new Error(
+              asString(turnError?.message) ?? "Codex turn failed without an error message"
+            )
+          );
+        } else if (status === "interrupted") {
+          failTurn?.(new Error("Codex turn was interrupted"));
+        } else {
+          completeTurn?.();
+        }
+      }
+    }
   });
   child.stderr.on("data", (chunk) => {
     stderr += chunk.toString();
   });
-  return await new Promise((resolve, reject) => {
-    child.on("error", reject);
+  const request = (method, params) => new Promise((resolve, reject) => {
+    const id = nextRequestId++;
+    pending.set(id, { resolve, reject });
+    child.stdin.write(`${JSON.stringify({ method, id, params })}
+`);
+  });
+  const notify = (method, params) => {
+    child.stdin.write(`${JSON.stringify({ method, params })}
+`);
+  };
+  const waitForExit = new Promise((_, reject) => {
+    child.on("error", (error) => reject(error));
     child.on("close", (code) => {
-      if (code === 0) {
-        resolve(stdout);
-        return;
+      if (!completed) {
+        const detail = stderr.trim() || `codex app-server exited with code ${code}`;
+        reject(new Error(detail));
       }
-      const detail = stderr.trim() || stdout.trim() || `exit code ${code}`;
-      reject(new Error(`${command} failed: ${detail}`));
     });
   });
-}
-function discoverCodexSessions() {
-  return listRecentJsonlFiles(getCodexSessionsDir()).flatMap((file) => {
-    const entries = readJsonLines(file);
-    let sessionKey;
-    let cwd;
-    let title;
-    let lastUserMessage;
-    let lastAssistantMessage;
-    for (const entry of entries) {
-      if (entry.type === "session_meta") {
-        sessionKey = asString(entry.payload?.id) ?? sessionKey;
-        cwd = asString(entry.payload?.cwd) ?? cwd;
-      }
-      if (entry.type === "event_msg" && entry.payload?.type === "user_message") {
-        lastUserMessage = asString(entry.payload?.message) ?? lastUserMessage;
-      }
-      if (entry.type === "response_item" && entry.payload?.type === "message" && entry.payload?.role === "user") {
-        lastUserMessage = extractCodexResponseText(entry.payload?.content) ?? lastUserMessage;
-      }
-      if (entry.type === "event_msg" && entry.payload?.type === "agent_message") {
-        lastAssistantMessage = asString(entry.payload?.message) ?? lastAssistantMessage;
-      }
-      if (entry.type === "response_item" && entry.payload?.type === "message" && entry.payload?.role === "assistant") {
-        lastAssistantMessage = extractCodexResponseText(entry.payload?.content) ?? lastAssistantMessage;
-      }
-    }
+  try {
+    await Promise.race([
+      request("initialize", {
+        clientInfo: {
+          name: "vector_bridge",
+          title: "Vector Bridge",
+          version: VECTOR_BRIDGE_CLIENT_VERSION
+        }
+      }),
+      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;
     if (!sessionKey) {
-      return [];
+      throw new Error("Codex app-server did not return a thread id");
     }
-    title = summarizeTitle(lastUserMessage ?? lastAssistantMessage, cwd);
-    const gitInfo = cwd ? getGitInfo(cwd) : {};
-    return [
-      {
-        provider: "codex",
-        providerLabel: "Codex",
-        sessionKey,
-        cwd,
-        ...gitInfo,
-        title,
-        mode: "observed",
-        status: "observed",
-        supportsInboundMessages: true
+    await Promise.race([
+      request("turn/start", {
+        threadId: sessionKey,
+        input: [{ type: "text", text: args.prompt }],
+        cwd: args.cwd,
+        approvalPolicy: "never",
+        personality: "pragmatic"
+      }),
+      waitForExit
+    ]);
+    await Promise.race([turnCompleted, waitForExit]);
+    const gitInfo = getGitInfo(args.cwd);
+    return {
+      provider: "codex",
+      providerLabel: "Codex",
+      sessionKey,
+      cwd: args.cwd,
+      ...gitInfo,
+      title: summarizeTitle(void 0, args.cwd),
+      mode: "managed",
+      status: "waiting",
+      supportsInboundMessages: true,
+      responseText: finalAssistantText.trim() || void 0,
+      launchCommand: args.launchCommand
+    };
+  } finally {
+    for (const entry of pending.values()) {
+      entry.reject(
+        new Error("codex app-server closed before request resolved")
+      );
+    }
+    pending.clear();
+    child.kill();
+  }
+}
+async function runClaudeSdkTurn(args) {
+  const { query } = await import("@anthropic-ai/claude-agent-sdk");
+  const stream = query({
+    prompt: args.prompt,
+    options: {
+      cwd: args.cwd,
+      resume: args.sessionKey,
+      persistSession: true,
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      env: {
+        ...process.env,
+        CLAUDE_AGENT_SDK_CLIENT_APP: `vector-bridge/${VECTOR_BRIDGE_CLIENT_VERSION}`
       }
-    ];
+    }
   });
-}
-function discoverClaudeSessions() {
-  return listRecentJsonlFiles(getClaudeSessionsDir()).flatMap((file) => {
-    const entries = readJsonLines(file);
-    let sessionKey;
-    let cwd;
-    let branch;
-    let model;
-    let lastUserMessage;
-    let lastAssistantMessage;
-    for (const entry of entries) {
-      sessionKey = asString(entry.sessionId) ?? sessionKey;
-      cwd = asString(entry.cwd) ?? cwd;
-      branch = asString(entry.gitBranch) ?? branch;
-      if (entry.type === "user") {
-        lastUserMessage = extractClaudeUserText(entry.message) ?? lastUserMessage;
+  let sessionKey = args.sessionKey;
+  let responseText = "";
+  let model;
+  try {
+    for await (const message of stream) {
+      if (!message || typeof message !== "object") {
+        continue;
       }
-      if (entry.type === "assistant") {
-        model = asString(entry.message?.model) ?? model;
-        lastAssistantMessage = extractClaudeAssistantText(entry.message) ?? lastAssistantMessage;
+      sessionKey = asString(message.session_id) ?? sessionKey;
+      if (message.type === "assistant") {
+        const assistantText = extractClaudeMessageTexts(
+          message.message
+        ).join("\n\n").trim();
+        if (assistantText) {
+          responseText = assistantText;
+        }
+        continue;
       }
-    }
-    if (!sessionKey) {
-      return [];
-    }
-    const gitInfo = cwd ? getGitInfo(cwd) : {};
-    return [
-      {
-        provider: "claude_code",
-        providerLabel: "Claude",
-        sessionKey,
-        cwd,
-        repoRoot: gitInfo.repoRoot,
-        branch: branch ?? gitInfo.branch,
-        title: summarizeTitle(lastUserMessage ?? lastAssistantMessage, cwd),
-        model,
-        mode: "observed",
-        status: "observed",
-        supportsInboundMessages: true
+      if (message.type !== "result") {
+        continue;
       }
-    ];
-  });
-}
-function parseCodexRunResult(stdout, cwd, launchCommand) {
-  let sessionKey;
-  const responseParts = [];
-  for (const line of stdout.split("\n").map((part) => part.trim()).filter(Boolean)) {
-    const payload = tryParseJson(line);
-    if (!payload) continue;
-    if (payload.type === "thread.started") {
-      sessionKey = asString(payload.thread_id) ?? sessionKey;
-    }
-    if (payload.type === "item.completed" && payload.item?.type === "agent_message" && typeof payload.item.text === "string") {
-      responseParts.push(payload.item.text.trim());
-    }
-    if (payload.type === "response_item" && payload.payload?.type === "message" && payload.payload?.role === "assistant") {
-      const responseText2 = extractCodexResponseText(payload.payload?.content);
-      if (responseText2) {
-        responseParts.push(responseText2);
+      if (message.subtype === "success") {
+        const resultText = asString(message.result);
+        if (resultText) {
+          responseText = resultText;
+        }
+        model = firstObjectKey(
+          message.modelUsage
+        );
+        continue;
       }
+      const errors = message.errors;
+      const detail = Array.isArray(errors) && errors.length > 0 ? errors.join("\n") : "Claude execution failed";
+      throw new Error(detail);
     }
+  } finally {
+    stream.close();
   }
   if (!sessionKey) {
-    throw new Error("Codex did not return a thread id");
+    throw new Error("Claude Agent SDK did not return a session id");
   }
-  const gitInfo = getGitInfo(cwd);
-  const responseText = responseParts.filter(Boolean).join("\n\n") || void 0;
-  return {
-    provider: "codex",
-    providerLabel: "Codex",
-    sessionKey,
-    cwd,
-    ...gitInfo,
-    title: summarizeTitle(void 0, cwd),
-    mode: "managed",
-    status: "waiting",
-    supportsInboundMessages: true,
-    responseText,
-    launchCommand
-  };
-}
-function parseClaudeRunResult(stdout, cwd, launchCommand) {
-  const payload = stdout.split("\n").map((line) => tryParseJson(line)).filter(Boolean).pop();
-  if (!payload) {
-    throw new Error("Claude did not return JSON output");
-  }
-  const sessionKey = asString(payload.session_id);
-  if (!sessionKey) {
-    throw new Error("Claude did not return a session id");
-  }
-  const gitInfo = getGitInfo(cwd);
-  const model = firstObjectKey(payload.modelUsage);
+  const gitInfo = getGitInfo(args.cwd);
   return {
     provider: "claude_code",
     providerLabel: "Claude",
     sessionKey,
-    cwd,
+    cwd: args.cwd,
     ...gitInfo,
-    title: summarizeTitle(void 0, cwd),
+    title: summarizeTitle(void 0, args.cwd),
     model,
     mode: "managed",
     status: "waiting",
     supportsInboundMessages: true,
-    responseText: asString(payload.result) ?? void 0,
-    launchCommand
+    responseText: responseText.trim() || void 0,
+    launchCommand: args.launchCommand
   };
 }
-function listRecentJsonlFiles(root) {
-  if (!existsSync(root)) {
-    return [];
-  }
-  const files = collectJsonlFiles(root);
-  return files.map((path3) => ({ path: path3, mtimeMs: statSync(path3).mtimeMs })).sort((a, b) => b.mtimeMs - a.mtimeMs).slice(0, MAX_DISCOVERED_FILES_PER_PROVIDER).map((file) => file.path);
+function discoverCodexSessions() {
+  const historyBySession = buildCodexHistoryIndex();
+  return listLiveProcessIds("codex").flatMap((pid) => {
+    const transcriptPath = getCodexTranscriptPath(pid);
+    if (!transcriptPath) {
+      return [];
+    }
+    const processCwd = getProcessCwd(pid);
+    const parsed = parseObservedCodexSession(
+      pid,
+      transcriptPath,
+      processCwd,
+      historyBySession
+    );
+    return parsed ? [parsed] : [];
+  }).sort(compareObservedSessions);
+}
+function discoverClaudeSessions() {
+  const historyBySession = buildClaudeHistoryIndex();
+  return listLiveProcessIds("claude").flatMap((pid) => {
+    const sessionMeta = readClaudePidSession(pid);
+    if (!sessionMeta?.sessionId) {
+      return [];
+    }
+    const transcriptPath = findClaudeTranscriptPath(sessionMeta.sessionId);
+    const parsed = parseObservedClaudeSession(
+      pid,
+      sessionMeta,
+      transcriptPath,
+      historyBySession
+    );
+    return parsed ? [parsed] : [];
+  }).sort(compareObservedSessions);
 }
-function getCodexSessionsDir() {
-  return join(getRealHomeDir(), ".codex", "sessions");
+function getCodexHistoryFile() {
+  return join(getRealHomeDir(), ".codex", "history.jsonl");
 }
-function getClaudeSessionsDir() {
+function getClaudeProjectsDir() {
   return join(getRealHomeDir(), ".claude", "projects");
 }
+function getClaudeSessionStateDir() {
+  return join(getRealHomeDir(), ".claude", "sessions");
+}
+function getClaudeHistoryFile() {
+  return join(getRealHomeDir(), ".claude", "history.jsonl");
+}
 function getRealHomeDir() {
   try {
     const realHome = userInfo().homedir?.trim();
@@ -1355,22 +1451,113 @@ function getRealHomeDir() {
   }
   return homedir2();
 }
-function collectJsonlFiles(root) {
-  const files = [];
+function resolveExecutable(fallbackCommand, absoluteCandidates) {
+  for (const candidate of absoluteCandidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  try {
+    const output = execSync(`command -v ${fallbackCommand}`, {
+      encoding: "utf-8",
+      timeout: 1e3
+    }).trim();
+    return output || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function listLiveProcessIds(commandName) {
+  try {
+    const output = execSync("ps -axo pid=,comm=", {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return output.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => line.split(/\s+/, 2)).filter(([, command]) => command === commandName).map(([pid]) => pid).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function getProcessCwd(pid) {
+  const lsofCommand = resolveExecutable("lsof", LSOF_PATHS);
+  if (!lsofCommand) {
+    return void 0;
+  }
+  try {
+    const output = execSync(`${lsofCommand} -a -p ${pid} -Fn -d cwd`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return output.split("\n").map((line) => line.trim()).find((line) => line.startsWith("n"))?.slice(1);
+  } catch {
+    return void 0;
+  }
+}
+function getCodexTranscriptPath(pid) {
+  const lsofCommand = resolveExecutable("lsof", LSOF_PATHS);
+  if (!lsofCommand) {
+    return void 0;
+  }
+  try {
+    const output = execSync(`${lsofCommand} -p ${pid} -Fn`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    return output.split("\n").map((line) => line.trim()).find(
+      (line) => line.startsWith("n") && line.includes("/.codex/sessions/") && line.endsWith(".jsonl")
+    )?.slice(1);
+  } catch {
+    return void 0;
+  }
+}
+function readClaudePidSession(pid) {
+  const path3 = join(getClaudeSessionStateDir(), `${pid}.json`);
+  if (!existsSync(path3)) {
+    return null;
+  }
+  try {
+    const payload = JSON.parse(readFileSync(path3, "utf-8"));
+    const sessionId = asString(payload.sessionId);
+    if (!sessionId) {
+      return null;
+    }
+    return {
+      sessionId,
+      cwd: asString(payload.cwd),
+      startedAt: typeof payload.startedAt === "number" ? payload.startedAt : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function findClaudeTranscriptPath(sessionId) {
+  return findJsonlFileByStem(getClaudeProjectsDir(), sessionId);
+}
+function findJsonlFileByStem(root, stem) {
+  if (!existsSync(root)) {
+    return void 0;
+  }
   for (const entry of readdirSync(root, { withFileTypes: true })) {
     const path3 = join(root, entry.name);
     if (entry.isDirectory()) {
-      files.push(...collectJsonlFiles(path3));
+      const nested = findJsonlFileByStem(path3, stem);
+      if (nested) {
+        return nested;
+      }
       continue;
     }
-    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-      files.push(path3);
+    if (entry.isFile() && entry.name === `${stem}.jsonl`) {
+      return path3;
     }
   }
-  return files;
+  return void 0;
 }
 function readJsonLines(path3) {
-  return readFileSync(path3, "utf-8").split("\n").map((line) => line.trim()).filter(Boolean).map(tryParseJson).filter(Boolean);
+  try {
+    return readFileSync(path3, "utf-8").split("\n").map((line) => line.trim()).filter(Boolean).map(tryParseJson).filter(Boolean);
+  } catch {
+    return [];
+  }
 }
 function tryParseJson(value) {
   try {
@@ -1382,7 +1569,7 @@ function tryParseJson(value) {
 function dedupeSessions(sessions) {
   const seen = /* @__PURE__ */ new Set();
   return sessions.filter((session) => {
-    const key = `${session.provider}:${session.sessionKey}`;
+    const key = `${session.provider}:${session.localProcessId ?? session.sessionKey}`;
     if (seen.has(key)) {
       return false;
     }
@@ -1390,37 +1577,113 @@ function dedupeSessions(sessions) {
     return true;
   });
 }
-function extractCodexResponseText(content) {
-  if (!Array.isArray(content)) {
-    return void 0;
-  }
-  const texts = content.map(
-    (item) => item && typeof item === "object" && "text" in item ? asString(item.text) : void 0
-  ).filter(Boolean);
-  return texts.length > 0 ? texts.join("\n\n") : void 0;
+function compareObservedSessions(a, b) {
+  return Number(b.localProcessId ?? 0) - Number(a.localProcessId ?? 0);
 }
-function extractClaudeUserText(message) {
-  if (!message || typeof message !== "object") {
-    return void 0;
+function parseObservedCodexSession(pid, transcriptPath, processCwd, historyBySession) {
+  const entries = readJsonLines(transcriptPath);
+  let sessionKey;
+  let cwd = processCwd;
+  const userMessages = [];
+  const assistantMessages = [];
+  for (const rawEntry of entries) {
+    const entry = asObject(rawEntry);
+    if (!entry) {
+      continue;
+    }
+    if (entry.type === "session_meta") {
+      const payload = asObject(entry.payload);
+      sessionKey = asString(payload?.id) ?? sessionKey;
+      cwd = asString(payload?.cwd) ?? cwd;
+    }
+    if (entry.type === "event_msg") {
+      const payload = asObject(entry.payload);
+      if (payload?.type === "user_message") {
+        pushIfPresent(userMessages, payload.message);
+      }
+    }
+    if (entry.type === "response_item" && asObject(entry.payload)?.type === "message" && asObject(entry.payload)?.role === "user") {
+      userMessages.push(
+        ...extractTextSegments(asObject(entry.payload)?.content)
+      );
+    }
+    if (entry.type === "event_msg") {
+      const payload = asObject(entry.payload);
+      if (payload?.type === "agent_message") {
+        pushIfPresent(assistantMessages, payload.message);
+      }
+    }
+    if (entry.type === "response_item" && asObject(entry.payload)?.type === "message" && asObject(entry.payload)?.role === "assistant") {
+      assistantMessages.push(
+        ...extractTextSegments(asObject(entry.payload)?.content)
+      );
+    }
   }
-  const content = message.content;
-  if (typeof content === "string") {
-    return content;
+  if (!sessionKey) {
+    return null;
   }
-  return void 0;
+  const gitInfo = cwd ? getGitInfo(cwd) : {};
+  const historyTitle = sessionKey ? selectSessionTitle(historyBySession?.get(sessionKey) ?? []) : void 0;
+  return {
+    provider: "codex",
+    providerLabel: "Codex",
+    localProcessId: pid,
+    sessionKey,
+    cwd,
+    ...gitInfo,
+    title: summarizeTitle(
+      historyTitle ?? selectSessionTitle(userMessages) ?? selectSessionTitle(assistantMessages),
+      cwd
+    ),
+    mode: "observed",
+    status: "observed",
+    supportsInboundMessages: true
+  };
 }
-function extractClaudeAssistantText(message) {
-  if (!message || typeof message !== "object") {
-    return void 0;
-  }
-  const content = message.content;
-  if (!Array.isArray(content)) {
-    return void 0;
+function parseObservedClaudeSession(pid, sessionMeta, transcriptPath, historyBySession) {
+  const entries = transcriptPath ? readJsonLines(transcriptPath) : [];
+  let cwd = sessionMeta.cwd;
+  let branch;
+  let model;
+  const userMessages = [];
+  const assistantMessages = [];
+  for (const rawEntry of entries) {
+    const entry = asObject(rawEntry);
+    if (!entry) {
+      continue;
+    }
+    cwd = asString(entry.cwd) ?? cwd;
+    branch = asString(entry.gitBranch) ?? branch;
+    if (entry.type === "user") {
+      userMessages.push(...extractClaudeMessageTexts(entry.message));
+    }
+    if (entry.type === "assistant") {
+      const message = asObject(entry.message);
+      model = asString(message?.model) ?? model;
+      assistantMessages.push(...extractClaudeMessageTexts(entry.message));
+    }
   }
-  const texts = content.map(
-    (item) => item && typeof item === "object" && "text" in item ? asString(item.text) : void 0
-  ).filter(Boolean);
-  return texts.length > 0 ? texts.join("\n\n") : void 0;
+  const gitInfo = cwd ? getGitInfo(cwd) : {};
+  const historyTitle = selectSessionTitle(
+    historyBySession?.get(sessionMeta.sessionId) ?? []
+  );
+  return {
+    provider: "claude_code",
+    providerLabel: "Claude",
+    localProcessId: pid,
+    sessionKey: sessionMeta.sessionId,
+    cwd,
+    repoRoot: gitInfo.repoRoot,
+    branch: branch ?? gitInfo.branch,
+    title: summarizeTitle(
+      historyTitle ?? selectSessionTitle(userMessages) ?? selectSessionTitle(assistantMessages),
+      cwd
+    ),
+    model,
+    mode: "observed",
+    status: "observed",
+    supportsInboundMessages: true
+  };
 }
 function summarizeTitle(message, cwd) {
   if (message) {
@@ -1439,11 +1702,176 @@ function firstObjectKey(value) {
     return void 0;
   }
   const [firstKey] = Object.keys(value);
-  return firstKey;
+  return firstKey ? normalizeModelKey(firstKey) : void 0;
+}
+function normalizeModelKey(value) {
+  const normalized = stripAnsi(value).replace(/\[\d+(?:;\d+)*m$/g, "").trim();
+  return normalized || void 0;
+}
+function asObject(value) {
+  return value && typeof value === "object" ? value : void 0;
 }
 function asString(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
+function pushIfPresent(target, value) {
+  const text2 = asString(value);
+  if (text2) {
+    target.push(text2);
+  }
+}
+function extractClaudeMessageTexts(message) {
+  if (!message || typeof message !== "object") {
+    return [];
+  }
+  return extractTextSegments(message.content);
+}
+function extractTextSegments(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap(extractTextSegmentFromBlock).filter(Boolean);
+}
+function extractTextSegmentFromBlock(block) {
+  if (!block || typeof block !== "object") {
+    return [];
+  }
+  const typedBlock = block;
+  const blockType = asString(typedBlock.type);
+  if (blockType && isIgnoredContentBlockType(blockType)) {
+    return [];
+  }
+  const directText = asString(typedBlock.text);
+  if (directText) {
+    return [directText];
+  }
+  if (typeof typedBlock.content === "string") {
+    return [typedBlock.content];
+  }
+  return [];
+}
+function isIgnoredContentBlockType(blockType) {
+  return [
+    "tool_result",
+    "tool_use",
+    "image",
+    "thinking",
+    "reasoning",
+    "contextCompaction"
+  ].includes(blockType);
+}
+function buildCodexHistoryIndex() {
+  const historyBySession = /* @__PURE__ */ new Map();
+  for (const rawEntry of readJsonLines(getCodexHistoryFile())) {
+    const entry = asObject(rawEntry);
+    if (!entry) {
+      continue;
+    }
+    const sessionId = asString(entry.session_id);
+    const text2 = asString(entry.text);
+    if (!sessionId || !text2) {
+      continue;
+    }
+    appendHistoryEntry(historyBySession, sessionId, text2);
+  }
+  return historyBySession;
+}
+function buildClaudeHistoryIndex() {
+  const historyBySession = /* @__PURE__ */ new Map();
+  for (const rawEntry of readJsonLines(getClaudeHistoryFile())) {
+    const entry = asObject(rawEntry);
+    if (!entry) {
+      continue;
+    }
+    const sessionId = asString(entry.sessionId);
+    if (!sessionId) {
+      continue;
+    }
+    const texts = extractClaudeHistoryTexts(entry);
+    for (const text2 of texts) {
+      appendHistoryEntry(historyBySession, sessionId, text2);
+    }
+  }
+  return historyBySession;
+}
+function appendHistoryEntry(historyBySession, sessionId, text2) {
+  const existing = historyBySession.get(sessionId);
+  if (existing) {
+    existing.push(text2);
+    return;
+  }
+  historyBySession.set(sessionId, [text2]);
+}
+function extractClaudeHistoryTexts(entry) {
+  if (!entry || typeof entry !== "object") {
+    return [];
+  }
+  const record = entry;
+  const pastedTexts = extractClaudePastedTexts(record.pastedContents);
+  if (pastedTexts.length > 0) {
+    return pastedTexts;
+  }
+  const display = asString(record.display);
+  return display ? [display] : [];
+}
+function extractClaudePastedTexts(value) {
+  if (!value || typeof value !== "object") {
+    return [];
+  }
+  return Object.values(value).flatMap((item) => {
+    if (!item || typeof item !== "object") {
+      return [];
+    }
+    const record = item;
+    return record.type === "text" && typeof record.content === "string" ? [record.content] : [];
+  }).filter(Boolean);
+}
+function selectSessionTitle(messages) {
+  for (const message of messages) {
+    const cleaned = cleanSessionTitleCandidate(message);
+    if (cleaned) {
+      return cleaned;
+    }
+  }
+  return void 0;
+}
+function cleanSessionTitleCandidate(message) {
+  const normalized = stripAnsi(message).replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return void 0;
+  }
+  if (normalized.length < 4) {
+    return void 0;
+  }
+  if (normalized.startsWith("/") || looksLikeGeneratedTagEnvelope(normalized) || looksLikeGeneratedImageSummary(normalized) || looksLikeStandaloneImagePath(normalized) || looksLikeInstructionScaffold(normalized)) {
+    return void 0;
+  }
+  return normalized;
+}
+function looksLikeGeneratedTagEnvelope(value) {
+  return /^<[\w:-]+>[\s\S]*<\/[\w:-]+>$/.test(value);
+}
+function looksLikeGeneratedImageSummary(value) {
+  return /^\[image:/i.test(value) || /displayed at/i.test(value) && /coordinates/i.test(value);
+}
+function looksLikeStandaloneImagePath(value) {
+  return /^\/\S+\.(png|jpe?g|gif|webp|heic|bmp)$/i.test(value) || /^file:\S+\.(png|jpe?g|gif|webp|heic|bmp)$/i.test(value);
+}
+function looksLikeInstructionScaffold(value) {
+  if (value.length < 700) {
+    return false;
+  }
+  const headingCount = value.match(/^#{1,3}\s/gm)?.length ?? 0;
+  const tagCount = value.match(/<\/?[\w:-]+>/g)?.length ?? 0;
+  const bulletCount = value.match(/^\s*[-*]\s/gm)?.length ?? 0;
+  return headingCount + tagCount + bulletCount >= 6;
+}
+function stripAnsi(value) {
+  return value.replace(/\u001B\[[0-9;]*m/g, "");
+}
 function getGitInfo(cwd) {
   try {
     const repoRoot = execSync("git rev-parse --show-toplevel", {
@@ -1481,6 +1909,7 @@ var LEGACY_MENUBAR_LAUNCHAGENT_PLIST = join2(
 );
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var COMMAND_POLL_INTERVAL_MS = 5e3;
+var LIVE_ACTIVITY_SYNC_INTERVAL_MS = 5e3;
 var PROCESS_DISCOVERY_INTERVAL_MS = 6e4;
 function loadBridgeConfig() {
   if (!existsSync2(BRIDGE_CONFIG_FILE)) return null;
@@ -1561,12 +1990,26 @@ var BridgeService = class {
   }
   async reportProcesses() {
     const processes = discoverAttachableSessions();
+    const activeSessionKeys = processes.map((proc) => proc.sessionKey).filter((value) => Boolean(value));
+    const activeLocalProcessIds = processes.map((proc) => proc.localProcessId).filter((value) => Boolean(value));
     for (const proc of processes) {
       try {
         await this.reportProcess(proc);
       } catch {
       }
     }
+    try {
+      await this.client.mutation(
+        api.agentBridge.bridgePublic.reconcileObservedProcesses,
+        {
+          deviceId: this.config.deviceId,
+          deviceSecret: this.config.deviceSecret,
+          activeSessionKeys,
+          activeLocalProcessIds
+        }
+      );
+    } catch {
+    }
     if (processes.length > 0) {
       console.log(
         `[${ts()}] Discovered ${processes.length} attachable session(s)`
@@ -1583,9 +2026,87 @@ var BridgeService = class {
         }
       );
       writeLiveActivitiesCache(activities);
+      await this.syncWorkSessionTerminals(activities);
     } catch {
     }
   }
+  async syncWorkSessionTerminals(activities) {
+    for (const activity of activities) {
+      if (!activity.workSessionId || !activity.tmuxPaneId) {
+        continue;
+      }
+      try {
+        await this.refreshWorkSessionTerminal(activity.workSessionId, {
+          tmuxPaneId: activity.tmuxPaneId,
+          cwd: activity.cwd,
+          repoRoot: activity.repoRoot,
+          branch: activity.branch,
+          agentProvider: activity.agentProvider,
+          agentSessionKey: activity.agentSessionKey
+        });
+        await this.verifyManagedWorkSession(activity);
+      } catch {
+      }
+    }
+  }
+  async verifyManagedWorkSession(activity) {
+    if (!activity.workSessionId || !activity.tmuxPaneId || !activity.agentProvider || !isBridgeProvider(activity.agentProvider) || activity.agentProcessId) {
+      return;
+    }
+    const workspacePath = activity.workspacePath ?? activity.cwd ?? activity.repoRoot;
+    if (!workspacePath) {
+      return;
+    }
+    const attachedSession = await this.attachObservedAgentSession(
+      activity.agentProvider,
+      workspacePath
+    );
+    if (!attachedSession) {
+      return;
+    }
+    await this.refreshWorkSessionTerminal(activity.workSessionId, {
+      tmuxPaneId: activity.tmuxPaneId,
+      cwd: attachedSession.process.cwd ?? activity.cwd ?? workspacePath,
+      repoRoot: attachedSession.process.repoRoot ?? activity.repoRoot ?? workspacePath,
+      branch: attachedSession.process.branch ?? activity.branch,
+      agentProvider: attachedSession.process.provider,
+      agentSessionKey: attachedSession.process.sessionKey
+    });
+    await this.postAgentMessage(
+      activity._id,
+      "status",
+      `Verified ${providerLabel(attachedSession.process.provider)} in ${activity.tmuxPaneId}`
+    );
+    await this.updateLiveActivity(activity._id, {
+      status: "waiting_for_input",
+      latestSummary: `Verified ${providerLabel(attachedSession.process.provider)} in ${activity.tmuxPaneId}`,
+      processId: attachedSession.processId,
+      title: activity.title
+    });
+  }
+  async refreshWorkSessionTerminal(workSessionId, metadata) {
+    if (!workSessionId || !metadata.tmuxPaneId) {
+      return;
+    }
+    const terminalSnapshot = captureTmuxPane(metadata.tmuxPaneId);
+    await this.client.mutation(
+      api.agentBridge.bridgePublic.updateWorkSessionTerminal,
+      {
+        deviceId: this.config.deviceId,
+        deviceSecret: this.config.deviceSecret,
+        workSessionId,
+        terminalSnapshot,
+        tmuxSessionName: metadata.tmuxSessionName,
+        tmuxWindowName: metadata.tmuxWindowName,
+        tmuxPaneId: metadata.tmuxPaneId,
+        cwd: metadata.cwd,
+        repoRoot: metadata.repoRoot,
+        branch: metadata.branch,
+        agentProvider: metadata.agentProvider,
+        agentSessionKey: metadata.agentSessionKey
+      }
+    );
+  }
   async run() {
     console.log("Vector Bridge Service");
     console.log(
@@ -1606,8 +2127,6 @@ var BridgeService = class {
         this.heartbeat().catch(
           (e) => console.error(`[${ts()}] Heartbeat error:`, e.message)
         );
-        this.refreshLiveActivities().catch(() => {
-        });
       }, HEARTBEAT_INTERVAL_MS)
     );
     this.timers.push(
@@ -1617,6 +2136,13 @@ var BridgeService = class {
         );
       }, COMMAND_POLL_INTERVAL_MS)
     );
+    this.timers.push(
+      setInterval(() => {
+        this.refreshLiveActivities().catch(
+          (e) => console.error(`[${ts()}] Live activity sync error:`, e.message)
+        );
+      }, LIVE_ACTIVITY_SYNC_INTERVAL_MS)
+    );
     this.timers.push(
       setInterval(() => {
         this.reportProcesses().catch(
@@ -1653,10 +2179,39 @@ var BridgeService = class {
       throw new Error("Message command is missing a body");
     }
     const process9 = cmd.process;
+    console.log(`  > "${truncateForLog(body)}"`);
+    if (cmd.workSession?.tmuxPaneId) {
+      sendTextToTmuxPane(cmd.workSession.tmuxPaneId, body);
+      const attachedSession = cmd.workSession.agentProvider && isBridgeProvider(cmd.workSession.agentProvider) ? await this.attachObservedAgentSession(
+        cmd.workSession.agentProvider,
+        cmd.workSession.workspacePath ?? cmd.workSession.cwd ?? process9?.cwd
+      ) : null;
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "status",
+        "Sent input to work session terminal"
+      );
+      await this.refreshWorkSessionTerminal(cmd.workSession._id, {
+        tmuxSessionName: cmd.workSession.tmuxSessionName,
+        tmuxWindowName: cmd.workSession.tmuxWindowName,
+        tmuxPaneId: cmd.workSession.tmuxPaneId,
+        cwd: cmd.workSession.cwd,
+        repoRoot: cmd.workSession.repoRoot,
+        branch: cmd.workSession.branch,
+        agentProvider: attachedSession?.process.provider ?? cmd.workSession.agentProvider,
+        agentSessionKey: attachedSession?.process.sessionKey ?? cmd.workSession.agentSessionKey
+      });
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "waiting_for_input",
+        latestSummary: `Input sent to ${cmd.workSession.tmuxPaneId}`,
+        title: cmd.liveActivity?.title,
+        processId: attachedSession?.processId ?? process9?._id
+      });
+      return;
+    }
     if (!process9 || !process9.supportsInboundMessages || !process9.sessionKey || !process9.cwd || !isBridgeProvider(process9.provider)) {
       throw new Error("No resumable local session is attached to this issue");
     }
-    console.log(`  > "${truncateForLog(body)}"`);
     await this.reportProcess({
       provider: process9.provider,
       providerLabel: process9.providerLabel ?? providerLabel(process9.provider),
@@ -1706,46 +2261,98 @@ var BridgeService = class {
     if (!workspacePath) {
       throw new Error("Launch command is missing workspacePath");
     }
-    if (!payload?.provider || !isBridgeProvider(payload.provider)) {
-      throw new Error("Launch command is missing a supported provider");
-    }
-    const provider = payload.provider;
-    const issueKey = payload.issueKey ?? cmd.liveActivity?.issueKey ?? "ISSUE";
-    const issueTitle = payload.issueTitle ?? cmd.liveActivity?.issueTitle ?? "Untitled issue";
+    const requestedProvider = 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 prompt2 = buildLaunchPrompt(issueKey, issueTitle, workspacePath);
+    const launchLabel = provider ? providerLabel(provider) : "shell session";
+    const workSessionTitle = `${issueKey}: ${issueTitle}`;
+    const sessionsBeforeLaunch = provider ? listObservedSessionsForWorkspace(provider, workspacePath) : [];
     await this.updateLiveActivity(cmd.liveActivityId, {
       status: "active",
-      latestSummary: `Launching ${providerLabel(provider)} in ${workspacePath}`,
-      delegatedRunId: payload.delegatedRunId,
+      latestSummary: `Launching ${launchLabel} in ${workspacePath}`,
+      delegatedRunId: payload?.delegatedRunId,
       launchStatus: "launching",
-      title: `${providerLabel(provider)} on ${this.config.displayName}`
+      title: workSessionTitle
     });
     await this.postAgentMessage(
       cmd.liveActivityId,
       "status",
-      `Launching ${providerLabel(provider)} in ${workspacePath}`
+      `Launching ${launchLabel} in ${workspacePath}`
     );
-    const result = await launchProviderSession(provider, workspacePath, prompt2);
-    const processId = await this.reportProcess({
-      ...result,
-      title: `${issueKey}: ${issueTitle}`
+    const tmuxSession = createTmuxWorkSession({
+      workspacePath,
+      issueKey,
+      issueTitle,
+      provider,
+      prompt: prompt2
     });
+    const attachedSession = provider ? await this.attachObservedAgentSession(
+      provider,
+      workspacePath,
+      sessionsBeforeLaunch,
+      tmuxSession.paneProcessId
+    ) : null;
+    await this.refreshWorkSessionTerminal(cmd.workSession?._id, {
+      tmuxSessionName: tmuxSession.sessionName,
+      tmuxWindowName: tmuxSession.windowName,
+      tmuxPaneId: tmuxSession.paneId,
+      cwd: workspacePath,
+      repoRoot: workspacePath,
+      branch: currentGitBranch(workspacePath),
+      agentProvider: provider,
+      agentSessionKey: attachedSession?.process.sessionKey
+    });
+    if (provider && !attachedSession) {
+      await this.postAgentMessage(
+        cmd.liveActivityId,
+        "status",
+        `Started tmux session ${tmuxSession.sessionName}:${tmuxSession.windowName}. Waiting to verify ${providerLabel(provider)} in ${tmuxSession.paneId}.`
+      );
+      await this.updateLiveActivity(cmd.liveActivityId, {
+        status: "waiting_for_input",
+        latestSummary: `Running in ${tmuxSession.sessionName}:${tmuxSession.windowName}; waiting to verify ${providerLabel(provider)}`,
+        delegatedRunId: payload?.delegatedRunId,
+        launchStatus: "running",
+        title: `${providerLabel(provider)} on ${this.config.displayName}`
+      });
+      return;
+    }
     await this.updateLiveActivity(cmd.liveActivityId, {
-      processId,
       status: "waiting_for_input",
-      latestSummary: summarizeMessage(result.responseText),
-      delegatedRunId: payload.delegatedRunId,
+      latestSummary: `Running in ${tmuxSession.sessionName}:${tmuxSession.windowName}`,
+      delegatedRunId: payload?.delegatedRunId,
       launchStatus: "running",
-      title: `${providerLabel(provider)} on ${this.config.displayName}`
+      processId: attachedSession?.processId,
+      title: workSessionTitle
     });
-    if (result.responseText) {
-      await this.postAgentMessage(
-        cmd.liveActivityId,
-        "assistant",
-        result.responseText
+  }
+  async attachObservedAgentSession(provider, workspacePath, sessionsBeforeLaunch = [], paneProcessId) {
+    if (!workspacePath) {
+      return null;
+    }
+    const existingKeys = new Set(
+      sessionsBeforeLaunch.map(sessionIdentityKey).filter(Boolean)
+    );
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      const observedSessions = listObservedSessionsForWorkspace(
+        provider,
+        workspacePath
       );
-      console.log(`  < "${truncateForLog(result.responseText)}"`);
+      const candidate = (paneProcessId ? findObservedSessionInProcessTree(observedSessions, paneProcessId) : void 0) ?? observedSessions.find(
+        (session) => !existingKeys.has(sessionIdentityKey(session))
+      ) ?? (attempt === 9 ? observedSessions[0] : void 0);
+      if (candidate) {
+        const processId = await this.reportProcess(candidate);
+        return {
+          process: candidate,
+          processId
+        };
+      }
+      await sleep(750);
     }
+    return null;
   }
   async reportProcess(process9) {
     const {
@@ -1831,6 +2438,98 @@ var BridgeService = class {
     }
   }
 };
+function createTmuxWorkSession(args) {
+  const slug = sanitizeTmuxName(args.issueKey.toLowerCase());
+  const sessionName = `vector-${slug}-${randomUUID().slice(0, 8)}`;
+  const windowName = sanitizeTmuxName(
+    args.provider === "codex" ? "codex" : args.provider === "claude_code" ? "claude" : "shell"
+  );
+  execFileSync("tmux", [
+    "new-session",
+    "-d",
+    "-s",
+    sessionName,
+    "-n",
+    windowName,
+    "-c",
+    args.workspacePath
+  ]);
+  const paneId = execFileSync(
+    "tmux",
+    [
+      "display-message",
+      "-p",
+      "-t",
+      `${sessionName}:${windowName}.0`,
+      "#{pane_id}"
+    ],
+    { encoding: "utf-8" }
+  ).trim();
+  const paneProcessId = execFileSync(
+    "tmux",
+    ["display-message", "-p", "-t", paneId, "#{pane_pid}"],
+    { encoding: "utf-8" }
+  ).trim();
+  if (args.provider) {
+    execFileSync("tmux", [
+      "send-keys",
+      "-t",
+      paneId,
+      buildManagedLaunchCommand(args.provider, args.prompt),
+      "Enter"
+    ]);
+  } else {
+    execFileSync("tmux", [
+      "send-keys",
+      "-t",
+      paneId,
+      `printf '%s\\n\\n' ${shellQuote(args.prompt)}`,
+      "Enter"
+    ]);
+  }
+  return {
+    sessionName,
+    windowName,
+    paneId,
+    paneProcessId
+  };
+}
+function sendTextToTmuxPane(paneId, text2) {
+  execFileSync("tmux", ["set-buffer", "--", text2]);
+  execFileSync("tmux", ["paste-buffer", "-t", paneId]);
+  execFileSync("tmux", ["send-keys", "-t", paneId, "Enter"]);
+  execFileSync("tmux", ["delete-buffer"]);
+}
+function captureTmuxPane(paneId) {
+  return execFileSync(
+    "tmux",
+    ["capture-pane", "-p", "-t", paneId, "-S", "-120"],
+    { encoding: "utf-8" }
+  ).replace(/\u001B\[[0-9;?]*[A-Za-z]/g, "").trimEnd();
+}
+function currentGitBranch(cwd) {
+  try {
+    return execSync2("git rev-parse --abbrev-ref HEAD", {
+      encoding: "utf-8",
+      cwd,
+      timeout: 3e3
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+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)}`;
+}
+function sanitizeTmuxName(value) {
+  return value.replace(/[^a-z0-9_-]+/gi, "-").replace(/^-+|-+$/g, "") || "work";
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
 async function setupBridgeDevice(client, convexUrl) {
   const deviceKey = getStableDeviceKey();
   const displayName = `${process.env.USER ?? "user"}'s ${platform() === "darwin" ? "Mac" : "machine"}`;
@@ -1897,6 +2596,78 @@ function summarizeMessage(message) {
 function truncateForLog(message) {
   return message.length > 80 ? `${message.slice(0, 77).trimEnd()}...` : message;
 }
+function listObservedSessionsForWorkspace(provider, workspacePath) {
+  return discoverAttachableSessions().filter(
+    (session) => session.provider === provider && matchesWorkspacePath(session, workspacePath)
+  ).sort(compareLocalSessionRecency);
+}
+function findObservedSessionInProcessTree(sessions, paneProcessId) {
+  const descendantIds = listDescendantProcessIds(paneProcessId);
+  if (descendantIds.size === 0) {
+    return void 0;
+  }
+  return sessions.find(
+    (session) => session.localProcessId ? descendantIds.has(session.localProcessId) : false
+  );
+}
+function listDescendantProcessIds(rootPid) {
+  const descendants = /* @__PURE__ */ new Set([rootPid]);
+  try {
+    const output = execSync2("ps -axo pid=,ppid=", {
+      encoding: "utf-8",
+      timeout: 3e3
+    });
+    const parentToChildren = /* @__PURE__ */ new Map();
+    for (const line of output.split("\n").map((value) => value.trim()).filter(Boolean)) {
+      const [pid, ppid] = line.split(/\s+/, 2);
+      if (!pid || !ppid) {
+        continue;
+      }
+      const children = parentToChildren.get(ppid) ?? [];
+      children.push(pid);
+      parentToChildren.set(ppid, children);
+    }
+    const queue = [rootPid];
+    while (queue.length > 0) {
+      const currentPid = queue.shift();
+      if (!currentPid) {
+        continue;
+      }
+      for (const childPid of parentToChildren.get(currentPid) ?? []) {
+        if (descendants.has(childPid)) {
+          continue;
+        }
+        descendants.add(childPid);
+        queue.push(childPid);
+      }
+    }
+  } catch {
+    return descendants;
+  }
+  return descendants;
+}
+function matchesWorkspacePath(session, workspacePath) {
+  const normalizedWorkspace = normalizePath(workspacePath);
+  const candidatePaths = [session.cwd, session.repoRoot].filter((value) => Boolean(value)).map(normalizePath);
+  return candidatePaths.some((path3) => path3 === normalizedWorkspace);
+}
+function normalizePath(value) {
+  return value.replace(/\/+$/, "");
+}
+function sessionIdentityKey(session) {
+  return [
+    session.provider,
+    session.sessionKey,
+    session.localProcessId,
+    session.cwd
+  ].filter(Boolean).join("::");
+}
+function compareLocalSessionRecency(a, b) {
+  return Number(b.localProcessId ?? 0) - Number(a.localProcessId ?? 0);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function isBridgeProvider(provider) {
   return provider === "codex" || provider === "claude_code";
 }
@@ -1911,7 +2682,7 @@ function installLaunchAgent(vcliPath) {
   const programArguments = getLaunchAgentProgramArguments(vcliPath);
   const environmentVariables = [
     "  <key>PATH</key>",
-    "  <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>",
+    "  <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>",
     ...process.env.VECTOR_HOME?.trim() ? [
       "  <key>VECTOR_HOME</key>",
       `  <string>${process.env.VECTOR_HOME.trim()}</string>`
@@ -2466,13 +3237,6 @@ function requireOrg(runtime, explicit) {
   }
   return orgSlug;
 }
-function readJsonFile(path3, fallback) {
-  try {
-    return JSON.parse(readFileSync3(path3, "utf8"));
-  } catch {
-    return fallback;
-  }
-}
 function hostForAppUrl(appUrl) {
   if (!appUrl) {
     return void 0;
@@ -2525,6 +3289,28 @@ function parseAgentProvider(value) {
   }
   throw new Error("provider must be one of: codex, claude_code, vector_cli");
 }
+function isBridgeDeviceAuthError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const maybeData = error.data;
+  return maybeData === "INVALID_DEVICE_SECRET" || maybeData === "DEVICE_NOT_FOUND";
+}
+async function validateStoredBridgeConfig(config) {
+  const client = new ConvexHttpClient3(config.convexUrl);
+  try {
+    await client.mutation(api.agentBridge.bridgePublic.heartbeat, {
+      deviceId: config.deviceId,
+      deviceSecret: config.deviceSecret
+    });
+    return true;
+  } catch (error) {
+    if (isBridgeDeviceAuthError(error)) {
+      return false;
+    }
+    throw error;
+  }
+}
 async function getClient(command) {
   const runtime = await getRuntime(command);
   const session = requireSession(runtime);
@@ -2552,7 +3338,7 @@ async function ensureBridgeConfig(command) {
     const backendDevice = config ? await runQuery(client, api.agentBridge.queries.getDevice, {
       deviceId: config.deviceId
     }) : null;
-    const needsRegistration = !config || config.userId !== user._id || config.convexUrl !== runtime.convexUrl || !backendDevice;
+    const needsRegistration = !config || config.userId !== user._id || config.convexUrl !== runtime.convexUrl || !backendDevice || !await validateStoredBridgeConfig(config);
     if (needsRegistration) {
       config = await setupBridgeDevice(client, runtime.convexUrl);
     }
@@ -4361,11 +5147,8 @@ serviceCommand.command("menu-state").description("Return JSON state for the macO
   const globalOptions = command.optsWithGlobals();
   const profile = globalOptions.profile ?? "default";
   const session = await readSession(profile);
-  const liveActivities = readJsonFile(
-    join3(VECTOR_HOME, "live-activities.json"),
-    []
-  );
-  let processes = [];
+  let workSessions = [];
+  let detectedSessions = [];
   try {
     const runtime = await getRuntime(command);
     if (runtime.session && status.config?.deviceId) {
@@ -4374,6 +5157,13 @@ serviceCommand.command("menu-state").description("Return JSON state for the macO
         runtime.appUrl,
         runtime.convexUrl
       );
+      workSessions = await runQuery(
+        client,
+        api.agentBridge.queries.listDeviceWorkSessions,
+        {
+          deviceId: status.config.deviceId
+        }
+      );
       const devices = await runQuery(
         client,
         api.agentBridge.queries.listProcessesForAttach,
@@ -4382,10 +5172,11 @@ serviceCommand.command("menu-state").description("Return JSON state for the macO
       const currentDevice = devices.find(
         (entry) => entry.device._id === status.config?.deviceId
       );
-      processes = currentDevice?.processes ?? [];
+      detectedSessions = currentDevice?.processes ?? [];
     }
   } catch {
-    processes = [];
+    workSessions = [];
+    detectedSessions = [];
   }
   printOutput(
     {
@@ -4395,8 +5186,8 @@ serviceCommand.command("menu-state").description("Return JSON state for the macO
       pid: status.pid,
       config: status.config,
       sessionInfo: buildMenuSessionInfo(session),
-      liveActivities,
-      processes
+      workSessions,
+      detectedSessions
     },
     Boolean(globalOptions.json)
   );