tmux-ide 2.7.0 → 2.8.0

package/packages/daemon/src/lib/app-config.ts

@@ -96,10 +96,30 @@ export interface AppUpdater {
   snapshotEvery: number;
 }
 
+/** The sound channel's states: ping sound on blocked only, on every ping, or never. */
+export type NotificationSound = "blocked" | "all" | "none";
+
 /** Notification channel toggles. */
 export interface AppNotifications {
   toast: boolean;
   macos: boolean;
+  /**
+   * Terminal-native banners (M25.2): an OSC 9 (kitty: OSC 99) escape written to
+   * each eligible attached client's tty, so terminals that surface them (iTerm2,
+   * Ghostty, WezTerm, kitty) show a native notification even over ssh. Default
+   * true — terminals without support ignore the sequence entirely.
+   */
+  terminal: boolean;
+  /**
+   * Seconds the OS-LEVEL channels (banner / terminal escape / sound / BEL) wait
+   * before firing, re-verifying the pane is STILL in the notified state — a
+   * blocked→working flap inside the window fires nothing. 0 fires immediately.
+   * The in-app toast never waits. Tick-native: the delay rounds up to the
+   * updater's next tick at or after `delaySeconds`.
+   */
+  delaySeconds: number;
+  /** Sound channel (M25.2) — `afplay`/`paplay` + a BEL to eligible client ttys. */
+  sound: NotificationSound;
 }
 
 /** Restore behaviour toggles. */
@@ -110,6 +130,14 @@ export interface AppRestore {
 /** Update-check toggles (consumed later by the update-flow card). */
 export interface AppUpdates {
   check: boolean;
+  /**
+   * Whether the daily update check ALSO refreshes the remote agent-detection
+   * manifest pack into `~/.tmux-ide/agent-detection/pack/` (M25.4). Default
+   * FALSE — auto-installing detection rules is opt-in; `tmux-ide update
+   * --manifests` always works explicitly. Requires `check: true` (the refresh
+   * rides the same daily throttle — no timer of its own).
+   */
+  manifests: boolean;
 }
 
 /** First-run welcome toggles. */
@@ -142,8 +170,48 @@ export interface AppApp {
    * (the explicit cockpit) and a project's `ide.yml` auto-launch are unaffected.
    */
   frontDoor: boolean;
+  /**
+   * Whether `tmux-ide app` runs HOSTED by default (M23.2): the app lives in an
+   * internal `_tmux-ide-app` tmux session and the invoking terminal attaches to
+   * it, so the cockpit survives the terminal and reattaches from anywhere (^q
+   * detaches instead of quitting). Default false — the same behavior as the
+   * explicit `--detachable` flag; `--detachable`/`--hosted` still force it on a
+   * single run.
+   */
+  detachable: boolean;
+  /**
+   * When a plain left drag on an app-mouse pane SELECTS locally instead of
+   * forwarding to the pane's app (M24.2). "agents" (default): panes our own
+   * detection matches to a fleet agent entry select; other app-mouse panes
+   * (vim/htop) forward. "always": every app-mouse pane selects on drag.
+   * "never": every app-mouse pane forwards (the pre-M24.2 behavior). A genuine
+   * click (press+release in one cell) is still forwarded on select-default
+   * panes; shift inverts a pane's default; the right-click pane menu overrides
+   * per pane for the session.
+   */
+  dragSelect: "agents" | "always" | "never";
+  /**
+   * Where a Terminal-surface "New agent" spawn starts (M24.1): `"pane"`
+   * (default) inherits the FOCUSED pane's current working directory —
+   * `#{pane_current_path}`, so the agent lands where you are — while
+   * `"session"` keeps the session/project directory. Home/sidebar spawns
+   * always use the session/project dir (no focused pane exists there).
+   */
+  newAgentCwd: NewAgentCwd;
+  /**
+   * Whether the unified app enables the kitty keyboard protocol on its host
+   * terminal (M24.4). On (default), kitty-capable terminals deliver ⌘-modified
+   * keys — ⌘K opens the command palette — and disambiguated escapes; the app
+   * re-encodes every key for the mirrored panes either way, and terminals
+   * without the protocol ignore the request entirely. Off restores the legacy
+   * key encoding for hosts where the protocol misbehaves.
+   */
+  kittyKeys: boolean;
 }
 
+/** The two Terminal-spawn cwd policies (see {@link AppApp.newAgentCwd}). */
+export type NewAgentCwd = "pane" | "session";
+
 /** Worktree flow config (`tmux-ide worktree`). */
 export interface AppWorktrees {
   /**
@@ -196,13 +264,19 @@ export const DEFAULT_APP_CONFIG: AppConfig = {
     glyphs: { active: "●", inactive: "○" },
   },
   updater: { tickMs: 2000, snapshotEvery: 15 },
-  notifications: { toast: true, macos: false },
+  notifications: { toast: true, macos: false, terminal: true, delaySeconds: 2, sound: "blocked" },
   restore: { resumeAgents: false },
-  updates: { check: true },
+  updates: { check: true, manifests: false },
   welcome: { show: true },
   integrations: { offer: true },
   worktrees: { dir: "" },
-  app: { frontDoor: false },
+  app: {
+    frontDoor: false,
+    detachable: false,
+    dragSelect: "agents",
+    newAgentCwd: "pane",
+    kittyKeys: true,
+  },
 };
 
 /** The default theme tokens — the fallback threaded into the pure builders. */
@@ -237,6 +311,18 @@ function pickPosInt(value: unknown, fallback: number): number {
   return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
 }
 
+/** A non-negative integer (0 allowed — e.g. "no delay"), else the default. */
+function pickNonNegInt(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : fallback;
+}
+
+/** One of the allowed literals, else the default. */
+function pickChoice<T extends string>(value: unknown, allowed: readonly T[], fallback: T): T {
+  return typeof value === "string" && (allowed as readonly string[]).includes(value)
+    ? (value as T)
+    : fallback;
+}
+
 /**
  * PURE — merge an unknown (typically parsed JSON) over {@link DEFAULT_APP_CONFIG}.
  * Every block/leaf is validated independently: a missing or mistyped field falls
@@ -295,13 +381,25 @@ export function parseAppConfig(input: unknown): AppConfig {
     notifications: {
       toast: pickBool(notifications.toast, D.notifications.toast),
       macos: pickBool(notifications.macos, D.notifications.macos),
+      terminal: pickBool(notifications.terminal, D.notifications.terminal),
+      delaySeconds: pickNonNegInt(notifications.delaySeconds, D.notifications.delaySeconds),
+      sound: pickChoice(notifications.sound, ["blocked", "all", "none"], D.notifications.sound),
     },
     restore: { resumeAgents: pickBool(restore.resumeAgents, D.restore.resumeAgents) },
-    updates: { check: pickBool(updates.check, D.updates.check) },
+    updates: {
+      check: pickBool(updates.check, D.updates.check),
+      manifests: pickBool(updates.manifests, D.updates.manifests),
+    },
     welcome: { show: pickBool(welcome.show, D.welcome.show) },
     integrations: { offer: pickBool(integrations.offer, D.integrations.offer) },
     worktrees: { dir: pickString(worktrees.dir, D.worktrees.dir) },
-    app: { frontDoor: pickBool(app.frontDoor, D.app.frontDoor) },
+    app: {
+      frontDoor: pickBool(app.frontDoor, D.app.frontDoor),
+      detachable: pickBool(app.detachable, D.app.detachable),
+      dragSelect: pickChoice(app.dragSelect, ["agents", "always", "never"], D.app.dragSelect),
+      newAgentCwd: pickChoice(app.newAgentCwd, ["pane", "session"], D.app.newAgentCwd),
+      kittyKeys: pickBool(app.kittyKeys, D.app.kittyKeys),
+    },
   };
 }
 

package/packages/daemon/src/lib/manifest-pack.ts

@@ -0,0 +1,255 @@
+/**
+ * Remote agent-detection manifest packs — `tmux-ide update --manifests` (M25.4).
+ *
+ * Detection breadth shouldn't wait for an npm release: agent TUIs change their
+ * chrome between our versions, and a re-tuned manifest is pure data. This
+ * module fetches a versioned MANIFEST PACK from a static URL and installs it
+ * where the manifest loader already hot-merges from.
+ *
+ * ## The pack format (publish contract)
+ *
+ * A single JSON document:
+ *
+ * ```json
+ * {
+ *   "schema": 1,                       // this format's version — reject others
+ *   "pack": "2026.07.12",              // pack version (informational, any string)
+ *   "manifests": [                     // one AgentManifest per entry, exactly the
+ *     {                                //   override-file shape manifest-loader.ts
+ *       "id": "claude",                //   documents (id, commands[], states,
+ *       "commands": ["claude"],        //   optional confidence)
+ *       "confidence": "tuned",
+ *       "states": { "working": { "any": [{ "contains": "esc to interrupt" }] } }
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * Publishing: attach the document as the `agent-manifests.json` asset on a
+ * GitHub release — {@link manifestPackUrl} constructs the same
+ * `releases/download/v<version>/<asset>` URL the TUI-binary download uses, so
+ * a pack rides every release and a NEWER pack can be re-attached to the
+ * CURRENT release tag at any time (the fetch always re-downloads; the pane
+ * option cache never pins it).
+ *
+ * ## Precedence (verified by tests)
+ *
+ * The pack installs into `<agent-detection>/pack/manifest-pack.json` — a
+ * SUBDIRECTORY of the user-override dir, so `readOverrideManifests` (which
+ * lists only `*.json` FILES in the top level) never sees it. The loader merges
+ * `bundled → pack → user`: a pack manifest replaces a bundled id or appends a
+ * new one, and a user's own `<agent-detection>/*.json` file ALWAYS beats both.
+ *
+ * ## Safety
+ *
+ * - Https only for remote URLs. `file://` and loopback `http://` are accepted
+ *   ONLY so tests/dev can exercise the flow without the network — anything
+ *   else is rejected before a byte is fetched.
+ * - The pack is schema-validated ({@link validateManifestPack}) BEFORE being
+ *   written; an invalid pack fails loudly and leaves the previous one intact.
+ * - The gated periodic refresh ({@link maybeRefreshManifestPack}) rides the
+ *   existing daily update check (see {@link ./update-check.ts}) — no timers or
+ *   daemons of its own — and is double-gated on `updates.check` (the caller)
+ *   and `updates.manifests` (read here, default false).
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { AgentManifest } from "../tui/detect/manifest.ts";
+import { overrideDir, validateManifestShape } from "../tui/detect/manifest-loader.ts";
+import { getAppConfig } from "./app-config.ts";
+import { getCurrentVersion } from "./update-check.ts";
+import { RELEASE_REPO } from "./tui-binary.ts";
+
+/** The pack-format version this build understands. */
+export const MANIFEST_PACK_SCHEMA = 1;
+
+/** The release asset name a pack is published under. */
+export const MANIFEST_PACK_ASSET = "agent-manifests.json";
+
+/** Env override for the pack URL (tests/dev; may be `file://` or loopback http). */
+export const MANIFEST_PACK_URL_ENV = "TMUX_IDE_MANIFEST_PACK_URL";
+
+/** A fetched/validated manifest pack. */
+export interface ManifestPack {
+  schema: number;
+  /** Pack version — informational (surfaced in logs), any non-empty string. */
+  pack: string;
+  manifests: AgentManifest[];
+}
+
+// ---------------------------------------------------------------------------
+// Pure
+// ---------------------------------------------------------------------------
+
+/**
+ * PURE — the default pack URL for a version:
+ * `https://github.com/<repo>/releases/download/v<version>/agent-manifests.json`
+ * (the same asset-URL construction as the TUI binary download).
+ */
+export function manifestPackUrl(version: string = getCurrentVersion()): string {
+  const v = version.startsWith("v") ? version.slice(1) : version;
+  return `https://github.com/${RELEASE_REPO}/releases/download/v${v}/${MANIFEST_PACK_ASSET}`;
+}
+
+/**
+ * PURE — is `url` an acceptable pack source? `https:` always; `file:` and
+ * LOOPBACK `http:` (127.0.0.1 / localhost / [::1]) only so tests and local
+ * fixtures can drive the flow. Any other scheme/host is rejected.
+ */
+export function isAllowedPackUrl(url: string): boolean {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return false;
+  }
+  if (parsed.protocol === "https:" || parsed.protocol === "file:") return true;
+  if (parsed.protocol === "http:") {
+    return ["127.0.0.1", "localhost", "[::1]", "::1"].includes(parsed.hostname);
+  }
+  return false;
+}
+
+/**
+ * PURE — validate an untrusted pack document. Returns the typed pack or a
+ * human-readable reason. Every manifest entry must pass the SAME structural
+ * validation user override files do ({@link validateManifestShape}) — one bad
+ * entry rejects the whole pack (a partial install would be harder to reason
+ * about than a loud failure). Never throws.
+ */
+export function validateManifestPack(
+  value: unknown,
+): { ok: true; pack: ManifestPack } | { ok: false; reason: string } {
+  if (typeof value !== "object" || value === null) return { ok: false, reason: "not an object" };
+  const v = value as Record<string, unknown>;
+  if (v.schema !== MANIFEST_PACK_SCHEMA) {
+    return {
+      ok: false,
+      reason: `unsupported schema ${JSON.stringify(v.schema)} (want ${MANIFEST_PACK_SCHEMA})`,
+    };
+  }
+  if (typeof v.pack !== "string" || v.pack.trim().length === 0) {
+    return { ok: false, reason: "missing pack version string" };
+  }
+  if (!Array.isArray(v.manifests) || v.manifests.length === 0) {
+    return { ok: false, reason: "manifests must be a non-empty array" };
+  }
+  for (let i = 0; i < v.manifests.length; i++) {
+    if (!validateManifestShape(v.manifests[i])) {
+      return {
+        ok: false,
+        reason: `manifests[${i}] is not a valid AgentManifest (need id, commands[], states)`,
+      };
+    }
+  }
+  return {
+    ok: true,
+    pack: { schema: MANIFEST_PACK_SCHEMA, pack: v.pack, manifests: v.manifests as AgentManifest[] },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// io
+// ---------------------------------------------------------------------------
+
+/** The installed pack's directory: `<agent-detection>/pack/`. */
+export function packDir(): string {
+  return join(overrideDir(), "pack");
+}
+
+/** The installed pack's path: `<agent-detection>/pack/manifest-pack.json`. */
+export function packPath(): string {
+  return join(packDir(), "manifest-pack.json");
+}
+
+/**
+ * io — fetch and validate a pack. `file://` URLs are read from disk (Node's
+ * fetch does not speak file:); everything else goes through fetch with a
+ * timeout. THROWS with an actionable message on a disallowed URL, a failed
+ * fetch, malformed JSON, or a schema-invalid pack — the caller decides whether
+ * that is loud (CLI) or swallowed (the background refresh).
+ */
+export async function fetchManifestPack(url: string, timeoutMs = 5000): Promise<ManifestPack> {
+  if (!isAllowedPackUrl(url)) {
+    throw new Error(
+      `refusing manifest-pack URL ${url} — https only (file:// and loopback http are allowed for local testing)`,
+    );
+  }
+  let body: string;
+  if (url.startsWith("file:")) {
+    body = readFileSync(fileURLToPath(url), "utf8");
+  } else {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const res = await fetch(url, { signal: controller.signal });
+      if (!res.ok) {
+        throw new Error(
+          `manifest-pack download failed (${url} → HTTP ${res.status} ${res.statusText})`,
+        );
+      }
+      body = await res.text();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    throw new Error(`manifest pack at ${url} is not valid JSON`);
+  }
+  const verdict = validateManifestPack(parsed);
+  if (!verdict.ok) {
+    throw new Error(`manifest pack at ${url} rejected: ${verdict.reason}`);
+  }
+  return verdict.pack;
+}
+
+/**
+ * io — write a validated pack into place atomically (temp-in-same-dir →
+ * rename, so a crash never leaves a half-written pack the loader would then
+ * warn about every run). Returns the installed path.
+ */
+export function installManifestPack(pack: ManifestPack, dest: string = packPath()): string {
+  mkdirSync(dirname(dest), { recursive: true });
+  const tmp = `${dest}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(pack, null, 2));
+  renameSync(tmp, dest);
+  return dest;
+}
+
+/**
+ * io — the `tmux-ide update --manifests` flow: resolve the URL (env override →
+ * the release-asset default), fetch, validate, install. Throws loudly on any
+ * failure (the CLI surfaces it); returns what was installed for reporting.
+ */
+export async function updateManifestPack(
+  opts: { url?: string; log?: (msg: string) => void } = {},
+): Promise<{ path: string; packVersion: string; count: number }> {
+  const log = opts.log ?? (() => {});
+  const url = opts.url ?? process.env[MANIFEST_PACK_URL_ENV] ?? manifestPackUrl();
+  log(`fetching manifest pack from ${url}`);
+  const pack = await fetchManifestPack(url);
+  const path = installManifestPack(pack);
+  log(`installed pack ${pack.pack} (${pack.manifests.length} manifests) → ${path}`);
+  return { path, packVersion: pack.pack, count: pack.manifests.length };
+}
+
+/**
+ * io — the GATED background refresh the daily update check invokes (see
+ * `runUpdateCheck` in {@link ./update-check.ts}). Opt-in via
+ * `updates.manifests: true` (default false); NEVER throws — a failed refresh
+ * just keeps the previous pack, exactly like a failed version check keeps the
+ * previous `latest`.
+ */
+export async function maybeRefreshManifestPack(): Promise<void> {
+  try {
+    if (!getAppConfig().updates.manifests) return;
+    await updateManifestPack();
+  } catch {
+    // Offline, a missing release asset, or an invalid pack — all degrade to
+    // "keep what we have"; the explicit CLI path reports errors loudly instead.
+  }
+}

package/packages/daemon/src/lib/state-home.ts

@@ -0,0 +1,13 @@
+/**
+ * THE tmux-ide state home — `TMUX_IDE_HOME` when set (tests / per-run
+ * overrides), else `~/.tmux-ide`. The same resolution the welcome marker,
+ * update cache, and app state each grew locally; new state files should
+ * resolve through here so none of them can drift from the override again.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+/** Absolute path to the state home directory (not created here). */
+export function stateHome(): string {
+  return process.env.TMUX_IDE_HOME ?? join(homedir(), ".tmux-ide");
+}

package/packages/daemon/src/lib/update-check.ts

@@ -252,6 +252,11 @@ export function getUpdateStatus({
 export async function runUpdateCheck({ now = Date.now() }: { now?: number } = {}): Promise<void> {
   const cache = readUpdateCache();
   if (!shouldCheck(cache?.lastCheckedAt ?? null, now)) return;
+  // The agent-detection manifest-pack refresh RIDES this same daily throttle
+  // (M25.4) — no timer of its own, gated again inside on `updates.manifests`
+  // (default false) and never throwing. Dynamic import: manifest-pack imports
+  // this module for getCurrentVersion, so a static import would be a cycle.
+  void import("./manifest-pack.ts").then((m) => m.maybeRefreshManifestPack()).catch(() => {});
   const fetched = await fetchLatestVersion();
   writeUpdateCache({
     lastCheckedAt: now,

package/packages/daemon/src/restore.ts

@@ -13,9 +13,11 @@
  *
  * `--resume-agents` (or `{ "restore": { "resumeAgents": true } }` in
  * `~/.tmux-ide/config.json`) layers native agent-resume on top: a rebuilt
- * claude pane that carries a recorded `@agent_session_id` relaunches as
- * `claude --resume <id>`, reviving the actual conversation rather than opening
- * a fresh shell. See {@link paneResumeCommand} for the exact decision table.
+ * agent pane that carries a recorded `@agent_session_id` relaunches with its
+ * kind's VERIFIED resume invocation (`claude --resume <id>`, `codex resume
+ * <id>`, … — {@link AGENT_RESUME_COMMANDS}), reviving the actual conversation
+ * rather than opening a fresh shell. See {@link paneResumeCommand} for the
+ * exact decision table.
  *
  * {@link buildRestorePlan} + {@link paneResumeCommand} + {@link restorePrefs}
  * are PURE (unit-tested); {@link restore} is the thin io wrapper that reads the
@@ -92,22 +94,57 @@ export function buildRestorePlan(
 // Pure — agent resume decision
 // ---------------------------------------------------------------------------
 
-/** A session id is trusted only if it's the uuid alphabet — nothing shell-active. */
-const SAFE_SESSION_ID = /^[A-Za-z0-9-]+$/;
+/** A session id is trusted only if it's uuid-ish (`[A-Za-z0-9_-]` — underscore
+ *  covers opencode's `ses_…` ids) — nothing shell-active. */
+const SAFE_SESSION_ID = /^[A-Za-z0-9_-]+$/;
+
+/**
+ * The native session-resume invocation per agent kind (M24.1 — the table was
+ * claude-only until then). ONLY VERIFIED entries ship; each spelling's source:
+ *  - `claude --resume <id>`: the shipped integration (its hooks record the id).
+ *  - `codex resume <id>`: `codex resume --help` — "Usage: codex resume
+ *    [OPTIONS] [SESSION_ID]  … Session id (UUID) or session name".
+ *  - `opencode --session <id>`: `opencode --help` — "-s, --session  session id
+ *    to continue".
+ *  - `cursor-agent --resume <id>`: `cursor-agent --help` — "--resume [chatId]
+ *    Select a session to resume".
+ *  - `copilot --resume=<id>`: GitHub Copilot CLI command reference —
+ *    "--resume[=VALUE]  Resume a previous interactive session … Optionally
+ *    specify a session ID" (the `=` form, since the value is optional).
+ * Unverified (no entry): gemini, aider, goose, amp — no confirmed native
+ * per-session resume invocation at the time of writing.
+ *
+ * How `@agent_session_id` gets recorded per kind (M25.3):
+ *  - claude — the hooks integration (`integration install claude`).
+ *  - opencode — the plugin integration (`integration install opencode`).
+ *  - codex, cursor — automatic: the chrome updater probes the agent's own
+ *    on-disk session state ({@link ./tui/detect/session-id.ts}).
+ *  - copilot — no automatic capture (skipped with evidence — see the
+ *    session-id module header); fires only for panes whose agent self-reported
+ *    the id per the agent contract
+ *    (`tmux set-option -p @agent_session_id <id>`), which any kind may do.
+ */
+export const AGENT_RESUME_COMMANDS: Record<string, (id: string) => string> = {
+  claude: (id) => `claude --resume ${id}`,
+  codex: (id) => `codex resume ${id}`,
+  opencode: (id) => `opencode --session ${id}`,
+  cursor: (id) => `cursor-agent --resume ${id}`,
+  copilot: (id) => `copilot --resume=${id}`,
+};
 
 /**
  * PURE — the command to relaunch a pane so its agent conversation is revived,
  * or `null` for "no resume — leave it a plain shell (or replay `command`)".
  *
  * Decision table (only fires when `resumeAgents` is on):
- *  - claude + a recorded `@agent_session_id` → `claude --resume <id>`. The id is
- *    a uuid, but we don't trust the snapshot: unless it matches
- *    {@link SAFE_SESSION_ID} (`[A-Za-z0-9-]`) we bail to `null` rather than risk
- *    feeding shell metacharacters into send-keys.
- *  - claude with NO session id → `null`. `claude --continue` would be too
- *    magical here (it resumes the most-recent conversation in the cwd, which may
- *    belong to a different pane); a fresh shell is the safe, predictable default.
- *  - any other agent → `null`. No native resume story yet.
+ *  - a kind in {@link AGENT_RESUME_COMMANDS} + a recorded `@agent_session_id` →
+ *    that kind's resume invocation. The id is uuid-ish, but we don't trust the
+ *    snapshot: unless it matches {@link SAFE_SESSION_ID} we bail to `null`
+ *    rather than risk feeding shell metacharacters into send-keys.
+ *  - a known kind with NO session id → `null`. A "continue most recent" flag
+ *    would be too magical here (it resumes the cwd's most-recent conversation,
+ *    which may belong to a different pane); a fresh shell is the safe default.
+ *  - any other agent → `null`. No VERIFIED resume story.
  *  - `resumeAgents` off → always `null`.
  */
 export function paneResumeCommand(
@@ -115,10 +152,11 @@ export function paneResumeCommand(
   opts: { resumeAgents: boolean },
 ): string | null {
   if (!opts.resumeAgents) return null;
-  if (pane.agent !== "claude") return null;
+  const resume = pane.agent ? AGENT_RESUME_COMMANDS[pane.agent] : undefined;
+  if (!resume) return null;
   const id = pane.agentSessionId;
   if (!id || !SAFE_SESSION_ID.test(id)) return null;
-  return `claude --resume ${id}`;
+  return resume(id);
 }
 
 /** PURE — how many of a session's panes would resume under `resumeAgents`. */

package/packages/daemon/src/send.ts

@@ -86,24 +86,36 @@ function prepareMessage(message: string, busyStatus: PaneBusyStatus): string {
   return message;
 }
 
-export async function send(targetDir: string | undefined, opts: SendOptions): Promise<void> {
-  const dir = resolve(targetDir ?? ".");
-  const { name: session } = getSessionName(dir);
-  const { json, to: target, message: rawMessage, noEnter } = opts;
-
-  if (!target) {
-    throw new IdeError("Missing target. Usage: tmux-ide send <target> <message>", {
-      code: "USAGE",
-    });
-  }
+/** What a delivery reports back (the `send --json` payload, and the control
+ *  socket's `send` verb data). */
+export interface DeliverResult {
+  ok: true;
+  session: string;
+  target: { paneId: string; name: string | null; title: string; role: string | null };
+  message: string;
+  busyStatus: PaneBusyStatus;
+  sentViaFile: boolean;
+  warning?: "agent_busy";
+}
 
-  if (!rawMessage) {
-    throw new IdeError("Missing message. Usage: tmux-ide send <target> <message>", {
-      code: "USAGE",
-    });
-  }
+/**
+ * Deliver `message` to a pane of `session` — the SHARED core behind the
+ * `tmux-ide send` CLI case and the control socket's `send` verb. Resolves
+ * `target` (pane id / @ide_name / title / role / partial title), adapts to
+ * the pane's busy status, and routes long messages through a dispatch file
+ * under `dir` when one is given (without a `dir` the text is sent directly).
+ * Throws `IdeError` (SESSION_NOT_FOUND / PANE_NOT_FOUND) — no printing here.
+ */
+export function deliverMessage(opts: {
+  session: string;
+  target: string;
+  message: string;
+  noEnter?: boolean;
+  /** The project dir long messages are dispatched through as a file. */
+  dir?: string;
+}): DeliverResult {
+  const { session, target, noEnter, dir } = opts;
 
-  // Verify session is running
   const state = getSessionState(session);
   if (!state.running) {
     throw new IdeError(`Session "${session}" is not running`, {
@@ -126,13 +138,13 @@ export async function send(targetDir: string | undefined, opts: SendOptions): Pr
   }
 
   const busyStatus = getPaneBusyStatus(session, pane.id);
-  const message = prepareMessage(rawMessage, busyStatus);
+  const message = prepareMessage(opts.message, busyStatus);
 
   let sentViaFile = false;
   if (noEnter) {
     sendText(session, pane.id, message);
   } else {
-    const dispatch = writeDispatchFile(dir, pane.id, message);
+    const dispatch = dir ? writeDispatchFile(dir, pane.id, message) : null;
     if (dispatch) {
       sendCommand(session, pane.id, dispatch.triggerCmd);
       sentViaFile = true;
@@ -141,7 +153,7 @@ export async function send(targetDir: string | undefined, opts: SendOptions): Pr
     }
   }
 
-  const result = {
+  return {
     ok: true,
     session,
     target: {
@@ -153,8 +165,30 @@ export async function send(targetDir: string | undefined, opts: SendOptions): Pr
     message,
     busyStatus,
     sentViaFile,
-    ...(busyStatus === "agent" ? { warning: "agent_busy" } : {}),
+    ...(busyStatus === "agent" ? { warning: "agent_busy" as const } : {}),
   };
+}
+
+export async function send(targetDir: string | undefined, opts: SendOptions): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  const { name: session } = getSessionName(dir);
+  const { json, to: target, message: rawMessage, noEnter } = opts;
+
+  if (!target) {
+    throw new IdeError("Missing target. Usage: tmux-ide send <target> <message>", {
+      code: "USAGE",
+    });
+  }
+
+  if (!rawMessage) {
+    throw new IdeError("Missing message. Usage: tmux-ide send <target> <message>", {
+      code: "USAGE",
+    });
+  }
+
+  const result = deliverMessage({ session, target, message: rawMessage, noEnter, dir });
+  const { message, busyStatus } = result;
+  const pane = result.target;
 
   if (json) {
     console.log(JSON.stringify(result, null, 2));
@@ -163,7 +197,7 @@ export async function send(targetDir: string | undefined, opts: SendOptions): Pr
 
   const label = pane.name ?? pane.title;
   const preview = message.length > 60 ? message.slice(0, 60) + "..." : message;
-  console.log(`Sent to "${label}" (${pane.id}): ${preview}`);
+  console.log(`Sent to "${label}" (${pane.paneId}): ${preview}`);
 
   if (busyStatus === "agent") {
     console.log("Warning: agent appears busy. Message sent anyway.");