agent-flow-app 0.6.0

package/dist/app.js

@@ -0,0 +1,2072 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// scripts/setup.js
+var require_setup = __commonJS({
+  "scripts/setup.js"(exports2, module2) {
+    "use strict";
+    var fs5 = require("fs");
+    var path4 = require("path");
+    var os2 = require("os");
+    var { execFileSync } = require("child_process");
+    var DISCOVERY_DIR2 = path4.join(os2.homedir(), ".claude", "agent-flow");
+    var HOOK_SCRIPT_PATH = path4.join(DISCOVERY_DIR2, "hook.js");
+    var SETTINGS_PATH = path4.join(os2.homedir(), ".claude", "settings.json");
+    var HOOK_TIMEOUT_S = 2;
+    var HOOK_SAFETY_MARGIN_MS = 500;
+    var HOOK_FORWARD_TIMEOUT_MS = 1e3;
+    var HOOK_COMMAND_MARKER = "agent-flow/hook.js";
+    function resolveNodePath() {
+      try {
+        const cmd = process.platform === "win32" ? "where" : "command";
+        const args2 = process.platform === "win32" ? ["node"] : ["-v", "node"];
+        const result = execFileSync(cmd, args2, { encoding: "utf8", timeout: 3e3 }).trim();
+        const firstLine = result.split(/\r?\n/)[0].trim();
+        if (firstLine)
+          return firstLine;
+      } catch {
+      }
+      return "node";
+    }
+    function getHookScriptContent() {
+      return `#!/usr/bin/env node
+// Agent Flow hook forwarder v3 \u2014 installed by the Agent Flow setup script.
+// Claude Code invokes this as a command hook. It reads a discovery directory to
+// find live extension instances, checks their PIDs, and forwards the event via
+// HTTP POST. Dead instances are cleaned up automatically.
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const os = require('os');
+
+setTimeout(() => process.exit(0), ${HOOK_TIMEOUT_S * 1e3 - HOOK_SAFETY_MARGIN_MS});
+
+const DIR = path.join(os.homedir(), '.claude', 'agent-flow');
+const IS_WIN = process.platform === 'win32';
+
+function normPath(p) {
+  let r = path.resolve(p);
+  try { r = fs.realpathSync(r); } catch {}
+  return r;
+}
+
+function isAlive(pid) {
+  if (IS_WIN) return true;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => { input += c; });
+process.stdin.on('end', () => {
+  let cwd;
+  try { cwd = JSON.parse(input).cwd; } catch { process.exit(0); }
+  if (!cwd) process.exit(0);
+
+  const resolvedCwd = normPath(cwd);
+
+  let allFiles;
+  try {
+    allFiles = fs.readdirSync(DIR).filter(f => f.endsWith('.json') && f !== 'workspaces.json');
+  } catch { process.exit(0); }
+  if (!allFiles.length) process.exit(0);
+
+  const matches = [];
+  for (const file of allFiles) {
+    let d;
+    try { d = JSON.parse(fs.readFileSync(path.join(DIR, file), 'utf8')); } catch { continue; }
+    if (!d.workspace || !d.pid || !d.port) continue;
+
+    if (!isAlive(d.pid)) {
+      try { fs.unlinkSync(path.join(DIR, file)); } catch {}
+      continue;
+    }
+
+    const ws = normPath(d.workspace);
+    if (resolvedCwd === ws || resolvedCwd.startsWith(ws + path.sep)) {
+      matches.push({ d, file, wsLen: ws.length });
+    }
+  }
+
+  if (!matches.length) process.exit(0);
+
+  matches.sort((a, b) => b.wsLen - a.wsLen);
+  const bestLen = matches[0].wsLen;
+  const targets = matches.filter(m => m.wsLen === bestLen);
+
+  let pending = targets.length;
+  for (const { d } of targets) {
+    let settled = false;
+    const finish = () => { if (settled) return; settled = true; done(); };
+    const req = http.request({
+      hostname: '127.0.0.1', port: d.port, method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      timeout: ${HOOK_FORWARD_TIMEOUT_MS},
+    }, res => { res.resume(); res.on('end', finish); });
+    req.on('error', finish);
+    req.on('timeout', () => { req.destroy(); });
+    req.write(input);
+    req.end();
+  }
+
+  function done() { if (--pending <= 0) process.exit(0); }
+});
+`;
+    }
+    function ensureHookScript() {
+      if (!fs5.existsSync(DISCOVERY_DIR2)) {
+        fs5.mkdirSync(DISCOVERY_DIR2, { recursive: true });
+      }
+      const script = getHookScriptContent();
+      try {
+        if (fs5.existsSync(HOOK_SCRIPT_PATH) && fs5.readFileSync(HOOK_SCRIPT_PATH, "utf8") === script) {
+          console.log("Hook script already up to date:", HOOK_SCRIPT_PATH);
+          return;
+        }
+      } catch {
+      }
+      const tmpPath = HOOK_SCRIPT_PATH + `.${process.pid}.tmp`;
+      fs5.writeFileSync(tmpPath, script, { mode: 493 });
+      fs5.renameSync(tmpPath, HOOK_SCRIPT_PATH);
+      console.log("Installed hook script:", HOOK_SCRIPT_PATH);
+    }
+    function isAgentFlowHook(entry) {
+      return entry.hooks?.some(
+        (h) => h.command?.includes(HOOK_COMMAND_MARKER) || h.url?.startsWith("http://127.0.0.1:")
+      );
+    }
+    function configureHooks() {
+      const nodePath = resolveNodePath();
+      const hookCommand = `"${nodePath}" "${HOOK_SCRIPT_PATH}"`;
+      const hookEntry = { hooks: [{ type: "command", command: hookCommand, timeout: HOOK_TIMEOUT_S }] };
+      const events = [
+        "SessionStart",
+        "PreToolUse",
+        "PostToolUse",
+        "PostToolUseFailure",
+        "SubagentStart",
+        "SubagentStop",
+        "Notification",
+        "Stop",
+        "SessionEnd"
+      ];
+      let settings = {};
+      try {
+        if (fs5.existsSync(SETTINGS_PATH)) {
+          settings = JSON.parse(fs5.readFileSync(SETTINGS_PATH, "utf-8"));
+        }
+      } catch {
+        console.log("Could not read existing settings, starting fresh");
+      }
+      const existingHooks = settings.hooks || {};
+      for (const event of events) {
+        const existing = existingHooks[event] || [];
+        const filtered = existing.filter((entry) => !isAgentFlowHook(entry));
+        existingHooks[event] = [...filtered, hookEntry];
+      }
+      settings.hooks = existingHooks;
+      const dir = path4.dirname(SETTINGS_PATH);
+      if (!fs5.existsSync(dir)) {
+        fs5.mkdirSync(dir, { recursive: true });
+      }
+      fs5.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+      console.log("Configured Claude Code hooks in:", SETTINGS_PATH);
+    }
+    function isAlreadySetup() {
+      if (!fs5.existsSync(HOOK_SCRIPT_PATH))
+        return false;
+      try {
+        if (!fs5.existsSync(SETTINGS_PATH))
+          return false;
+        const settings = JSON.parse(fs5.readFileSync(SETTINGS_PATH, "utf-8"));
+        const hooks = settings.hooks;
+        if (!hooks || typeof hooks !== "object")
+          return false;
+        return Object.values(hooks).some((entries) => {
+          if (!Array.isArray(entries))
+            return false;
+          return entries.some((entry) => isAgentFlowHook(entry));
+        });
+      } catch {
+        return false;
+      }
+    }
+    function ensureSetup2() {
+      if (isAlreadySetup())
+        return;
+      console.log("Setting up agent hooks...");
+      ensureHookScript();
+      configureHooks();
+      console.log("");
+    }
+    module2.exports = { ensureSetup: ensureSetup2 };
+    if (require.main === module2) {
+      const force = process.argv.includes("--force");
+      if (!force && isAlreadySetup()) {
+        console.log("Agent Flow is already set up. Run with --force to reconfigure.");
+        process.exit(0);
+      }
+      console.log("Setting up Agent Flow...\n");
+      ensureHookScript();
+      configureHooks();
+      console.log("\nDone! New sessions will stream events to Agent Flow.");
+    }
+  }
+});
+
+// scripts/vscode-shim.js
+var require_vscode_shim = __commonJS({
+  "scripts/vscode-shim.js"(exports2, module2) {
+    "use strict";
+    var EventEmitter2 = class {
+      constructor() {
+        this._listeners = [];
+      }
+      get event() {
+        return (listener) => {
+          this._listeners.push(listener);
+          return { dispose: () => {
+            const i = this._listeners.indexOf(listener);
+            if (i >= 0)
+              this._listeners.splice(i, 1);
+          } };
+        };
+      }
+      fire(data) {
+        for (const l of this._listeners)
+          l(data);
+      }
+      dispose() {
+        this._listeners = [];
+      }
+    };
+    module2.exports = {
+      EventEmitter: EventEmitter2,
+      workspace: {
+        workspaceFolders: [{ uri: { fsPath: process.cwd() } }],
+        getConfiguration: () => ({ get: () => void 0 })
+      },
+      window: {
+        showInformationMessage: () => {
+        }
+      }
+    };
+  }
+});
+
+// app/src/args.ts
+function parseArgs(argv) {
+  let port = 3001;
+  let open = true;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if ((arg === "--port" || arg === "-p") && argv[i + 1]) {
+      const n = parseInt(argv[i + 1], 10);
+      if (!isNaN(n) && n > 0 && n < 65536)
+        port = n;
+      i++;
+    } else if (arg === "--no-open") {
+      open = false;
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(`
+Usage: agent-flow [options]
+
+Options:
+  -p, --port <number>  Port for the server (default: 3001)
+  --no-open            Don't open the browser automatically
+  -h, --help           Show this help message
+`);
+      process.exit(0);
+    }
+  }
+  return { port, open };
+}
+
+// app/src/app.ts
+var import_setup = __toESM(require_setup());
+
+// app/src/server.ts
+var http2 = __toESM(require("http"));
+var import_child_process = require("child_process");
+
+// scripts/relay.ts
+var crypto = __toESM(require("crypto"));
+var fs3 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var os = __toESM(require("os"));
+
+// extension/src/hook-server.ts
+var http = __toESM(require("http"));
+var vscode = __toESM(require_vscode_shim());
+
+// extension/src/protocol.ts
+function emitSubagentSpawn(emitter, parent, child, task, sessionId) {
+  emitter.emit({
+    time: emitter.elapsed(sessionId),
+    type: "subagent_dispatch",
+    payload: { parent, child, task }
+  }, sessionId);
+  emitter.emit({
+    time: emitter.elapsed(sessionId),
+    type: "agent_spawn",
+    payload: { name: child, parent, task }
+  }, sessionId);
+}
+
+// extension/src/constants.ts
+var INACTIVITY_TIMEOUT_MS = 5 * 60 * 1e3;
+var SCAN_INTERVAL_MS = 1e3;
+var POLL_FALLBACK_MS = 3e3;
+var PERMISSION_DETECT_MS = 5e3;
+var ACTIVE_SESSION_AGE_S = 10 * 60;
+var HOOK_SERVER_NOT_STARTED = -1;
+var HOOK_MAX_BODY_SIZE = 1024 * 1024;
+var WORKSPACE_HASH_LENGTH = 16;
+var PREVIEW_MAX = 60;
+var ARGS_MAX = 80;
+var RESULT_MAX = 200;
+var MESSAGE_MAX = 2e3;
+var SESSION_LABEL_MAX = 14;
+var SESSION_LABEL_TRUNCATED = SESSION_LABEL_MAX - 2;
+var DISCOVERY_LABEL_MAX = 40;
+var DISCOVERY_LABEL_TAIL = DISCOVERY_LABEL_MAX - 3;
+var DISCOVERY_CONTENT_MAX = 100;
+var TASK_MAX = 60;
+var EDIT_CONTENT_MAX = 500;
+var WEB_FETCH_PROMPT_MAX = 200;
+var CHILD_NAME_MAX = 30;
+var SKILL_NAME_MAX = 40;
+var URL_PATH_MAX = 40;
+var SESSION_ID_DISPLAY = 8;
+var FAILED_RESULT_MAX = 100;
+var CHARS_PER_TOKEN = 4;
+var MIN_TOKEN_ESTIMATE = 10;
+var FALLBACK_TOKEN_ESTIMATE = 200;
+var GREP_TOKEN_MULTIPLIER = 0.5;
+var DEFAULT_TOKEN_MULTIPLIER = 0.3;
+var SYSTEM_PROMPT_BASE_TOKENS = 5e3;
+var HASH_PREFIX_MAX = 200;
+var HOOK_SERVER_HOST = "127.0.0.1";
+var HOOK_URL_PREFIX = `http://${HOOK_SERVER_HOST}:`;
+var ORCHESTRATOR_NAME = "orchestrator";
+var FILE_TOOLS = ["Read", "Edit", "Write", "Glob", "Grep"];
+var PATTERN_TOOLS = ["Glob", "Grep"];
+var SUBAGENT_ID_SUFFIX_LENGTH = 6;
+function generateSubagentFallbackName(id, index) {
+  return `subagent-${id.length > SUBAGENT_ID_SUFFIX_LENGTH ? id.slice(-SUBAGENT_ID_SUFFIX_LENGTH) : index}`;
+}
+function resolveSubagentChildName(input) {
+  return String(input.description || input.subagent_type || "subagent").slice(0, CHILD_NAME_MAX);
+}
+var SYSTEM_CONTENT_PREFIXES = [
+  "This session is being continued",
+  "<ide_",
+  "<system-reminder",
+  "<available-deferred-tools",
+  "<command-name"
+];
+
+// extension/src/tool-summarizer.ts
+function tailPath(filePath, segments = 2) {
+  return String(filePath).split("/").slice(-segments).join("/");
+}
+function summarizeInput(toolName, input) {
+  if (!input) {
+    return "";
+  }
+  switch (toolName) {
+    case "Bash":
+      return String(input.command || "").slice(0, ARGS_MAX);
+    case "Read":
+      return tailPath(String(input.file_path || input.path || ""));
+    case "Edit":
+      return tailPath(String(input.file_path || "")) + " \u2014 edit";
+    case "Write":
+      return tailPath(String(input.file_path || "")) + " \u2014 write";
+    case "Glob":
+      return String(input.pattern || "");
+    case "Grep":
+      return String(input.pattern || "");
+    case "Task":
+    case "Agent":
+      return String(input.description || input.prompt || "").slice(0, TASK_MAX);
+    case "TodoWrite": {
+      const todos = input.todos;
+      if (Array.isArray(todos) && todos.length > 0) {
+        const active = todos.find((t) => t.status === "in_progress");
+        const label = active?.activeForm || active?.content || todos[0]?.content || "todos";
+        const done = todos.filter((t) => t.status === "completed").length;
+        return `${label} (${done}/${todos.length})`.slice(0, ARGS_MAX);
+      }
+      return "updating todos";
+    }
+    case "WebSearch":
+      return String(input.query || "").slice(0, ARGS_MAX);
+    case "WebFetch": {
+      const url = String(input.url || "");
+      try {
+        const u = new URL(url);
+        return u.hostname + u.pathname.slice(0, URL_PATH_MAX);
+      } catch {
+        return url.slice(0, ARGS_MAX);
+      }
+    }
+    case "AskUserQuestion": {
+      const questions = input.questions;
+      if (Array.isArray(questions) && questions[0]?.question) {
+        return String(questions[0].question).slice(0, ARGS_MAX);
+      }
+      return "asking user...";
+    }
+    case "Skill":
+      return String(input.skill || "").slice(0, SKILL_NAME_MAX);
+    case "NotebookEdit":
+      return tailPath(String(input.notebook_path || "")) + ` cell ${input.cell_number ?? "?"}`;
+    default:
+      return JSON.stringify(input).slice(0, ARGS_MAX);
+  }
+}
+function summarizeResult(content) {
+  if (typeof content === "string") {
+    return content.slice(0, RESULT_MAX);
+  }
+  if (Array.isArray(content)) {
+    return content.map((c) => {
+      if (typeof c === "string") {
+        return c;
+      }
+      if (c && typeof c === "object" && "text" in c) {
+        return String(c.text);
+      }
+      return "";
+    }).join("\n").slice(0, RESULT_MAX);
+  }
+  if (content && typeof content === "object" && !Array.isArray(content)) {
+    const obj = content;
+    if (typeof obj.content === "string") {
+      return obj.content.slice(0, RESULT_MAX);
+    }
+    if (typeof obj.text === "string") {
+      return obj.text.slice(0, RESULT_MAX);
+    }
+    try {
+      return JSON.stringify(content).slice(0, RESULT_MAX);
+    } catch {
+    }
+  }
+  return String(content || "").slice(0, RESULT_MAX);
+}
+function extractInputData(toolName, input) {
+  if (!input) {
+    return void 0;
+  }
+  try {
+    switch (toolName) {
+      case "Edit":
+        return {
+          file_path: String(input.file_path || ""),
+          old_string: String(input.old_string || "").slice(0, EDIT_CONTENT_MAX),
+          new_string: String(input.new_string || "").slice(0, EDIT_CONTENT_MAX)
+        };
+      case "TodoWrite":
+        return { todos: input.todos };
+      case "Write":
+        return {
+          file_path: String(input.file_path || ""),
+          content: String(input.content || "").slice(0, EDIT_CONTENT_MAX)
+        };
+      case "Bash":
+        return {
+          command: String(input.command || ""),
+          description: String(input.description || "")
+        };
+      case "Read":
+        return {
+          file_path: String(input.file_path || input.path || ""),
+          offset: typeof input.offset === "number" ? input.offset : void 0,
+          limit: typeof input.limit === "number" ? input.limit : void 0
+        };
+      case "Grep":
+        return {
+          pattern: String(input.pattern || ""),
+          path: String(input.path || ""),
+          glob: typeof input.glob === "string" ? input.glob : void 0
+        };
+      case "Glob":
+        return {
+          pattern: String(input.pattern || ""),
+          path: String(input.path || "")
+        };
+      case "WebSearch":
+        return {
+          query: String(input.query || "")
+        };
+      case "WebFetch":
+        return {
+          url: String(input.url || ""),
+          prompt: String(input.prompt || "").slice(0, WEB_FETCH_PROMPT_MAX)
+        };
+      case "AskUserQuestion": {
+        const qs = input.questions;
+        return {
+          questions: Array.isArray(qs) ? qs.map((q) => ({
+            question: String(q.question || ""),
+            options: Array.isArray(q.options) ? q.options.map((o) => String(o.label || "")) : []
+          })) : []
+        };
+      }
+      default:
+        return void 0;
+    }
+  } catch {
+    return void 0;
+  }
+}
+function extractFilePath(input) {
+  if (!input) {
+    return void 0;
+  }
+  const raw = input.file_path || input.path;
+  return typeof raw === "string" ? raw : void 0;
+}
+function buildDiscovery(toolName, filePath, result) {
+  if (!FILE_TOOLS.includes(toolName) || !filePath) {
+    return void 0;
+  }
+  return {
+    type: PATTERN_TOOLS.includes(toolName) ? "pattern" : "file",
+    label: filePath.length > DISCOVERY_LABEL_MAX ? "..." + filePath.slice(-DISCOVERY_LABEL_TAIL) : filePath,
+    content: result.slice(0, DISCOVERY_CONTENT_MAX)
+  };
+}
+function detectError(content) {
+  const lower = content.toLowerCase();
+  const patterns = [
+    "error:",
+    "error[",
+    "exception:",
+    "failed",
+    "permission denied",
+    "command failed",
+    "cannot find",
+    "not found",
+    "enoent",
+    "fatal:",
+    "panic:",
+    "segfault",
+    "syntax error"
+  ];
+  return patterns.some((p) => lower.includes(p));
+}
+
+// extension/src/token-estimator.ts
+function estimateTokensFromContent(content) {
+  if (typeof content === "string") {
+    return Math.max(Math.ceil(content.length / CHARS_PER_TOKEN), MIN_TOKEN_ESTIMATE);
+  }
+  if (Array.isArray(content)) {
+    let total = 0;
+    for (const item of content) {
+      if (typeof item === "string") {
+        total += item.length;
+      } else if (item && typeof item === "object" && "text" in item) {
+        total += String(item.text || "").length;
+      }
+    }
+    return Math.max(Math.ceil(total / CHARS_PER_TOKEN), MIN_TOKEN_ESTIMATE);
+  }
+  return FALLBACK_TOKEN_ESTIMATE;
+}
+function estimateTokensFromText(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateTokenCost(toolName, result) {
+  const baseTokens = Math.ceil(result.length / CHARS_PER_TOKEN);
+  if (toolName === "Read") {
+    return baseTokens;
+  }
+  if (toolName === "Grep" || toolName === "Glob") {
+    return Math.ceil(baseTokens * GREP_TOKEN_MULTIPLIER);
+  }
+  return Math.ceil(baseTokens * DEFAULT_TOKEN_MULTIPLIER);
+}
+
+// extension/src/logger.ts
+var LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+var minLevel = "info";
+function shouldLog(level) {
+  return (LOG_LEVELS[level] ?? 0) >= (LOG_LEVELS[minLevel] ?? 0);
+}
+function createLogger(tag) {
+  const prefix = `[${tag}]`;
+  return {
+    debug(...args2) {
+      if (shouldLog("debug"))
+        console.log(prefix, ...args2);
+    },
+    info(...args2) {
+      if (shouldLog("info"))
+        console.log(prefix, ...args2);
+    },
+    warn(...args2) {
+      if (shouldLog("warn"))
+        console.warn(prefix, ...args2);
+    },
+    error(...args2) {
+      if (shouldLog("error"))
+        console.error(prefix, ...args2);
+    }
+  };
+}
+
+// extension/src/hook-server.ts
+var log = createLogger("HookServer");
+var HookServer = class {
+  server = null;
+  port;
+  /** Per-session state — cleaned up on SessionEnd/Stop to prevent unbounded growth */
+  sessionState = /* @__PURE__ */ new Map();
+  _onEvent = new vscode.EventEmitter();
+  onEvent = this._onEvent.event;
+  constructor(port) {
+    this.port = port ?? 0;
+  }
+  async start() {
+    return new Promise((resolve2, reject) => {
+      this.server = http.createServer((req, res) => {
+        if (req.method === "POST") {
+          let body = "";
+          let oversized = false;
+          req.on("data", (chunk) => {
+            if (oversized)
+              return;
+            body += chunk.toString();
+            if (body.length > HOOK_MAX_BODY_SIZE) {
+              oversized = true;
+              body = "";
+              log.warn("Request body exceeded size limit, discarding");
+            }
+          });
+          req.on("end", () => {
+            if (!oversized) {
+              try {
+                const parsed = JSON.parse(body);
+                if (!parsed || typeof parsed !== "object" || !("session_id" in parsed) || !("hook_event_name" in parsed) || typeof parsed.session_id !== "string" || typeof parsed.hook_event_name !== "string") {
+                  log.warn("Invalid hook payload: missing session_id or hook_event_name");
+                } else {
+                  this.handleHook(parsed);
+                }
+              } catch (e) {
+                log.error("Failed to parse payload:", e);
+              }
+            }
+            res.writeHead(200);
+            res.end();
+          });
+        } else {
+          res.writeHead(200, { "Content-Type": "text/plain" });
+          res.end("Agent Visualizer Hook Server");
+        }
+      });
+      this.server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          log.info(`Port ${this.port} in use (another instance owns it) \u2014 skipping hook server`);
+          this.server?.close();
+          this.server = null;
+          resolve2(HOOK_SERVER_NOT_STARTED);
+        } else {
+          reject(err);
+        }
+      });
+      this.server.listen(this.port, HOOK_SERVER_HOST, () => {
+        const addr = this.server.address();
+        this.port = addr.port;
+        log.info(`Listening on http://127.0.0.1:${this.port}`);
+        resolve2(this.port);
+      });
+    });
+  }
+  getPort() {
+    return this.port;
+  }
+  getOrCreateSession(sessionId) {
+    let state = this.sessionState.get(sessionId);
+    if (!state) {
+      state = { startTime: Date.now(), agentNames: /* @__PURE__ */ new Map() };
+      this.sessionState.set(sessionId, state);
+    }
+    return state;
+  }
+  elapsedSeconds(sessionId) {
+    const startTime = sessionId ? this.sessionState.get(sessionId)?.startTime ?? Date.now() : Date.now();
+    return (Date.now() - startTime) / 1e3;
+  }
+  handleHook(payload) {
+    const eventName = payload.hook_event_name;
+    log.debug(eventName, payload.tool_name || payload.agent_type || "");
+    switch (eventName) {
+      case "SessionStart":
+        this.handleSessionStart(payload);
+        break;
+      case "PreToolUse":
+        this.handlePreToolUse(payload);
+        break;
+      case "PostToolUse":
+        this.handlePostToolUse(payload);
+        break;
+      case "PostToolUseFailure":
+        this.handlePostToolUseFailure(payload);
+        break;
+      case "SubagentStart":
+        this.handleSubagentStart(payload);
+        break;
+      case "SubagentStop":
+        this.handleSubagentStop(payload);
+        break;
+      case "Notification":
+        this.handleNotification(payload);
+        break;
+      case "Stop":
+        this.handleStop(payload);
+        break;
+      case "SessionEnd":
+        this.handleSessionEnd(payload);
+        break;
+    }
+  }
+  handleSessionStart(payload) {
+    this.getOrCreateSession(payload.session_id);
+    this.emit({
+      time: 0,
+      type: "agent_spawn",
+      payload: {
+        name: ORCHESTRATOR_NAME,
+        isMain: true,
+        task: `Session ${payload.session_id.slice(0, SESSION_ID_DISPLAY)}`
+      }
+    }, payload.session_id);
+  }
+  handlePreToolUse(payload) {
+    const agentName = this.resolveAgentName(payload);
+    const toolName = payload.tool_name || "unknown";
+    const args2 = summarizeInput(toolName, payload.tool_input);
+    if (!this.sessionState.has(payload.session_id)) {
+      this.handleSessionStart(payload);
+    }
+    this.emit({
+      time: this.elapsedSeconds(payload.session_id),
+      type: "tool_call_start",
+      payload: {
+        agent: agentName,
+        tool: toolName,
+        args: args2,
+        preview: `${toolName}: ${args2}`.slice(0, PREVIEW_MAX)
+      }
+    }, payload.session_id);
+  }
+  handlePostToolUse(payload) {
+    const agentName = this.resolveAgentName(payload);
+    const toolName = payload.tool_name || "unknown";
+    const result = payload.tool_response ? summarizeResult(payload.tool_response) : "";
+    const tokenCost = estimateTokenCost(toolName, result);
+    const discovery = buildDiscovery(toolName, extractFilePath(payload.tool_input), result);
+    this.emit({
+      time: this.elapsedSeconds(payload.session_id),
+      type: "tool_call_end",
+      payload: {
+        agent: agentName,
+        tool: toolName,
+        result: result.slice(0, RESULT_MAX),
+        tokenCost,
+        ...discovery ? { discovery } : {}
+      }
+    }, payload.session_id);
+  }
+  handlePostToolUseFailure(payload) {
+    const agentName = this.resolveAgentName(payload);
+    const toolName = payload.tool_name || "unknown";
+    this.emit({
+      time: this.elapsedSeconds(payload.session_id),
+      type: "tool_call_end",
+      payload: {
+        agent: agentName,
+        tool: toolName,
+        result: `[FAILED] ${(payload.tool_response ? summarizeResult(payload.tool_response) : "").slice(0, FAILED_RESULT_MAX)}`,
+        tokenCost: 0
+      }
+    }, payload.session_id);
+  }
+  handleSubagentStart(payload) {
+    const parentName = this.resolveAgentName(payload);
+    const agentType = payload.agent_type || "subagent";
+    const agentId = payload.agent_id || "";
+    const sessionAgents = this.getOrCreateSession(payload.session_id).agentNames;
+    const childName = agentId ? `${agentType}-${agentId.slice(-SUBAGENT_ID_SUFFIX_LENGTH)}` : generateSubagentFallbackName(String(Date.now()), sessionAgents.size + 1);
+    sessionAgents.set(agentId, childName);
+    emitSubagentSpawn(
+      { emit: (e, s) => this.emit(e, s), elapsed: (s) => this.elapsedSeconds(s) },
+      parentName,
+      childName,
+      agentType,
+      payload.session_id
+    );
+  }
+  handleSubagentStop(payload) {
+    const agentId = payload.agent_id || "";
+    const sessionAgents = this.sessionState.get(payload.session_id)?.agentNames;
+    const childName = sessionAgents?.get(agentId) || "subagent";
+    const parentName = this.resolveAgentName(payload);
+    this.emit({
+      time: this.elapsedSeconds(payload.session_id),
+      type: "subagent_return",
+      payload: { child: childName, parent: parentName, summary: `${payload.agent_type} complete` }
+    }, payload.session_id);
+    this.emit({
+      time: this.elapsedSeconds(payload.session_id),
+      type: "agent_complete",
+      payload: { name: childName }
+    }, payload.session_id);
+  }
+  handleNotification(payload) {
+    if (payload.notification_type !== "permission_prompt")
+      return;
+    this.emit({
+      time: this.elapsedSeconds(payload.session_id),
+      type: "permission_requested",
+      payload: {
+        agent: ORCHESTRATOR_NAME,
+        message: payload.message || "Permission needed",
+        title: payload.title || "Permission needed"
+      }
+    }, payload.session_id);
+  }
+  handleStop(payload) {
+    this.emit({
+      time: this.elapsedSeconds(payload.session_id),
+      type: "agent_complete",
+      payload: { name: ORCHESTRATOR_NAME }
+    }, payload.session_id);
+  }
+  handleSessionEnd(payload) {
+    this.emit({
+      time: this.elapsedSeconds(payload.session_id),
+      type: "agent_complete",
+      payload: { name: ORCHESTRATOR_NAME, sessionEnd: true }
+    }, payload.session_id);
+    this.sessionState.delete(payload.session_id);
+  }
+  // ─── Helpers ─────────────────────────────────────────────────────────────
+  resolveAgentName(payload) {
+    if (payload.agent_id) {
+      const name = this.sessionState.get(payload.session_id)?.agentNames.get(payload.agent_id);
+      if (name)
+        return name;
+    }
+    return ORCHESTRATOR_NAME;
+  }
+  emit(event, sessionId) {
+    this._onEvent.fire(sessionId ? { ...event, sessionId } : event);
+  }
+  dispose() {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+    this.sessionState.clear();
+    this._onEvent.dispose();
+  }
+};
+
+// extension/src/fs-utils.ts
+var fs = __toESM(require("fs"));
+function readFileChunk(filePath, offset, length) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const buffer = Buffer.alloc(length);
+    fs.readSync(fd, buffer, 0, length, offset);
+    return buffer.toString("utf-8");
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function readNewFileLines(filePath, lastSize) {
+  let stat;
+  try {
+    stat = fs.statSync(filePath);
+  } catch {
+    return null;
+  }
+  if (stat.size < lastSize) {
+    return { lines: [], newSize: 0 };
+  }
+  if (stat.size <= lastSize) {
+    return null;
+  }
+  const newContent = readFileChunk(filePath, lastSize, stat.size - lastSize);
+  const lines = newContent.split(/\r?\n/).filter(Boolean);
+  return { lines, newSize: stat.size };
+}
+
+// extension/src/transcript-parser.ts
+var log2 = createLogger("TranscriptParser");
+function isRecord(v) {
+  return v !== null && typeof v === "object";
+}
+function safeText(block) {
+  if (!isRecord(block))
+    return "";
+  return String(block.text || "").trim();
+}
+function safeThinking(block) {
+  if (!isRecord(block))
+    return "";
+  return String(block.thinking || "").trim();
+}
+var TranscriptParser = class {
+  constructor(delegate) {
+    this.delegate = delegate;
+  }
+  /** Per-subagent dedup state for inline progress events, keyed by parentToolUseID */
+  inlineSubagentState = /* @__PURE__ */ new Map();
+  /** Maps Agent tool_use ID → resolved child agent name (set in handleToolUse) */
+  subagentChildNames = /* @__PURE__ */ new Map();
+  /** Clean up state associated with a completed session to prevent unbounded Map growth.
+   *  Pass the session's pending tool_use_ids so we can remove orphaned entries. */
+  clearSessionState(pendingToolUseIds) {
+    for (const toolUseId of pendingToolUseIds) {
+      this.inlineSubagentState.delete(toolUseId);
+      this.subagentChildNames.delete(toolUseId);
+    }
+  }
+  processTranscriptLine(line, agentName = ORCHESTRATOR_NAME, ctxPending, ctxSeen, sessionId, ctxSeenMessages) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line.trim());
+    } catch (err) {
+      log2.debug("Skipping unparseable line:", err);
+      return;
+    }
+    if (parsed.type === "progress") {
+      this.handleProgressEvent(parsed, sessionId);
+      return;
+    }
+    if (parsed.type !== "user" && parsed.type !== "assistant") {
+      return;
+    }
+    const msg = parsed.message;
+    if (!msg) {
+      return;
+    }
+    const entry = {
+      sessionId: parsed.sessionId,
+      type: parsed.type,
+      uuid: parsed.uuid,
+      message: msg
+    };
+    if (sessionId) {
+      this.maybeSetSessionLabel(entry, sessionId);
+    }
+    const role = msg.role;
+    const session = sessionId ? this.delegate.getSession(sessionId) : void 0;
+    if (session && !session.model && entry.type === "assistant" && msg.model) {
+      session.model = msg.model;
+      this.delegate.emit({
+        time: this.delegate.elapsed(sessionId),
+        type: "model_detected",
+        payload: { agent: agentName, model: msg.model }
+      }, sessionId);
+    }
+    const seenMsgs = ctxSeenMessages ?? session?.seenMessageHashes;
+    if (typeof msg.content === "string" && msg.content.trim()) {
+      if (role === "user" || role === "human") {
+        const text = msg.content.trim();
+        if (!this.isSystemInjectedContent(text)) {
+          const hash = entry.uuid ? `user:${entry.uuid}` : `user:${text.slice(0, HASH_PREFIX_MAX)}`;
+          if (seenMsgs && seenMsgs.has(hash)) {
+          } else {
+            seenMsgs?.add(hash);
+            if (session) {
+              session.contextBreakdown.userMessages += estimateTokensFromText(text);
+            }
+            this.delegate.emit({
+              time: this.delegate.elapsed(sessionId),
+              type: "message",
+              payload: { agent: agentName, role: "user", content: text.slice(0, MESSAGE_MAX) }
+            }, sessionId);
+          }
+        }
+      }
+      if (session) {
+        this.delegate.emitContextUpdate(agentName, session, sessionId);
+      }
+      return;
+    }
+    if (!Array.isArray(msg.content)) {
+      return;
+    }
+    const emitRole = role === "user" || role === "human" ? "user" : "assistant";
+    for (const block of msg.content) {
+      if (block.type === "tool_use") {
+        const toolBlock = block;
+        if (ctxSeen.has(toolBlock.id)) {
+          continue;
+        }
+        ctxSeen.add(toolBlock.id);
+        this.handleToolUse(toolBlock, agentName, ctxPending, sessionId);
+      } else if (block.type === "tool_result") {
+        this.handleToolResult(block, agentName, ctxPending, sessionId);
+      } else if (block.type === "text" && "text" in block) {
+        this.handleTextBlock(block, emitRole, entry.uuid, agentName, seenMsgs, session, sessionId);
+      } else if (block.type === "thinking" && "thinking" in block) {
+        this.handleThinkingBlock(block, entry.uuid, agentName, seenMsgs, session, sessionId);
+      }
+    }
+    if (session) {
+      this.delegate.emitContextUpdate(agentName, session, sessionId);
+    }
+  }
+  /** Process a text block — dedup, track tokens, emit message event */
+  handleTextBlock(block, emitRole, entryUuid, agentName, seenMsgs, session, sessionId) {
+    const text = safeText(block);
+    if (!text)
+      return;
+    if (emitRole === "user" && this.isSystemInjectedContent(text))
+      return;
+    const hash = entryUuid ? `${emitRole}:${entryUuid}` : `${emitRole}:${text.slice(0, HASH_PREFIX_MAX)}`;
+    if (seenMsgs?.has(hash))
+      return;
+    seenMsgs?.add(hash);
+    if (session) {
+      if (emitRole === "user") {
+        session.contextBreakdown.userMessages += estimateTokensFromText(text);
+      } else {
+        session.contextBreakdown.reasoning += estimateTokensFromText(text);
+      }
+    }
+    this.delegate.emit({
+      time: this.delegate.elapsed(sessionId),
+      type: "message",
+      payload: { agent: agentName, role: emitRole, content: text.slice(0, MESSAGE_MAX) }
+    }, sessionId);
+  }
+  /** Process a thinking block — dedup, track tokens, emit message event */
+  handleThinkingBlock(block, entryUuid, agentName, seenMsgs, session, sessionId) {
+    const thinking = safeThinking(block);
+    if (!thinking)
+      return;
+    const hash = entryUuid ? `thinking:${entryUuid}` : `thinking:${thinking.slice(0, HASH_PREFIX_MAX)}`;
+    if (seenMsgs?.has(hash))
+      return;
+    seenMsgs?.add(hash);
+    if (session) {
+      session.contextBreakdown.reasoning += estimateTokensFromText(thinking);
+    }
+    this.delegate.emit({
+      time: this.delegate.elapsed(sessionId),
+      type: "message",
+      payload: { agent: agentName, role: "thinking", content: thinking.slice(0, MESSAGE_MAX) }
+    }, sessionId);
+  }
+  handleToolUse(block, agentName, ctxPending, sessionId) {
+    const toolName = block.name;
+    const args2 = summarizeInput(toolName, block.input);
+    const rawPath = block.input.file_path || block.input.path;
+    const filePath = typeof rawPath === "string" ? rawPath : void 0;
+    ctxPending.set(block.id, {
+      name: toolName,
+      args: args2,
+      filePath,
+      startTime: Date.now()
+    });
+    if (toolName === "Task" || toolName === "Agent") {
+      const childName = resolveSubagentChildName(block.input);
+      this.subagentChildNames.set(block.id, childName);
+      const session = sessionId ? this.delegate.getSession(sessionId) : void 0;
+      if (!session?.spawnedSubagents.has(childName)) {
+        session?.spawnedSubagents.add(childName);
+        emitSubagentSpawn(this.delegate, agentName, childName, args2, sessionId);
+      }
+    }
+    this.delegate.emit({
+      time: this.delegate.elapsed(sessionId),
+      type: "tool_call_start",
+      payload: {
+        agent: agentName,
+        tool: toolName,
+        args: args2,
+        preview: `${toolName}: ${args2}`.slice(0, PREVIEW_MAX),
+        inputData: extractInputData(toolName, block.input)
+      }
+    }, sessionId);
+  }
+  handleToolResult(block, agentName, ctxPending, sessionId) {
+    const pending = ctxPending.get(block.tool_use_id);
+    if (!pending) {
+      return;
+    }
+    const toolName = pending.name;
+    const result = summarizeResult(block.content);
+    const tokenCost = estimateTokensFromContent(block.content);
+    if (sessionId) {
+      const session = this.delegate.getSession(sessionId);
+      if (session) {
+        if (toolName === "Task" || toolName === "Agent") {
+          session.contextBreakdown.subagentResults += tokenCost;
+        } else {
+          session.contextBreakdown.toolResults += tokenCost;
+        }
+      }
+    }
+    ctxPending.delete(block.tool_use_id);
+    const discovery = buildDiscovery(toolName, pending?.filePath || "", result);
+    if (toolName === "Task" || toolName === "Agent") {
+      const childName = this.subagentChildNames.get(block.tool_use_id) || pending?.args?.slice(0, CHILD_NAME_MAX) || "subagent";
+      this.subagentChildNames.delete(block.tool_use_id);
+      this.inlineSubagentState.delete(block.tool_use_id);
+      this.delegate.emit({
+        time: this.delegate.elapsed(sessionId),
+        type: "subagent_return",
+        payload: { child: childName, parent: agentName, summary: result.slice(0, ARGS_MAX) }
+      }, sessionId);
+      this.delegate.emit({
+        time: this.delegate.elapsed(sessionId),
+        type: "agent_complete",
+        payload: { name: childName }
+      }, sessionId);
+    }
+    const isError = detectError(result);
+    const errorMessage = isError ? result.slice(0, FAILED_RESULT_MAX) : void 0;
+    this.delegate.emit({
+      time: this.delegate.elapsed(sessionId),
+      type: "tool_call_end",
+      payload: {
+        agent: agentName,
+        tool: toolName,
+        result: result.slice(0, RESULT_MAX),
+        tokenCost,
+        ...discovery ? { discovery } : {},
+        ...isError ? { isError, errorMessage } : {}
+      }
+    }, sessionId);
+    if (sessionId) {
+      const session = this.delegate.getSession(sessionId);
+      if (session) {
+        this.delegate.emitContextUpdate(agentName, session, sessionId);
+      }
+    }
+  }
+  /**
+   * Handle inline progress events from newer Claude Code versions.
+   * These carry subagent transcript entries directly in the main JSONL,
+   * keyed by parentToolUseID (the Agent tool_use that spawned the subagent).
+   */
+  handleProgressEvent(parsed, sessionId) {
+    const data = parsed.data;
+    if (!isRecord(data) || data.type !== "agent_progress") {
+      return;
+    }
+    const innerEntry = data.message;
+    if (!innerEntry?.message) {
+      return;
+    }
+    const parentToolUseID = typeof parsed.parentToolUseID === "string" ? parsed.parentToolUseID : void 0;
+    if (!parentToolUseID) {
+      return;
+    }
+    let subState = this.inlineSubagentState.get(parentToolUseID);
+    if (!subState) {
+      const childName = this.subagentChildNames.get(parentToolUseID) || generateSubagentFallbackName("", this.inlineSubagentState.size + 1);
+      subState = {
+        agentName: childName,
+        pending: /* @__PURE__ */ new Map(),
+        seen: /* @__PURE__ */ new Set(),
+        seenMessages: /* @__PURE__ */ new Set()
+      };
+      this.inlineSubagentState.set(parentToolUseID, subState);
+      if (sessionId) {
+        const session = this.delegate.getSession(sessionId);
+        session?.inlineProgressAgents.add(childName);
+      }
+    }
+    const innerLine = JSON.stringify(innerEntry);
+    this.processTranscriptLine(innerLine, subState.agentName, subState.pending, subState.seen, sessionId, subState.seenMessages);
+  }
+  /**
+   * Pre-scan existing file content:
+   * 1. Build seenToolUseIds dedup set (prevents re-emitting old tool calls)
+   * 2. Return all entries for catch-up emission
+   */
+  prescanExistingContent(filePath, size, session) {
+    if (size === 0) {
+      return [];
+    }
+    const catchUpEntries = [];
+    try {
+      const content = readFileChunk(filePath, 0, size);
+      for (const line of content.split(/\r?\n/)) {
+        if (!line.trim()) {
+          continue;
+        }
+        try {
+          const entry = JSON.parse(line.trim());
+          const isUser = entry.message?.role === "user" || entry.message?.role === "human";
+          if (entry.message && Array.isArray(entry.message.content)) {
+            for (const block of entry.message.content) {
+              if (block.type === "tool_use" && block.id) {
+                const toolBlock = block;
+                session.seenToolUseIds.add(toolBlock.id);
+                if (toolBlock.name === "Agent" || toolBlock.name === "Task") {
+                  const childName = resolveSubagentChildName(toolBlock.input);
+                  session.spawnedSubagents.add(childName);
+                  this.subagentChildNames.set(toolBlock.id, childName);
+                }
+                const args2 = summarizeInput(toolBlock.name, toolBlock.input);
+                const rawPath = toolBlock.input.file_path || toolBlock.input.path;
+                const filePath2 = typeof rawPath === "string" ? rawPath : void 0;
+                session.pendingToolCalls.set(toolBlock.id, { name: toolBlock.name, args: args2, filePath: filePath2, startTime: Date.now() });
+              } else if (block.type === "tool_result") {
+                const resultBlock = block;
+                if (resultBlock.tool_use_id) {
+                  session.pendingToolCalls.delete(resultBlock.tool_use_id);
+                }
+                session.contextBreakdown.toolResults += estimateTokensFromContent(resultBlock.content);
+              } else if (block.type === "text" && "text" in block) {
+                const text = safeText(block);
+                if (text) {
+                  const emitRole = isUser ? "user" : "assistant";
+                  const hashKey = entry.uuid ? `${emitRole}:${entry.uuid}` : `${emitRole}:${text.slice(0, HASH_PREFIX_MAX)}`;
+                  session.seenMessageHashes.add(hashKey);
+                  if (isUser) {
+                    session.contextBreakdown.userMessages += estimateTokensFromText(text);
+                  } else {
+                    session.contextBreakdown.reasoning += estimateTokensFromText(text);
+                  }
+                }
+              } else if (block.type === "thinking" && "thinking" in block) {
+                const thinking = safeThinking(block);
+                if (thinking) {
+                  const hashKey = entry.uuid ? `thinking:${entry.uuid}` : `thinking:${thinking.slice(0, HASH_PREFIX_MAX)}`;
+                  session.seenMessageHashes.add(hashKey);
+                  session.contextBreakdown.reasoning += estimateTokensFromText(thinking);
+                }
+              }
+            }
+          } else if (entry.type === "user" && typeof entry.message?.content === "string") {
+            const text = entry.message.content.trim();
+            if (text) {
+              const hashKey = entry.uuid ? `user:${entry.uuid}` : `user:${text.slice(0, HASH_PREFIX_MAX)}`;
+              session.seenMessageHashes.add(hashKey);
+              session.contextBreakdown.userMessages += estimateTokensFromText(text);
+            }
+          }
+          if (entry.type === "assistant" && entry.message?.model && !session.model) {
+            session.model = entry.message.model;
+          }
+          if (entry.type === "user" || entry.type === "assistant") {
+            catchUpEntries.push(entry);
+          }
+        } catch (err) {
+          log2.debug("Skipping unparseable transcript line:", err);
+        }
+      }
+      log2.info(`Pre-scanned ${session.seenToolUseIds.size} existing tool_use IDs, ${catchUpEntries.length} entries total`);
+      return catchUpEntries;
+    } catch (err) {
+      log2.error("Pre-scan failed:", err);
+      return [];
+    }
+  }
+  /** Emit message events for pre-existing transcript entries (catch-up on session detection).
+   *  Only emits the last user message (the current turn), not the full history. */
+  emitCatchUpEntries(entries, session, sessionId) {
+    let lastUserIndex = -1;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      if (entries[i].type === "user") {
+        lastUserIndex = i;
+        break;
+      }
+    }
+    if (lastUserIndex === -1) {
+      return;
+    }
+    const recentEntries = entries.slice(lastUserIndex);
+    for (const entry of recentEntries) {
+      const role = entry.type === "user" ? "user" : "assistant";
+      const msg = entry.message;
+      if (!msg) {
+        continue;
+      }
+      if (typeof msg.content === "string" && msg.content.trim()) {
+        const text = msg.content.trim();
+        if (this.isSystemInjectedContent(text)) {
+          continue;
+        }
+        this.delegate.emit({
+          time: 0,
+          type: "message",
+          payload: { agent: ORCHESTRATOR_NAME, role, content: text.slice(0, MESSAGE_MAX) }
+        }, sessionId);
+        continue;
+      }
+      if (!Array.isArray(msg.content)) {
+        continue;
+      }
+      for (const block of msg.content) {
+        if (block.type === "text" && "text" in block) {
+          const text = safeText(block);
+          if (text && !this.isSystemInjectedContent(text)) {
+            this.delegate.emit({
+              time: 0,
+              type: "message",
+              payload: { agent: ORCHESTRATOR_NAME, role, content: text.slice(0, MESSAGE_MAX) }
+            }, sessionId);
+          }
+        }
+      }
+    }
+  }
+  /** Extract a human-readable label from the first user message in transcript entries */
+  extractSessionLabel(entries, session) {
+    if (session.labelSet)
+      return;
+    for (const entry of entries) {
+      if (entry.type !== "user")
+        continue;
+      const text = this.extractUserMessageText(entry);
+      if (text) {
+        session.label = this.truncateLabel(text);
+        session.labelSet = true;
+        return;
+      }
+    }
+  }
+  /** Extract text content from a user transcript entry, skipping system-injected tags */
+  extractUserMessageText(entry) {
+    const msg = entry.message;
+    if (!msg)
+      return null;
+    if (typeof msg.content === "string" && msg.content.trim()) {
+      const text = msg.content.trim();
+      if (!this.isSystemInjectedContent(text))
+        return text;
+      return null;
+    }
+    if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "text" && "text" in block) {
+          const text = safeText(block);
+          if (text && !this.isSystemInjectedContent(text))
+            return text;
+        }
+      }
+    }
+    return null;
+  }
+  /** Check if text is system-injected context (not a real user/assistant message) */
+  isSystemInjectedContent(text) {
+    return SYSTEM_CONTENT_PREFIXES.some((prefix) => text.startsWith(prefix));
+  }
+  /** Truncate to first line, max chars — fits in a tab */
+  truncateLabel(text) {
+    const firstLine = text.split("\n")[0].trim();
+    if (firstLine.length <= SESSION_LABEL_MAX)
+      return firstLine;
+    return firstLine.slice(0, SESSION_LABEL_TRUNCATED) + "..";
+  }
+  /** Update session label on first user message and notify the webview */
+  maybeSetSessionLabel(entry, sessionId) {
+    const session = this.delegate.getSession(sessionId);
+    if (!session || session.labelSet)
+      return;
+    if (entry.type !== "user")
+      return;
+    const text = this.extractUserMessageText(entry);
+    if (!text)
+      return;
+    session.label = this.truncateLabel(text);
+    session.labelSet = true;
+    this.delegate.fireSessionLifecycle({ type: "updated", sessionId, label: session.label });
+  }
+};
+
+// extension/src/subagent-watcher.ts
+var fs2 = __toESM(require("fs"));
+var path = __toESM(require("path"));
+
+// extension/src/permission-detection.ts
+function handlePermissionDetection(delegate, agentName, pendingToolCalls, permState, sessionId, sessionCompleted, checkSessionActivity) {
+  if (permState.permissionTimer) {
+    clearTimeout(permState.permissionTimer);
+    permState.permissionTimer = null;
+  }
+  if (permState.permissionEmitted) {
+    permState.permissionEmitted = false;
+    delegate.emit({
+      time: delegate.elapsed(sessionId),
+      type: "agent_idle",
+      payload: { name: agentName }
+    }, sessionId);
+  }
+  const needsPermission = Array.from(pendingToolCalls.values()).some((tc) => tc.name !== "Agent" && tc.name !== "Task");
+  if (needsPermission) {
+    const snapshotTime = Date.now();
+    permState.permissionTimer = setTimeout(() => {
+      if (permState.permissionEmitted || sessionCompleted)
+        return;
+      const stillPending = Array.from(pendingToolCalls.values()).some((tc) => tc.name !== "Agent" && tc.name !== "Task" && tc.startTime <= snapshotTime);
+      if (!stillPending)
+        return;
+      if (checkSessionActivity) {
+        const lastActivity = delegate.getLastActivityTime(sessionId);
+        if (lastActivity !== void 0) {
+          const recentThreshold = Date.now() - PERMISSION_DETECT_MS;
+          if (lastActivity > recentThreshold)
+            return;
+        }
+      }
+      permState.permissionEmitted = true;
+      delegate.emit({
+        time: delegate.elapsed(sessionId),
+        type: "permission_requested",
+        payload: {
+          agent: agentName,
+          message: "Waiting for permission"
+        }
+      }, sessionId);
+    }, PERMISSION_DETECT_MS);
+  }
+}
+
+// extension/src/subagent-watcher.ts
+var log3 = createLogger("SubagentWatcher");
+function resolveNameFromMeta(jsonlPath, fallbackIndex) {
+  const metaPath = jsonlPath.replace(/\.jsonl$/, ".meta.json");
+  try {
+    const raw = fs2.readFileSync(metaPath, "utf-8");
+    const meta = JSON.parse(raw);
+    const name = resolveSubagentChildName(meta);
+    if (name && name !== "subagent")
+      return name;
+  } catch {
+  }
+  return generateSubagentFallbackName("", fallbackIndex);
+}
+function scanSubagentsDir(delegate, parser2, sessionId) {
+  const session = delegate.getSession(sessionId);
+  if (!session || !session.subagentsDir)
+    return;
+  if (!session.subagentsDirWatcher && fs2.existsSync(session.subagentsDir)) {
+    try {
+      session.subagentsDirWatcher = fs2.watch(session.subagentsDir, () => {
+        scanSubagentsDir(delegate, parser2, sessionId);
+      });
+    } catch (err) {
+      log3.debug("Subagent dir watch failed:", err);
+    }
+  }
+  const subDir = session.subagentsDir;
+  if (!fs2.existsSync(subDir))
+    return;
+  try {
+    const files = fs2.readdirSync(subDir);
+    for (const file of files) {
+      if (!file.endsWith(".jsonl"))
+        continue;
+      const filePath = path.join(subDir, file);
+      if (session.subagentWatchers.has(filePath))
+        continue;
+      startWatchingSubagentFile(delegate, parser2, filePath, sessionId);
+    }
+  } catch (err) {
+    log3.debug("Subagent dir scan failed:", err);
+  }
+}
+function startWatchingSubagentFile(delegate, parser2, filePath, sessionId) {
+  const session = delegate.getSession(sessionId);
+  if (!session)
+    return;
+  const agentName = resolveNameFromMeta(filePath, session.subagentWatchers.size + 1);
+  log3.info(`Tailing subagent: ${path.basename(filePath)} as "${agentName}" (session ${sessionId.slice(0, SESSION_ID_DISPLAY)})`);
+  const state = {
+    watcher: null,
+    fileSize: 0,
+    agentName,
+    pendingToolCalls: /* @__PURE__ */ new Map(),
+    seenToolUseIds: /* @__PURE__ */ new Set(),
+    permissionTimer: null,
+    permissionEmitted: false,
+    spawnEmitted: false
+  };
+  session.subagentWatchers.set(filePath, state);
+  const pendingToolUseIds = /* @__PURE__ */ new Set();
+  try {
+    const stat = fs2.statSync(filePath);
+    if (stat.size > 0) {
+      const content = fs2.readFileSync(filePath, "utf-8");
+      for (const line of content.split(/\r?\n/)) {
+        if (!line.trim())
+          continue;
+        try {
+          const raw = JSON.parse(line.trim());
+          const entry = raw;
+          if (raw && typeof raw === "object" && entry.message && Array.isArray(entry.message.content)) {
+            for (const block of entry.message.content) {
+              if (block.type === "tool_use" && block.id) {
+                state.seenToolUseIds.add(block.id);
+                pendingToolUseIds.add(block.id);
+              } else if (block.type === "tool_result" && block.tool_use_id) {
+                pendingToolUseIds.delete(block.tool_use_id);
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      state.fileSize = stat.size;
+    }
+  } catch (err) {
+    log3.debug("Subagent initial read failed:", err);
+  }
+  const alreadySpawned = session.spawnedSubagents.has(agentName);
+  state.spawnEmitted = pendingToolUseIds.size > 0 || alreadySpawned;
+  if (pendingToolUseIds.size > 0 && !alreadySpawned) {
+    session.spawnedSubagents.add(agentName);
+    emitSubagentSpawn(delegate, ORCHESTRATOR_NAME, agentName, agentName, sessionId);
+  }
+  try {
+    state.watcher = fs2.watch(filePath, () => {
+      readSubagentNewLines(delegate, parser2, filePath, sessionId);
+    });
+  } catch (err) {
+    log3.debug("Subagent file watch failed:", err);
+  }
+}
+function readSubagentNewLines(delegate, parser2, filePath, sessionId) {
+  const session = delegate.getSession(sessionId);
+  if (!session)
+    return;
+  const state = session.subagentWatchers.get(filePath);
+  if (!state)
+    return;
+  const result = readNewFileLines(filePath, state.fileSize);
+  if (!result)
+    return;
+  state.fileSize = result.newSize;
+  if (session.inlineProgressAgents.has(state.agentName)) {
+    delegate.resetInactivityTimer(sessionId);
+    return;
+  }
+  if (!state.spawnEmitted) {
+    state.spawnEmitted = true;
+    if (!session.spawnedSubagents.has(state.agentName)) {
+      session.spawnedSubagents.add(state.agentName);
+      emitSubagentSpawn(delegate, ORCHESTRATOR_NAME, state.agentName, state.agentName, sessionId);
+    }
+  }
+  for (const line of result.lines) {
+    parser2.processTranscriptLine(line, state.agentName, state.pendingToolCalls, state.seenToolUseIds, sessionId);
+  }
+  handlePermissionDetection(delegate, state.agentName, state.pendingToolCalls, state, sessionId);
+  delegate.resetInactivityTimer(sessionId);
+}
+
+// scripts/relay.ts
+var MAX_EVENT_BUFFER = 5e3;
+var DISCOVERY_DIR = path2.join(os.homedir(), ".claude", "agent-flow");
+var CLAUDE_DIR = path2.join(os.homedir(), ".claude", "projects");
+var relayCreated = false;
+var sseClients = /* @__PURE__ */ new Set();
+function sendSSE(res, data) {
+  try {
+    res.write(`data: ${JSON.stringify(data)}
+
+`);
+  } catch {
+    sseClients.delete(res);
+  }
+}
+function broadcast(data) {
+  for (const res of sseClients) {
+    try {
+      res.write(`data: ${data}
+
+`);
+    } catch {
+      sseClients.delete(res);
+    }
+  }
+}
+var eventBuffer = /* @__PURE__ */ new Map();
+function broadcastEvent(event) {
+  const sid = event.sessionId?.slice(0, SESSION_ID_DISPLAY) || "?";
+  console.log(`[event] ${event.type} (session ${sid})`);
+  if (event.sessionId) {
+    let buf = eventBuffer.get(event.sessionId) || [];
+    buf.push(event);
+    if (buf.length > MAX_EVENT_BUFFER) {
+      buf = buf.slice(buf.length - MAX_EVENT_BUFFER);
+    }
+    eventBuffer.set(event.sessionId, buf);
+  }
+  broadcast(JSON.stringify({ type: "agent-event", event }));
+}
+function broadcastSessionLifecycle(type, sessionId, label) {
+  if (type === "started") {
+    broadcast(JSON.stringify({
+      type: "session-started",
+      session: { id: sessionId, label, status: "active", startTime: Date.now(), lastActivityTime: Date.now() }
+    }));
+  } else if (type === "ended") {
+    broadcast(JSON.stringify({ type: "session-ended", sessionId }));
+  } else if (type === "updated") {
+    broadcast(JSON.stringify({ type: "session-updated", sessionId, label }));
+  }
+}
+var sessions = /* @__PURE__ */ new Map();
+function elapsed(sessionId) {
+  if (sessionId) {
+    const session = sessions.get(sessionId);
+    if (session)
+      return (Date.now() - session.sessionStartTime) / 1e3;
+  }
+  return 0;
+}
+function emitContextUpdate(agentName, session, sessionId) {
+  const bd = session.contextBreakdown;
+  const total = bd.systemPrompt + bd.userMessages + bd.toolResults + bd.reasoning + bd.subagentResults;
+  broadcastEvent({
+    time: elapsed(sessionId),
+    type: "context_update",
+    payload: { agent: agentName, tokens: total, breakdown: { ...bd } },
+    sessionId
+  });
+}
+function emitEvent(event, sessionId) {
+  broadcastEvent(sessionId ? { ...event, sessionId } : event);
+}
+var parser = new TranscriptParser({
+  emit: emitEvent,
+  elapsed,
+  getSession: (sessionId) => sessions.get(sessionId),
+  fireSessionLifecycle: (event) => broadcastSessionLifecycle(event.type, event.sessionId, event.label),
+  emitContextUpdate
+});
+var watcherDelegate = {
+  emit: emitEvent,
+  elapsed,
+  getSession: (sessionId) => sessions.get(sessionId),
+  getLastActivityTime: (sessionId) => sessions.get(sessionId)?.lastActivityTime,
+  resetInactivityTimer: (sessionId) => resetInactivityTimer(sessionId)
+};
+function resetInactivityTimer(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return;
+  const wasCompleted = session.sessionCompleted;
+  session.lastActivityTime = Date.now();
+  session.sessionCompleted = false;
+  if (wasCompleted) {
+    broadcastEvent({
+      time: elapsed(sessionId),
+      type: "agent_spawn",
+      payload: { name: ORCHESTRATOR_NAME, isMain: true, task: session.label, ...session.model ? { model: session.model } : {} },
+      sessionId
+    });
+    broadcastSessionLifecycle("started", sessionId, session.label);
+  }
+  if (session.inactivityTimer)
+    clearTimeout(session.inactivityTimer);
+  session.inactivityTimer = setTimeout(() => {
+    if (!session.sessionCompleted && session.sessionDetected) {
+      console.log(`[session] ${sessionId.slice(0, SESSION_ID_DISPLAY)} inactive`);
+      session.sessionCompleted = true;
+      broadcastEvent({
+        time: elapsed(sessionId),
+        type: "agent_complete",
+        payload: { name: ORCHESTRATOR_NAME },
+        sessionId
+      });
+      broadcastSessionLifecycle("ended", sessionId, session.label);
+    }
+  }, INACTIVITY_TIMEOUT_MS);
+}
+function watchSession(sessionId, filePath) {
+  const defaultLabel = `Session ${sessionId.slice(0, SESSION_ID_DISPLAY)}`;
+  const session = {
+    sessionId,
+    filePath,
+    fileWatcher: null,
+    pollTimer: null,
+    fileSize: 0,
+    sessionStartTime: Date.now(),
+    pendingToolCalls: /* @__PURE__ */ new Map(),
+    seenToolUseIds: /* @__PURE__ */ new Set(),
+    seenMessageHashes: /* @__PURE__ */ new Set(),
+    sessionDetected: false,
+    sessionCompleted: false,
+    lastActivityTime: Date.now(),
+    inactivityTimer: null,
+    subagentWatchers: /* @__PURE__ */ new Map(),
+    spawnedSubagents: /* @__PURE__ */ new Set(),
+    inlineProgressAgents: /* @__PURE__ */ new Set(),
+    subagentsDirWatcher: null,
+    subagentsDir: null,
+    label: defaultLabel,
+    labelSet: false,
+    model: null,
+    permissionTimer: null,
+    permissionEmitted: false,
+    contextBreakdown: { systemPrompt: SYSTEM_PROMPT_BASE_TOKENS, userMessages: 0, toolResults: 0, reasoning: 0, subagentResults: 0 }
+  };
+  sessions.set(sessionId, session);
+  const stat = fs3.statSync(filePath);
+  const catchUpEntries = parser.prescanExistingContent(filePath, stat.size, session);
+  session.fileSize = stat.size;
+  parser.extractSessionLabel(catchUpEntries, session);
+  broadcastSessionLifecycle("started", sessionId, session.label);
+  broadcastEvent({
+    time: 0,
+    type: "agent_spawn",
+    payload: { name: ORCHESTRATOR_NAME, isMain: true, task: session.label, ...session.model ? { model: session.model } : {} },
+    sessionId
+  });
+  session.sessionDetected = true;
+  emitContextUpdate(ORCHESTRATOR_NAME, session, sessionId);
+  parser.emitCatchUpEntries(catchUpEntries, session, sessionId);
+  session.fileWatcher = fs3.watch(filePath, (eventType) => {
+    if (eventType === "change")
+      readNewLines(sessionId);
+  });
+  session.pollTimer = setInterval(() => {
+    readNewLines(sessionId);
+    for (const [subPath] of session.subagentWatchers) {
+      readSubagentNewLines(watcherDelegate, parser, subPath, sessionId);
+    }
+    scanSubagentsDir(watcherDelegate, parser, sessionId);
+  }, POLL_FALLBACK_MS);
+  session.subagentsDir = path2.join(path2.dirname(filePath), sessionId, "subagents");
+  scanSubagentsDir(watcherDelegate, parser, sessionId);
+  resetInactivityTimer(sessionId);
+  console.log(`[session] Watching ${sessionId.slice(0, SESSION_ID_DISPLAY)} \u2014 "${session.label}"`);
+}
+function readNewLines(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session)
+    return;
+  const result = readNewFileLines(session.filePath, session.fileSize);
+  if (!result)
+    return;
+  session.fileSize = result.newSize;
+  for (const line of result.lines) {
+    parser.processTranscriptLine(line, ORCHESTRATOR_NAME, session.pendingToolCalls, session.seenToolUseIds, sessionId, session.seenMessageHashes);
+  }
+  handlePermissionDetection(watcherDelegate, ORCHESTRATOR_NAME, session.pendingToolCalls, session, sessionId, session.sessionCompleted, true);
+  scanSubagentsDir(watcherDelegate, parser, sessionId);
+  resetInactivityTimer(sessionId);
+}
+function scanForActiveSessions(workspace) {
+  if (!fs3.existsSync(CLAUDE_DIR))
+    return;
+  let resolved = workspace;
+  try {
+    resolved = fs3.realpathSync(resolved);
+  } catch {
+  }
+  const encoded = resolved.replace(/[/\\:]/g, "-");
+  const dirsToScan = [];
+  const projectDir = path2.join(CLAUDE_DIR, encoded);
+  if (fs3.existsSync(projectDir))
+    dirsToScan.push(projectDir);
+  try {
+    for (const dir of fs3.readdirSync(CLAUDE_DIR, { withFileTypes: true })) {
+      if (!dir.isDirectory())
+        continue;
+      const fullPath = path2.join(CLAUDE_DIR, dir.name);
+      if (fullPath === projectDir)
+        continue;
+      if (dir.name.startsWith(encoded + "-")) {
+        dirsToScan.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  for (const dirPath of dirsToScan) {
+    try {
+      for (const file of fs3.readdirSync(dirPath)) {
+        if (!file.endsWith(".jsonl"))
+          continue;
+        const filePath = path2.join(dirPath, file);
+        const stat = fs3.statSync(filePath);
+        const sessionId = path2.basename(file, ".jsonl");
+        let newestMtime = stat.mtimeMs;
+        const subagentsDir = path2.join(dirPath, sessionId, "subagents");
+        try {
+          if (fs3.existsSync(subagentsDir)) {
+            for (const subFile of fs3.readdirSync(subagentsDir)) {
+              if (!subFile.endsWith(".jsonl"))
+                continue;
+              const subStat = fs3.statSync(path2.join(subagentsDir, subFile));
+              if (subStat.mtimeMs > newestMtime)
+                newestMtime = subStat.mtimeMs;
+            }
+          }
+        } catch {
+        }
+        const ageSeconds = (Date.now() - newestMtime) / 1e3;
+        if (ageSeconds <= ACTIVE_SESSION_AGE_S && !sessions.has(sessionId)) {
+          watchSession(sessionId, filePath);
+        }
+      }
+    } catch {
+    }
+  }
+}
+function normalizePath(p) {
+  let resolved = path2.resolve(p);
+  try {
+    resolved = fs3.realpathSync(resolved);
+  } catch {
+  }
+  return resolved;
+}
+function hashWorkspace(workspace) {
+  return crypto.createHash("sha256").update(normalizePath(workspace)).digest("hex").slice(0, WORKSPACE_HASH_LENGTH);
+}
+var discoveryFilePath = null;
+function writeDiscoveryFile(port, workspace) {
+  if (!fs3.existsSync(DISCOVERY_DIR))
+    fs3.mkdirSync(DISCOVERY_DIR, { recursive: true });
+  const hash = hashWorkspace(workspace);
+  discoveryFilePath = path2.join(DISCOVERY_DIR, `${hash}-${process.pid}.json`);
+  fs3.writeFileSync(discoveryFilePath, JSON.stringify({ port, pid: process.pid, workspace: normalizePath(workspace) }, null, 2) + "\n");
+}
+function removeDiscoveryFile() {
+  if (discoveryFilePath) {
+    try {
+      fs3.unlinkSync(discoveryFilePath);
+    } catch {
+    }
+  }
+}
+async function createRelay(workspace) {
+  if (relayCreated) {
+    throw new Error("createRelay() can only be called once per process");
+  }
+  relayCreated = true;
+  const hookServer = new HookServer();
+  const hookPort = await hookServer.start();
+  if (hookPort === HOOK_SERVER_NOT_STARTED) {
+    throw new Error("Failed to start hook server (port in use)");
+  }
+  hookServer.onEvent((event) => {
+    broadcast(JSON.stringify({ type: "agent-event", event }));
+  });
+  writeDiscoveryFile(hookPort, workspace);
+  scanForActiveSessions(workspace);
+  const scanInterval = setInterval(() => scanForActiveSessions(workspace), SCAN_INTERVAL_MS);
+  const resolved = (() => {
+    try {
+      return fs3.realpathSync(workspace);
+    } catch {
+      return workspace;
+    }
+  })();
+  const encoded = resolved.replace(/[/\\:]/g, "-");
+  const projectDir = path2.join(CLAUDE_DIR, encoded);
+  let projectDirWatcher = null;
+  if (fs3.existsSync(projectDir)) {
+    try {
+      projectDirWatcher = fs3.watch(projectDir, (_eventType, filename) => {
+        if (filename?.endsWith(".jsonl"))
+          scanForActiveSessions(workspace);
+      });
+    } catch {
+    }
+  }
+  return {
+    handleSSE(req, res) {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      });
+      sseClients.add(res);
+      console.log(`[sse] Client connected (${sseClients.size} total)`);
+      req.on("close", () => {
+        sseClients.delete(res);
+        console.log(`[sse] Client disconnected (${sseClients.size} total)`);
+      });
+      const sessionList = [];
+      for (const session of sessions.values()) {
+        if (!session.sessionDetected)
+          continue;
+        sessionList.push({
+          id: session.sessionId,
+          label: session.label,
+          status: session.sessionCompleted ? "completed" : "active",
+          startTime: session.sessionStartTime,
+          lastActivityTime: session.lastActivityTime
+        });
+      }
+      if (sessionList.length > 0) {
+        sendSSE(res, { type: "session-list", sessions: sessionList });
+      }
+      const sorted = [...sessionList].sort((a, b) => {
+        const aActive = a.status === "active" ? 1 : 0;
+        const bActive = b.status === "active" ? 1 : 0;
+        if (aActive !== bActive)
+          return bActive - aActive;
+        return b.lastActivityTime - a.lastActivityTime;
+      });
+      if (sorted.length > 0) {
+        const buffered = eventBuffer.get(sorted[0].id);
+        if (buffered) {
+          sendSSE(res, { type: "agent-event-batch", events: buffered });
+        }
+      }
+    },
+    dispose() {
+      removeDiscoveryFile();
+      hookServer.dispose();
+      clearInterval(scanInterval);
+      projectDirWatcher?.close();
+      for (const session of sessions.values()) {
+        session.fileWatcher?.close();
+        if (session.pollTimer)
+          clearInterval(session.pollTimer);
+        if (session.inactivityTimer)
+          clearTimeout(session.inactivityTimer);
+      }
+    }
+  };
+}
+
+// app/src/static.ts
+var fs4 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var WEBVIEW_DIR = path3.join(__dirname, "webview");
+var HTML_SHELL = `<!DOCTYPE html>
+<html lang="en" class="dark">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Agent Flow</title>
+  <link rel="stylesheet" href="/index.css">
+  <style>html, body { height: 100%; margin: 0; padding: 0; }</style>
+</head>
+<body class="font-sans antialiased" style="background: #0a0a1a;">
+  <div id="root" style="height: 100%;"></div>
+  <script src="/index.js"></script>
+</body>
+</html>`;
+var MIME_TYPES = {
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".html": "text/html"
+};
+function serveStatic(req, res) {
+  const url = req.url || "/";
+  if (url === "/" || url === "/index.html") {
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(HTML_SHELL);
+    return;
+  }
+  const basename4 = path3.basename(url);
+  const ext = path3.extname(basename4);
+  const mime = MIME_TYPES[ext];
+  if (!mime) {
+    res.writeHead(404);
+    res.end("Not found");
+    return;
+  }
+  const filePath = path3.join(WEBVIEW_DIR, basename4);
+  if (!filePath.startsWith(WEBVIEW_DIR)) {
+    res.writeHead(403);
+    res.end("Forbidden");
+    return;
+  }
+  try {
+    const content = fs4.readFileSync(filePath);
+    res.writeHead(200, { "Content-Type": mime });
+    res.end(content);
+  } catch {
+    res.writeHead(404);
+    res.end("Not found");
+  }
+}
+
+// app/src/server.ts
+async function startServer(options) {
+  const { port, openBrowser, workspace } = options;
+  const relay = await createRelay(workspace);
+  const server = http2.createServer((req, res) => {
+    if (req.url === "/events") {
+      return relay.handleSSE(req, res);
+    }
+    if (req.method === "GET") {
+      return serveStatic(req, res);
+    }
+    res.writeHead(404);
+    res.end("Not found");
+  });
+  server.listen(port, "127.0.0.1", () => {
+    const url = `http://127.0.0.1:${port}`;
+    console.log(`Server running at ${url}`);
+    console.log("Waiting for agent events...\n");
+    if (openBrowser) {
+      openURL(url);
+    }
+  });
+  function cleanup() {
+    server.close();
+    relay.dispose();
+    process.exit(0);
+  }
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  process.on("exit", () => relay.dispose());
+}
+function openURL(url) {
+  if (process.platform === "win32") {
+    (0, import_child_process.exec)(`start "" "${url}"`);
+  } else {
+    const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+    (0, import_child_process.execFile)(cmd, [url], () => {
+    });
+  }
+}
+
+// app/src/app.ts
+var args = parseArgs(process.argv.slice(2));
+console.log("Agent Flow\n");
+(0, import_setup.ensureSetup)();
+startServer({
+  port: args.port,
+  openBrowser: args.open,
+  workspace: process.cwd()
+});