webmux 0.29.0 → 0.30.0

package/backend/dist/server.js

@@ -6933,7 +6933,7 @@ var require_public_api = __commonJS((exports) => {
 
 // backend/src/server.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { join as join8, resolve as resolve8 } from "path";
+import { join as join8, resolve as resolve9 } from "path";
 import { mkdirSync } from "fs";
 import { networkInterfaces } from "os";
 
@@ -11969,7 +11969,7 @@ async function sendPrompt(worktreeId, target, text, paneIndex = 0, preamble, sub
   if (load.exitCode !== 0) {
     return { ok: false, error: `load-buffer failed${load.stderr ? `: ${load.stderr}` : ""}` };
   }
-  const paste = await tmuxExec(["tmux", "paste-buffer", "-b", bufferName, "-t", paneTarget, "-d"]);
+  const paste = await tmuxExec(["tmux", "paste-buffer", "-rp", "-b", bufferName, "-t", paneTarget, "-d"]);
   if (paste.exitCode !== 0) {
     return { ok: false, error: `paste-buffer failed${paste.stderr ? `: ${paste.stderr}` : ""}` };
   }
@@ -13376,6 +13376,12 @@ function pruneArchivedWorktreeState(input) {
 }
 
 // backend/src/services/agent-chat-service.ts
+var CODEX_SUBMIT_DELAY_MS = 200;
+function resolveAgentTerminalSubmitDelayMs(input) {
+  if (!input.agentId || !input.agent || input.agent.kind !== "builtin")
+    return 0;
+  return input.agent.implementation.agent === "codex" ? CODEX_SUBMIT_DELAY_MS : 0;
+}
 function resolveAgentChatSupport(input) {
   if (!input.agentId) {
     return {
@@ -13411,7 +13417,7 @@ function resolveAgentChatSupport(input) {
       ok: true,
       data: {
         provider: input.agent.implementation.agent,
-        submitDelayMs: input.agent.implementation.agent === "codex" ? 200 : 0
+        submitDelayMs: resolveAgentTerminalSubmitDelayMs(input)
       }
     };
   }
@@ -13880,11 +13886,11 @@ async function createLinearIssue(input) {
 
 // backend/src/services/lifecycle-service.ts
 import { mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname4, resolve as resolve6 } from "path";
+import { dirname as dirname4, resolve as resolve7 } from "path";
 
 // backend/src/adapters/agent-runtime.ts
 import { chmod as chmod2, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
 
 // backend/src/adapters/fs.ts
 import { mkdir as mkdir2 } from "fs/promises";
@@ -14097,6 +14103,7 @@ async function writeWorktreePrs(gitDir, prs) {
 }
 
 // backend/src/adapters/agent-runtime.ts
+var GENERATED_CODEX_HOOKS_EXCLUDE = ".codex/hooks.json";
 function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -14115,6 +14122,7 @@ from pathlib import Path
 
 
 CONTROL_ENV_PATH = Path(__file__).resolve().with_name("control.env")
+CONTROL_REQUEST_TIMEOUT_SECONDS = 2
 
 
 def read_control_env():
@@ -14144,6 +14152,7 @@ def build_parser():
 
     status_changed = subparsers.add_parser("status-changed")
     status_changed.add_argument("--lifecycle", choices=["starting", "running", "idle", "stopped"], required=True)
+    status_changed.add_argument("--best-effort", action="store_true")
 
     pr_opened = subparsers.add_parser("pr-opened")
     pr_opened.add_argument("--url")
@@ -14153,6 +14162,11 @@ def build_parser():
 
     subparsers.add_parser("claude-user-prompt-submit")
     subparsers.add_parser("claude-post-tool-use")
+    subparsers.add_parser("codex-session-start")
+    subparsers.add_parser("codex-user-prompt-submit")
+    subparsers.add_parser("codex-permission-request")
+    subparsers.add_parser("codex-post-tool-use")
+    subparsers.add_parser("codex-stop")
 
     return parser
 
@@ -14195,6 +14209,41 @@ def read_hook_payload():
     return parsed if isinstance(parsed, dict) else {}
 
 
+def iter_string_values(value):
+    if isinstance(value, str):
+        yield value
+        return
+    if isinstance(value, dict):
+        for child in value.values():
+            yield from iter_string_values(child)
+        return
+    if isinstance(value, list):
+        for child in value:
+            yield from iter_string_values(child)
+
+
+def find_pr_url(value):
+    for text in iter_string_values(value):
+        match = re.search(r"https://github\\.com/[^\\s\\"]+/pull/\\d+", text)
+        if match:
+            return match.group(0)
+    return None
+
+
+def maybe_send_pr_opened(hook_payload, control_env):
+    tool_name = hook_payload.get("tool_name")
+    tool_input = hook_payload.get("tool_input")
+    if not isinstance(tool_input, dict) or tool_name != "Bash":
+        return True
+
+    command = tool_input.get("command")
+    if not isinstance(command, str) or "gh pr create" not in command:
+        return True
+
+    pr_args = argparse.Namespace(url=find_pr_url(hook_payload.get("tool_response")))
+    return send_payload(build_payload("pr-opened", pr_args, control_env), control_env)
+
+
 def send_payload(payload, control_env):
     request = urllib.request.Request(
         control_env["WEBMUX_CONTROL_URL"],
@@ -14207,7 +14256,7 @@ def send_payload(payload, control_env):
     )
 
     try:
-        with urllib.request.urlopen(request, timeout=10) as response:
+        with urllib.request.urlopen(request, timeout=CONTROL_REQUEST_TIMEOUT_SECONDS) as response:
             if response.status < 200 or response.status >= 300:
                 print(f"control endpoint returned HTTP {response.status}", file=sys.stderr)
                 return False
@@ -14241,34 +14290,40 @@ def main():
         print(f"missing control env keys: {', '.join(missing)}", file=sys.stderr)
         return 1
 
+    if parsed.command == "codex-session-start":
+        send_payload(build_payload("status-changed", argparse.Namespace(lifecycle="idle"), control_env), control_env)
+        return 0
+
+    if parsed.command == "codex-user-prompt-submit":
+        send_payload(build_payload("status-changed", argparse.Namespace(lifecycle="running"), control_env), control_env)
+        return 0
+
     if parsed.command == "claude-user-prompt-submit":
         if not send_payload(build_payload("status-changed", argparse.Namespace(lifecycle="running"), control_env), control_env):
             return 1
         return 0
 
-    if parsed.command == "claude-post-tool-use":
-        hook_payload = read_hook_payload()
-        tool_name = hook_payload.get("tool_name")
-        tool_input = hook_payload.get("tool_input")
-        if not isinstance(tool_input, dict) or tool_name != "Bash":
-            return 0
+    if parsed.command == "codex-permission-request":
+        send_payload(build_payload("status-changed", argparse.Namespace(lifecycle="idle"), control_env), control_env)
+        return 0
 
-        command = tool_input.get("command")
-        if not isinstance(command, str) or "gh pr create" not in command:
-            return 0
+    if parsed.command == "codex-post-tool-use":
+        hook_payload = read_hook_payload()
+        maybe_send_pr_opened(hook_payload, control_env)
+        return 0
 
-        pr_args = argparse.Namespace(url=None)
-        tool_response = hook_payload.get("tool_response")
-        if isinstance(tool_response, str):
-            match = re.search(r"https://github\\.com/[^\\s\\"]+/pull/\\d+", tool_response)
-            if match:
-                pr_args.url = match.group(0)
+    if parsed.command == "claude-post-tool-use":
+        hook_payload = read_hook_payload()
+        return 0 if maybe_send_pr_opened(hook_payload, control_env) else 1
 
-        return 0 if send_payload(build_payload("pr-opened", pr_args, control_env), control_env) else 1
+    if parsed.command == "codex-stop":
+        send_payload(build_payload("agent-stopped", parsed, control_env), control_env)
+        print(json.dumps({}))
+        return 0
 
     payload = build_payload(parsed.command, parsed, control_env)
     if not send_payload(payload, control_env):
-        return 1
+        return 0 if getattr(parsed, "best_effort", False) else 1
 
     return 0
 
@@ -14338,6 +14393,81 @@ function buildClaudeHookSettings(input) {
     }
   };
 }
+function buildCodexHookSettings(input) {
+  const statusCommand = `${shellQuote(input.agentCtlPath)} status-changed --lifecycle running --best-effort`;
+  return {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "startup|resume|clear",
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} codex-session-start`,
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      UserPromptSubmit: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} codex-user-prompt-submit`,
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      PermissionRequest: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} codex-permission-request`,
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      PreToolUse: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: statusCommand,
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      PostToolUse: [
+        {
+          matcher: "Bash",
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} codex-post-tool-use`,
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      Stop: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} codex-stop`,
+              timeout: 30
+            }
+          ]
+        }
+      ]
+    }
+  };
+}
 async function mergeClaudeSettings(settingsPath, hookSettings) {
   let existing = {};
   try {
@@ -14357,13 +14487,77 @@ async function mergeClaudeSettings(settingsPath, hookSettings) {
   await Bun.write(settingsPath, JSON.stringify(merged, null, 2) + `
 `);
 }
+function commandStartsWithAgentCtl(command, agentCtlPath) {
+  const trimmedCommand = command.trimStart();
+  const quotedAgentCtlPath = shellQuote(agentCtlPath);
+  return trimmedCommand === agentCtlPath || trimmedCommand.startsWith(`${agentCtlPath} `) || trimmedCommand === quotedAgentCtlPath || trimmedCommand.startsWith(`${quotedAgentCtlPath} `);
+}
+function isWebmuxHookGroup(group, agentCtlPath) {
+  if (!isRecord5(group) || !Array.isArray(group.hooks))
+    return false;
+  return group.hooks.some((hook) => isRecord5(hook) && typeof hook.command === "string" && commandStartsWithAgentCtl(hook.command, agentCtlPath));
+}
+async function mergeCodexHooksFile(hooksPath, hookSettings, agentCtlPath) {
+  let existing = {};
+  try {
+    const file = Bun.file(hooksPath);
+    if (await file.exists()) {
+      const parsed = await file.json();
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        existing = parsed;
+      }
+    }
+  } catch {
+    existing = {};
+  }
+  const existingHooks = isRecord5(existing.hooks) ? existing.hooks : {};
+  const mergedHooks = { ...existingHooks };
+  for (const [eventName, groups] of Object.entries(hookSettings)) {
+    const eventGroups = existingHooks[eventName];
+    const preservedGroups = Array.isArray(eventGroups) ? eventGroups.filter((group) => !isWebmuxHookGroup(group, agentCtlPath)) : [];
+    mergedHooks[eventName] = [...preservedGroups, ...groups];
+  }
+  await Bun.write(hooksPath, JSON.stringify({ ...existing, hooks: mergedHooks }, null, 2) + `
+`);
+}
+async function resolveGitCommonDir(gitDir) {
+  try {
+    const commonDir = (await Bun.file(join4(gitDir, "commondir")).text()).trim();
+    if (!commonDir)
+      return gitDir;
+    return commonDir.startsWith("/") ? commonDir : resolve3(gitDir, commonDir);
+  } catch {
+    return gitDir;
+  }
+}
+async function ensureGeneratedCodexHooksIgnored(gitDir) {
+  const commonDir = await resolveGitCommonDir(gitDir);
+  const excludePath = join4(commonDir, "info", "exclude");
+  let existing = "";
+  try {
+    existing = await Bun.file(excludePath).text();
+  } catch {
+    existing = "";
+  }
+  const lines = existing.split(/\r?\n/).map((line) => line.trim());
+  if (lines.includes(GENERATED_CODEX_HOOKS_EXCLUDE))
+    return;
+  await mkdir3(dirname3(excludePath), { recursive: true });
+  const separator = existing.length > 0 && !existing.endsWith(`
+`) ? `
+` : "";
+  await Bun.write(excludePath, `${existing}${separator}${GENERATED_CODEX_HOOKS_EXCLUDE}
+`);
+}
 async function ensureAgentRuntimeArtifacts(input) {
   const storagePaths = getWorktreeStoragePaths(input.gitDir);
   const artifacts = {
     agentCtlPath: join4(storagePaths.webmuxDir, "webmux-agentctl"),
-    claudeSettingsPath: join4(input.worktreePath, ".claude", "settings.local.json")
+    claudeSettingsPath: join4(input.worktreePath, ".claude", "settings.local.json"),
+    codexHooksPath: join4(input.worktreePath, ".codex", "hooks.json")
   };
   await mkdir3(dirname3(artifacts.claudeSettingsPath), { recursive: true });
+  await mkdir3(dirname3(artifacts.codexHooksPath), { recursive: true });
   await Bun.write(artifacts.agentCtlPath, buildAgentCtlScript());
   await chmod2(artifacts.agentCtlPath, 493);
   const hookSettings = buildClaudeHookSettings(artifacts);
@@ -14372,12 +14566,14 @@ async function ensureAgentRuntimeArtifacts(input) {
     throw new Error("Invalid Claude hook settings");
   }
   await mergeClaudeSettings(artifacts.claudeSettingsPath, hooks);
+  await ensureGeneratedCodexHooksIgnored(input.gitDir);
+  await mergeCodexHooksFile(artifacts.codexHooksPath, buildCodexHookSettings(artifacts).hooks, artifacts.agentCtlPath);
   return artifacts;
 }
 
 // backend/src/adapters/tmux.ts
 import { createHash } from "crypto";
-import { basename as basename2, resolve as resolve3 } from "path";
+import { basename as basename2, resolve as resolve4 } from "path";
 function runTmux(args) {
   const result = Bun.spawnSync(["tmux", ...args], {
     stdout: "pipe",
@@ -14405,7 +14601,7 @@ function sanitizeTmuxNameSegment(value, maxLength = 24) {
   return trimmed || "x";
 }
 function buildProjectSessionName(projectRoot2) {
-  const resolved = resolve3(projectRoot2);
+  const resolved = resolve4(projectRoot2);
   const base = sanitizeTmuxNameSegment(basename2(resolved), 18);
   const hash = createHash("sha1").update(resolved).digest("hex").slice(0, 8);
   return `wm-${base}-${hash}`;
@@ -14546,15 +14742,16 @@ function buildDockerRuntimeBootstrap(runtimeEnvPath) {
 }
 function buildBuiltInAgentInvocation(input) {
   if (input.agent === "codex") {
+    const hooksFlag = " --enable codex_hooks";
     const yoloFlag2 = input.yolo ? " --yolo" : "";
     if (input.launchMode === "resume") {
-      return `codex${yoloFlag2} resume --last`;
+      return `codex${hooksFlag}${yoloFlag2} resume --last`;
     }
     const promptSuffix2 = input.prompt ? ` -- ${quoteShell(input.prompt)}` : "";
     if (input.systemPrompt) {
-      return `codex${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix2}`;
+      return `codex${hooksFlag}${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix2}`;
     }
-    return `codex${yoloFlag2}${promptSuffix2}`;
+    return `codex${hooksFlag}${yoloFlag2}${promptSuffix2}`;
   }
   const yoloFlag = input.yolo ? " --dangerously-skip-permissions" : "";
   if (input.launchMode === "resume") {
@@ -14627,7 +14824,7 @@ function buildDockerAgentPaneCommand(input) {
 }
 
 // backend/src/services/session-service.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 function quoteShell2(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -14641,7 +14838,7 @@ function buildCommandPaneStartupCommand(template, ctx) {
   if (!template.workingDir) {
     return template.command;
   }
-  const workingDir = resolve4(resolvePaneCwd(template, ctx), template.workingDir);
+  const workingDir = resolve5(resolvePaneCwd(template, ctx), template.workingDir);
   return `cd -- ${quoteShell2(workingDir)} && ${template.command}`;
 }
 function resolvePaneStartupCommand(template, ctx) {
@@ -14721,7 +14918,7 @@ import { randomUUID } from "crypto";
 
 // backend/src/adapters/git.ts
 import { readdirSync, rmSync, statSync } from "fs";
-import { resolve as resolve5, join as join5 } from "path";
+import { resolve as resolve6, join as join5 } from "path";
 function runGit(args, cwd) {
   const result = Bun.spawnSync(["git", ...args], {
     cwd,
@@ -14755,8 +14952,8 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function isRegisteredWorktree(entries, worktreePath) {
-  const resolvedPath = resolve5(worktreePath);
-  return entries.some((entry) => resolve5(entry.path) === resolvedPath);
+  const resolvedPath = resolve6(worktreePath);
+  return entries.some((entry) => resolve6(entry.path) === resolvedPath);
 }
 function removeDirectory(path) {
   rmSync(path, {
@@ -14780,7 +14977,7 @@ function currentCheckoutRef(cwd) {
 function resolveRepoRoot(dir) {
   const direct = tryRunGit(["rev-parse", "--show-toplevel"], dir);
   if (direct.ok)
-    return resolve5(dir, direct.stdout);
+    return resolve6(dir, direct.stdout);
   let entries;
   try {
     entries = readdirSync(dir);
@@ -14797,17 +14994,17 @@ function resolveRepoRoot(dir) {
     }
     const childResult = tryRunGit(["rev-parse", "--show-toplevel"], child);
     if (childResult.ok)
-      return resolve5(child, childResult.stdout);
+      return resolve6(child, childResult.stdout);
   }
   return null;
 }
 function resolveWorktreeRoot(cwd) {
   const output = runGit(["rev-parse", "--show-toplevel"], cwd);
-  return resolve5(cwd, output);
+  return resolve6(cwd, output);
 }
 function resolveWorktreeGitDir(cwd) {
   const output = runGit(["rev-parse", "--git-dir"], cwd);
-  return resolve5(cwd, output);
+  return resolve6(cwd, output);
 }
 function parseGitWorktreePorcelain(output) {
   const entries = [];
@@ -15445,20 +15642,20 @@ class LifecycleService {
     return allocateServicePorts(metas, this.deps.config.services);
   }
   resolveWorktreePath(branch) {
-    return resolve6(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
+    return resolve7(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
   }
   listLocalBranches() {
-    return this.deps.git.listLocalBranches(resolve6(this.deps.projectRoot));
+    return this.deps.git.listLocalBranches(resolve7(this.deps.projectRoot));
   }
   listRemoteBranches() {
-    return this.deps.git.listRemoteBranches(resolve6(this.deps.projectRoot));
+    return this.deps.git.listRemoteBranches(resolve7(this.deps.projectRoot));
   }
   listCheckedOutBranches() {
-    return new Set(this.deps.git.listWorktrees(resolve6(this.deps.projectRoot)).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch));
+    return new Set(this.deps.git.listWorktrees(resolve7(this.deps.projectRoot)).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch));
   }
   listProjectWorktrees() {
-    const projectRoot2 = resolve6(this.deps.projectRoot);
-    return this.deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && resolve6(entry.path) !== projectRoot2);
+    const projectRoot2 = resolve7(this.deps.projectRoot);
+    return this.deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && resolve7(entry.path) !== projectRoot2);
   }
   async readManagedMetas() {
     const metas = await Promise.all(this.listProjectWorktrees().map(async (entry) => {
@@ -17317,7 +17514,7 @@ class BunPortProbe {
     this.hostnames = hostnames;
   }
   isListening(port) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       let settled = false;
       let pending = this.hostnames.length;
       const settle = (result) => {
@@ -17326,20 +17523,20 @@ class BunPortProbe {
         if (result) {
           settled = true;
           clearTimeout(timer);
-          resolve7(true);
+          resolve8(true);
           return;
         }
         pending--;
         if (pending === 0) {
           settled = true;
           clearTimeout(timer);
-          resolve7(false);
+          resolve8(false);
         }
       };
       const timer = setTimeout(() => {
         if (!settled) {
           settled = true;
-          resolve7(false);
+          resolve8(false);
         }
       }, this.timeoutMs);
       for (const hostname of this.hostnames) {
@@ -17417,7 +17614,7 @@ async function defaultSpawn(args, options = {}) {
   if (options.timeoutMs === undefined) {
     return await resultPromise;
   }
-  return await new Promise((resolve7, reject) => {
+  return await new Promise((resolve8, reject) => {
     let settled = false;
     const timeoutId = setTimeout(() => {
       if (settled)
@@ -17433,7 +17630,7 @@ async function defaultSpawn(args, options = {}) {
         return;
       settled = true;
       clearTimeout(timeoutId);
-      resolve7(result);
+      resolve8(result);
     }, (error) => {
       if (settled)
         return;
@@ -17571,8 +17768,8 @@ class ArchiveStateService {
   async withMutationLock(operation) {
     const previous = this.mutationQueue;
     let release = () => {};
-    this.mutationQueue = new Promise((resolve7) => {
-      release = resolve7;
+    this.mutationQueue = new Promise((resolve8) => {
+      release = resolve8;
     });
     await previous.catch(() => {});
     try {
@@ -17847,9 +18044,9 @@ class ProjectRuntime {
 }
 
 // backend/src/services/reconciliation-service.ts
-import { basename as basename3, resolve as resolve7 } from "path";
+import { basename as basename3, resolve as resolve8 } from "path";
 function makeUnmanagedWorktreeId(path) {
-  return `unmanaged:${resolve7(path)}`;
+  return `unmanaged:${resolve8(path)}`;
 }
 function isValidPort2(port) {
   return port !== null && Number.isInteger(port) && port >= 1 && port <= 65535;
@@ -17906,7 +18103,7 @@ class ReconciliationService {
     if (!options.force && this.now() - this.lastReconciledAt < this.freshnessMs) {
       return;
     }
-    const normalizedRepoRoot = resolve7(repoRoot);
+    const normalizedRepoRoot = resolve8(repoRoot);
     const reconcilePromise = this.runReconcile(normalizedRepoRoot).then(() => {
       this.lastReconciledAt = this.now();
     });
@@ -17925,7 +18122,7 @@ class ReconciliationService {
       windows = [];
     }
     const seenWorktreeIds = new Set;
-    const candidateEntries = worktrees.filter((entry) => !entry.bare && resolve7(entry.path) !== normalizedRepoRoot);
+    const candidateEntries = worktrees.filter((entry) => !entry.bare && resolve8(entry.path) !== normalizedRepoRoot);
     const reconciledStates = await mapWithConcurrency(candidateEntries, this.concurrency, async (entry) => {
       const gitDir = this.deps.git.resolveWorktreeGitDir(entry.path);
       const meta = await readWorktreeMeta(gitDir);
@@ -18166,7 +18363,7 @@ function getFrontendConfig() {
     startupEnvs: config.startupEnvs,
     linkedRepos: config.integrations.github.linkedRepos.map((lr) => ({
       alias: lr.alias,
-      ...lr.dir ? { dir: resolve8(PROJECT_DIR, lr.dir) } : {}
+      ...lr.dir ? { dir: resolve9(PROJECT_DIR, lr.dir) } : {}
     })),
     linearAutoCreateWorktrees: linearAutoCreateEnabled,
     autoRemoveOnMerge: autoRemoveOnMergeEnabled,
@@ -18270,7 +18467,8 @@ async function resolveTerminalWorktree(branch) {
     attachTarget: {
       ownerSessionName: state.session.sessionName,
       windowName: state.session.windowName
-    }
+    },
+    agentName: state.agentName
   };
 }
 async function resolveAgentsTerminalWorktree(branch) {
@@ -18318,9 +18516,9 @@ async function hasValidControlToken(req) {
 }
 async function getWorktreeGitDirs() {
   const gitDirs = new Map;
-  const projectRoot2 = resolve8(PROJECT_DIR);
+  const projectRoot2 = resolve9(PROJECT_DIR);
   for (const entry of git.listWorktrees(projectRoot2)) {
-    if (entry.bare || resolve8(entry.path) === projectRoot2 || !entry.branch)
+    if (entry.bare || resolve9(entry.path) === projectRoot2 || !entry.branch)
       continue;
     gitDirs.set(entry.branch, git.resolveWorktreeGitDir(entry.path));
   }
@@ -18403,6 +18601,12 @@ function resolveWorktreeAgentChatSupport(worktree, action) {
     action
   });
 }
+function resolveWorktreeTerminalSubmitDelayMs(agentName) {
+  return resolveAgentTerminalSubmitDelayMs({
+    agentId: agentName,
+    agent: agentName ? getAgentDefinition(config, agentName) : null
+  });
+}
 async function apiAttachAgentsWorktree(branch) {
   touchDashboardActivity();
   const resolved = await resolveAgentsWorktree(branch);
@@ -18734,7 +18938,8 @@ async function apiSendPrompt(name, req) {
   const preamble = body.preamble;
   log.info(`[worktree:send] name=${name} text="${text.slice(0, 80)}"`);
   const terminalWorktree = await resolveTerminalWorktree(name);
-  const result = await sendPrompt(terminalWorktree.worktreeId, terminalWorktree.attachTarget, text, 0, preamble);
+  const submitDelayMs = resolveWorktreeTerminalSubmitDelayMs(terminalWorktree.agentName);
+  const result = await sendPrompt(terminalWorktree.worktreeId, terminalWorktree.attachTarget, text, 0, preamble, submitDelayMs);
   if (!result.ok)
     return errorResponse(result.error, 503);
   return jsonResponse({ ok: true });
@@ -18854,7 +19059,7 @@ async function apiPullMain(req) {
       return errorResponse(`Unknown linked repo: ${repo}`, 404);
     if (!linkedRepo.dir)
       return errorResponse(`Linked repo "${repo}" has no dir configured`, 400);
-    const resolvedDir = resolve8(PROJECT_DIR, linkedRepo.dir);
+    const resolvedDir = resolve9(PROJECT_DIR, linkedRepo.dir);
     const repoRoot = git.resolveRepoRoot(resolvedDir);
     if (!repoRoot)
       return errorResponse(`Linked repo "${repo}" dir is not a git repository: ${resolvedDir}`, 400);
@@ -18945,7 +19150,7 @@ async function apiUploadFiles(name, req) {
     }
     const safeName = `${Date.now()}_${sanitizeFilename(entry.name)}`;
     const destPath = join8(uploadDir, safeName);
-    if (!resolve8(destPath).startsWith(uploadDir + "/")) {
+    if (!resolve9(destPath).startsWith(uploadDir + "/")) {
       return errorResponse("Invalid filename", 400);
     }
     await Bun.write(destPath, entry);
@@ -19214,8 +19419,8 @@ Bun.serve({
     if (STATIC_DIR) {
       const rawPath = url.pathname === "/" ? "index.html" : url.pathname;
       const filePath = join8(STATIC_DIR, rawPath);
-      const staticRoot = resolve8(STATIC_DIR);
-      if (!resolve8(filePath).startsWith(staticRoot + "/")) {
+      const staticRoot = resolve9(STATIC_DIR);
+      if (!resolve9(filePath).startsWith(staticRoot + "/")) {
         return new Response("Forbidden", { status: 403 });
       }
       const file = Bun.file(filePath);