tmux-ide 2.6.1 → 2.8.0

package/packages/daemon/src/tui/team/sessions.ts

@@ -14,10 +14,12 @@ import { execFileSync } from "node:child_process";
 import {
   classifyInstant,
   parseAuthority,
+  parseAuthorityEpoch,
+  sanitizeAgentText,
   type AgentStatus,
   type StatusTracker,
 } from "../detect/classify.ts";
-import type { AgentManifest } from "../detect/manifest.ts";
+import type { AgentManifest, ManifestConfidence } from "../detect/manifest.ts";
 import { readProcessTable, resolveAgentCommand } from "../detect/process-tree.ts";
 import { readPaneSnapshot } from "../detect/snapshot.ts";
 
@@ -33,6 +35,119 @@ export interface TeamSession {
    * this is the richer breakdown the switcher/cockpit navigate.
    */
   windowList: TeamWindow[];
+  /**
+   * Per-pane agent detail — one entry for every pane the two-layer detection
+   * classifies as an agent (a manifest resolved and it isn't the `shell`
+   * catch-all). A FLAT list across the session's windows; each entry carries
+   * its own `windowIndex`, so a consumer that wants a per-window view groups by
+   * it. ADDITIVE: the rollup fields above (`status`, `windowList`, `panes`) are
+   * unchanged — this only SURFACES per-pane truth the rollup already computes.
+   * Optional so pre-existing constructors stay valid; {@link listTeamSessions}
+   * always populates it (possibly empty).
+   */
+  agents?: PaneAgentEntry[];
+}
+
+/**
+ * Per-pane agent detail surfaced alongside a session's rollup. Emitted only for
+ * panes that resolve to a real agent (a manifest, excluding the `shell`
+ * catch-all). Everything here is already computed during the status rollup —
+ * this record just keeps it instead of discarding it.
+ */
+export interface PaneAgentEntry {
+  /** tmux pane id, e.g. `%5`. */
+  paneId: string;
+  /** `window_index` of the window (tab) this pane lives in. */
+  windowIndex: number;
+  /** Owning session name (repeated per entry so a flattened list stays keyed). */
+  session: string;
+  /** The resolved agent kind — the manifest id (`claude`, `codex`, …). */
+  kind: string;
+  /** Final per-pane status (authority when fresh, else scraped/tracked). */
+  state: AgentStatus;
+  /** The manifest's evidence confidence (`conservative` when the manifest omits it). */
+  confidence: ManifestConfidence;
+  /**
+   * The authority state's epoch stamp when the AUTHORITY layer provided the
+   * state (`@agent_state` = `"<state>:<epoch>"`); null for a scraped/tracked
+   * pane, which has no authoritative timestamp.
+   */
+  since: number | null;
+  /** `pane_title`. */
+  title: string;
+  /** `pane_current_command` — the pane's immediate process (often node/bun/sh). */
+  command: string;
+  /** `pane_current_path` — the pane's working directory. */
+  dir: string;
+  /**
+   * Self-reported one-liner (`@agent_status_text`, sanitized + clamped to 32
+   * chars) — what the agent says it is doing ("refactoring auth"). ADDITIVE and
+   * present only while the pane's `@agent_state` stamp is FRESH (the metadata
+   * follows the same authority-staleness rules; stale/absent authority drops it).
+   */
+  statusText?: string;
+  /**
+   * Self-reported display name (`@agent_display_name`, sanitized) — label
+   * precedence over `kind` in the sidebar/chips. Same freshness gate as
+   * {@link statusText}. ADDITIVE.
+   */
+  displayName?: string;
+}
+
+/**
+ * Build a {@link PaneAgentEntry} from a classified pane — PURE. Returns null
+ * for a NON-agent pane (no manifest resolved, or the `shell` catch-all), which
+ * gets no entry. `since` is threaded from the caller (the authority epoch when
+ * the authority layer supplied the state, else null). No tmux/`ps` access —
+ * every input is already resolved by the rollup.
+ */
+export function buildAgentEntry(input: {
+  sessionName: string;
+  pane: Pick<PaneRecord, "id" | "windowIndex" | "title" | "cmd" | "dir">;
+  manifest: AgentManifest | undefined;
+  state: AgentStatus;
+  since: number | null;
+  /** Already-sanitized display metadata (undefined when absent/stale). */
+  statusText?: string;
+  displayName?: string;
+}): PaneAgentEntry | null {
+  const { manifest, pane } = input;
+  if (!manifest || manifest.id === "shell") return null;
+  return {
+    paneId: pane.id,
+    windowIndex: pane.windowIndex,
+    session: input.sessionName,
+    kind: manifest.id,
+    state: input.state,
+    confidence: manifest.confidence ?? "conservative",
+    since: input.since,
+    title: pane.title,
+    command: pane.cmd,
+    dir: pane.dir,
+    ...(input.statusText !== undefined ? { statusText: input.statusText } : {}),
+    ...(input.displayName !== undefined ? { displayName: input.displayName } : {}),
+  };
+}
+
+/**
+ * PURE — the display metadata a pane's agent entry surfaces: the sanitized
+ * `@agent_status_text` / `@agent_display_name` options, gated on the SAME
+ * authority-freshness verdict as the state itself. `authorityFresh` is
+ * `parseAuthority(...) !== null` — when the pane's `@agent_state` stamp is
+ * absent or stale (a dead hook mid-turn), the metadata is dropped with it
+ * rather than lying alongside a scraped state.
+ */
+export function agentMetadataFor(
+  pane: Pick<PaneRecord, "statusTextRaw" | "displayNameRaw">,
+  authorityFresh: boolean,
+): { statusText?: string; displayName?: string } {
+  if (!authorityFresh) return {};
+  const statusText = sanitizeAgentText(pane.statusTextRaw);
+  const displayName = sanitizeAgentText(pane.displayNameRaw);
+  return {
+    ...(statusText !== undefined ? { statusText } : {}),
+    ...(displayName !== undefined ? { displayName } : {}),
+  };
 }
 
 /**
@@ -63,6 +178,15 @@ export interface PaneDetail {
   paneId: string;
   agent: string | null;
   status: AgentStatus;
+  /** `window_index` of the pane's window — the notification path suppresses
+   *  toasts window-granularly, so the transition must know its window. */
+  windowIndex: number;
+  /** `pane_pid` — root of the pane's process tree (session-id capture probes from it). */
+  pid: number;
+  /** `pane_current_path` — the pane's working directory. */
+  dir: string;
+  /** Existing `@agent_session_id` stamp, or null (capture only fills empty ones). */
+  sessionId: string | null;
 }
 
 interface PaneRecord {
@@ -74,10 +198,18 @@ interface PaneRecord {
   cmd: string;
   /** `pane_title`. */
   title: string;
+  /** `pane_current_path` — the pane's working directory. */
+  dir: string;
   /** Raw `@agent_state` pane option (authority layer), if set. */
   authority: string;
   /** Raw `@agent_hint` pane option — forces a manifest when set. */
   hint: string;
+  /** Raw `@agent_session_id` pane option — the agent's own session id, if recorded. */
+  sessionId: string;
+  /** Raw `@agent_status_text` pane option — sanitized by {@link agentMetadataFor}. */
+  statusTextRaw: string;
+  /** Raw `@agent_display_name` pane option — sanitized by {@link agentMetadataFor}. */
+  displayNameRaw: string;
   /** `window_index` — the window (tab) this pane lives in. */
   windowIndex: number;
   /** `window_name`. */
@@ -105,12 +237,13 @@ export function excludeSidebarPanes<T extends { sidebar: boolean }>(panes: T[]):
 const SEVERITY: AgentStatus[] = ["blocked", "working", "done", "idle", "unknown"];
 
 /**
- * Whether a session should appear in the switcher. Any `_`-prefixed session is
- * internal plumbing (the `_tmux-ide-chrome` updater, scratch sessions, …) and
- * is filtered out so the cockpit never lists — or navigates into — infrastructure.
+ * Whether a session should appear in the switcher. `_`-prefixed sessions are
+ * internal plumbing (the `_tmux-ide-chrome` updater, the `_tmux-ide-app` host)
+ * and `zz-`-prefixed sessions are development scratch sessions — both are
+ * filtered out so the cockpit never lists — or navigates into — infrastructure.
  */
 export function isListableSession(name: string): boolean {
-  return !name.startsWith("_");
+  return !name.startsWith("_") && !name.startsWith("zz-");
 }
 
 function tmux(args: string[]): string {
@@ -177,16 +310,21 @@ export function listTeamSessions(
       const seen = opts.viewed === name;
 
       const nowSec = Math.floor(Date.now() / 1000);
-      const wantPane = typeof opts.onPane === "function";
+      const agents: PaneAgentEntry[] = [];
       const statuses = panes.map((pane) => {
         // AUTHORITY first: a fresh hook-reported state outranks scraping.
         const authority = parseAuthority(pane.authority, nowSec);
         let status: AgentStatus;
-        // The manifest is resolved in the fallback anyway; for authority panes
-        // we only resolve it (cheaply — the process table is already loaded, no
-        // capture) when a pane sink wants the agent name for a chip.
+        // The agent kind is needed for BOTH the chip (onPane) and the per-pane
+        // agent entry, so the manifest is resolved for every pane. It's cheap —
+        // the process table is already loaded, and authority panes take NO
+        // capture-pane round-trip.
         let manifest: AgentManifest | undefined;
+        // The authority state's own timestamp (its "since"); only fresh
+        // authority states carry one — scraped panes have no stamp.
+        let since: number | null = null;
         if (authority !== null) {
+          since = parseAuthorityEpoch(pane.authority);
           if (authority === "done" && seen) {
             // Viewing acknowledges a finished agent — persist the ack so the
             // pane doesn't flip back to done on the next tick.
@@ -195,11 +333,9 @@ export function listTeamSessions(
           } else {
             status = authority;
           }
-          if (wantPane) {
-            manifest = resolveAgentCommand(pane.cmd, pane.pid, processTable, {
-              hint: pane.hint,
-            }).manifest;
-          }
+          manifest = resolveAgentCommand(pane.cmd, pane.pid, processTable, {
+            hint: pane.hint,
+          }).manifest;
         } else {
           // FALLBACK: snapshot scraping. Resolve the real agent from the pane's
           // process tree (pane_current_command alone is usually just node/bun/sh).
@@ -220,7 +356,24 @@ export function listTeamSessions(
           paneId: pane.id,
           agent: manifest && manifest.id !== "shell" ? manifest.id : null,
           status,
+          windowIndex: pane.windowIndex,
+          pid: pane.pid,
+          dir: pane.dir,
+          sessionId: pane.sessionId.length > 0 ? pane.sessionId : null,
+        });
+        // Surface per-pane agent detail (same resolved manifest/status — nothing
+        // re-derived). Non-agent panes yield null and are skipped. Display
+        // metadata (@agent_status_text/@agent_display_name) is gated on the SAME
+        // freshness verdict as the authority state — stale/absent stamp drops it.
+        const entry = buildAgentEntry({
+          sessionName: name,
+          pane,
+          manifest,
+          state: status,
+          since,
+          ...agentMetadataFor(pane, authority !== null),
         });
+        if (entry) agents.push(entry);
         return status;
       });
 
@@ -233,6 +386,7 @@ export function listTeamSessions(
         // `panes` and `statuses` are parallel (statuses = panes.map(...)), so
         // the pure rollup can group each pane's window with its resolved status.
         windowList: rollupWindows(panes, statuses),
+        agents,
       };
     });
 }
@@ -243,9 +397,14 @@ function collectPanes(): Map<string, PaneRecord[]> {
     "list-panes",
     "-a",
     "-F",
-    // Window fields sit before pane_title so the (tab-safe) title stays the
-    // trailing catch-all — window names don't contain tabs in practice.
-    `#{session_name}\t#{pane_id}\t#{pane_pid}\t#{pane_current_command}\t#{@agent_state}\t#{@agent_hint}\t#{${SIDEBAR_PANE_OPTION}}\t#{window_index}\t#{window_name}\t#{window_active}\t#{pane_title}`,
+    // Window fields + pane_current_path sit before pane_title so the (tab-safe)
+    // title stays the trailing catch-all — window names/paths don't contain tabs
+    // in practice. pane_current_path rides this SAME list-panes call (no extra
+    // tmux round-trip) so per-pane agent entries can carry a working dir.
+    // @agent_status_text/@agent_display_name ride the same caveat: the contract
+    // (skill/SKILL.md) says plain text; a stamped tab would shift this one
+    // pane's fields (sanitizeAgentText strips control chars AFTER the split).
+    `#{session_name}\t#{pane_id}\t#{pane_pid}\t#{pane_current_command}\t#{@agent_state}\t#{@agent_hint}\t#{@agent_session_id}\t#{@agent_status_text}\t#{@agent_display_name}\t#{${SIDEBAR_PANE_OPTION}}\t#{window_index}\t#{window_name}\t#{window_active}\t#{pane_current_path}\t#{pane_title}`,
   ]);
   const bySession = new Map<string, PaneRecord[]>();
   for (const line of raw.split("\n").filter(Boolean)) {
@@ -256,10 +415,14 @@ function collectPanes(): Map<string, PaneRecord[]> {
       cmd = "",
       authority = "",
       hint = "",
+      sessionId = "",
+      statusTextRaw = "",
+      displayNameRaw = "",
       sidebar = "",
       windowIndex = "0",
       windowName = "",
       windowActive = "0",
+      dir = "",
       ...titleParts
     ] = line.split("\t");
     if (!session) continue;
@@ -270,10 +433,14 @@ function collectPanes(): Map<string, PaneRecord[]> {
       cmd,
       authority,
       hint,
+      sessionId,
+      statusTextRaw,
+      displayNameRaw,
       sidebar: sidebar === "1",
       windowIndex: Number(windowIndex) || 0,
       windowName,
       windowActive: windowActive === "1",
+      dir,
       title: titleParts.join("\t"),
     });
     bySession.set(session, list);

package/packages/daemon/src/tui/team/wait.ts

@@ -0,0 +1,144 @@
+/**
+ * The `wait` conditions — the SHARED implementation behind `tmux-ide wait
+ * agent-status` / `tmux-ide wait output` (bin/cli.ts) and the control
+ * socket's `wait` verb (src/control/). Extracted from the CLI case so the
+ * socket is a transport over the same logic, not a second implementation.
+ *
+ * Both loops are deps-injected (fleet lister / pane capture, clock, sleep)
+ * so the polling logic unit-tests without tmux; the exported defaults wire
+ * the real io.
+ */
+import { capturePane } from "@tmux-ide/tmux-bridge";
+import type { AgentStatus, StatusTracker } from "../detect/classify.ts";
+import { createStatusTracker } from "../detect/classify.ts";
+import { findSessionStatus } from "./report.ts";
+import { listTeamSessions, type TeamSession } from "./sessions.ts";
+
+/** Default overall timeout (matches the CLI's historical default). */
+export const WAIT_DEFAULT_TIMEOUT_MS = 60_000;
+/** Poll cadence for the agent-status wait. */
+export const WAIT_STATUS_POLL_MS = 750;
+/** Poll cadence for the output-match wait. */
+export const WAIT_OUTPUT_POLL_MS = 500;
+
+const sleepMs = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
+
+/**
+ * PURE — test `text` (a pane capture) against `pattern`, line by line, and
+ * report the first matching LINE; falls back to whole-text matching (with the
+ * last line reported) so multi-line patterns still hit. A fresh RegExp per
+ * test so a user-supplied /g flag can't carry `lastIndex` between calls.
+ * Returns null when nothing matches.
+ */
+export function matchOutput(text: string, pattern: string): string | null {
+  const lines = text.split("\n");
+  for (const line of lines) {
+    if (new RegExp(pattern).test(line)) return line;
+  }
+  if (new RegExp(pattern).test(text)) return lines[lines.length - 1] ?? "";
+  return null;
+}
+
+export interface WaitAgentStatusResult {
+  ok: boolean;
+  session: string;
+  want: AgentStatus;
+  /** The session's last observed status (null = session absent). */
+  status: AgentStatus | null;
+  /** Set when `ok` is false: how long we waited. */
+  timedOutAfterMs?: number;
+}
+
+export interface WaitAgentStatusOpts {
+  timeoutMs?: number;
+  pollMs?: number;
+  /**
+   * The tracker threaded across polls (one PERSISTS per wait so the
+   * cross-tick working→idle `done` transition can be observed). Injected by
+   * tests; defaults to a fresh tracker.
+   */
+  tracker?: StatusTracker;
+  listSessions?: (tracker: StatusTracker) => TeamSession[];
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+}
+
+/** Block until `session` reaches `want`, or time out. Never throws. */
+export async function waitForAgentStatus(
+  session: string,
+  want: AgentStatus,
+  opts: WaitAgentStatusOpts = {},
+): Promise<WaitAgentStatusResult> {
+  const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
+  const pollMs = opts.pollMs ?? WAIT_STATUS_POLL_MS;
+  const tracker = opts.tracker ?? createStatusTracker();
+  const list = opts.listSessions ?? listTeamSessions;
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? sleepMs;
+  const started = now();
+
+  for (;;) {
+    const status = findSessionStatus(list(tracker), session);
+    if (status === want) return { ok: true, session, want, status };
+    if (now() - started >= timeoutMs) {
+      return { ok: false, session, want, status, timedOutAfterMs: timeoutMs };
+    }
+    await sleep(pollMs);
+  }
+}
+
+export interface WaitOutputResult {
+  ok: boolean;
+  target: string;
+  pattern: string;
+  /** The matching line when `ok`; null on timeout. */
+  matched: string | null;
+  timedOutAfterMs?: number;
+}
+
+export interface WaitOutputOpts {
+  timeoutMs?: number;
+  pollMs?: number;
+  /** Pane capture (defaults to tmux-bridge's `capturePane`, 200 lines). */
+  capture?: (target: string) => string;
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+}
+
+/**
+ * Block until `target`'s captured output matches `pattern`, or time out.
+ * A capture failure (pane/session not (yet) available) keeps polling until
+ * the timeout. Throws only on an invalid regex — validate before looping.
+ */
+export async function waitForOutputMatch(
+  target: string,
+  pattern: string,
+  opts: WaitOutputOpts = {},
+): Promise<WaitOutputResult> {
+  new RegExp(pattern); // an invalid pattern is a usage error, surfaced up front
+  const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
+  const pollMs = opts.pollMs ?? WAIT_OUTPUT_POLL_MS;
+  const capture = opts.capture ?? defaultCapture;
+  const now = opts.now ?? Date.now;
+  const sleep = opts.sleep ?? sleepMs;
+  const started = now();
+
+  for (;;) {
+    let text = "";
+    try {
+      text = capture(target);
+    } catch {
+      // not capturable yet — keep polling
+    }
+    const matched = matchOutput(text, pattern);
+    if (matched !== null) return { ok: true, target, pattern, matched };
+    if (now() - started >= timeoutMs) {
+      return { ok: false, target, pattern, matched: null, timedOutAfterMs: timeoutMs };
+    }
+    await sleep(pollMs);
+  }
+}
+
+function defaultCapture(target: string): string {
+  return capturePane(target, { lines: 200 });
+}

package/scripts/build-macos-notifier.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/** Build the universal, appearance-aware native macOS notification helper. */
+import { execFileSync } from "node:child_process";
+import {
+  chmodSync,
+  cpSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+if (process.platform !== "darwin") {
+  throw new Error("build-macos-notifier must run on macOS with Xcode 26 or newer");
+}
+
+const here = dirname(fileURLToPath(import.meta.url));
+const root = resolve(here, "..");
+const sourceDir = join(root, "native", "macos", "notifier");
+const outputFlag = process.argv.indexOf("--output");
+const versionFlag = process.argv.indexOf("--version");
+const appPath = resolve(
+  outputFlag === -1
+    ? join(root, "packages", "daemon", "dist", "native", "TmuxIdeNotifier.app")
+    : process.argv[outputFlag + 1],
+);
+const packageJson = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+const version = String(
+  versionFlag === -1 ? packageJson.version || "1.0.0" : process.argv[versionFlag + 1],
+);
+const buildVersion = /^\d+(?:\.\d+){0,2}/.exec(version)?.[0] ?? "1";
+const signingIdentity = process.env.TMUX_IDE_CODESIGN_IDENTITY?.trim() || "-";
+const scratch = mkdtempSync(join(tmpdir(), "tmux-ide-notifier-"));
+
+function run(command, args, options = {}) {
+  execFileSync(command, args, { stdio: "inherit", ...options });
+}
+
+function output(command, args) {
+  return execFileSync(command, args, { encoding: "utf8" }).trim();
+}
+
+try {
+  const contents = join(appPath, "Contents");
+  const macosDir = join(contents, "MacOS");
+  const resourcesDir = join(contents, "Resources");
+  const stagedIcon = join(scratch, "AppIcon.icon");
+  const armBinary = join(scratch, "tmux-ide-notifier-arm64");
+  const x64Binary = join(scratch, "tmux-ide-notifier-x86_64");
+  const universalBinary = join(macosDir, "tmux-ide-notifier");
+
+  rmSync(appPath, { recursive: true, force: true });
+  mkdirSync(macosDir, { recursive: true });
+  mkdirSync(resourcesDir, { recursive: true });
+  cpSync(join(sourceDir, "AppIcon.icon"), stagedIcon, { recursive: true });
+
+  const swiftArgs = (target, output) => [
+    "swiftc",
+    "-O",
+    "-parse-as-library",
+    "-swift-version",
+    "5",
+    "-target",
+    target,
+    "-framework",
+    "AppKit",
+    "-framework",
+    "UserNotifications",
+    "-framework",
+    "Security",
+    join(sourceDir, "TmuxIdeNotifier.swift"),
+    "-o",
+    output,
+  ];
+  run("xcrun", swiftArgs("arm64-apple-macos11.0", armBinary));
+  run("xcrun", swiftArgs("x86_64-apple-macos11.0", x64Binary));
+  run("xcrun", ["lipo", "-create", armBinary, x64Binary, "-output", universalBinary]);
+  chmodSync(universalBinary, 0o755);
+
+  run("xcrun", [
+    "actool",
+    stagedIcon,
+    "--compile",
+    resourcesDir,
+    "--platform",
+    "macosx",
+    "--minimum-deployment-target",
+    "11.0",
+    "--target-device",
+    "mac",
+    "--app-icon",
+    "AppIcon",
+    "--standalone-icon-behavior",
+    "all",
+    "--output-partial-info-plist",
+    join(scratch, "icon-partial.plist"),
+    "--warnings",
+    "--notices",
+    "--errors",
+    "--output-format",
+    "human-readable-text",
+  ]);
+
+  const plist = readFileSync(join(sourceDir, "Info.plist"), "utf8")
+    // Apple bundle versions are numeric even when the npm release carries a
+    // prerelease suffix (for example 2.8.0-beta.1).
+    .replaceAll("__VERSION__", buildVersion)
+    .replaceAll("__BUILD_VERSION__", buildVersion);
+  writeFileSync(join(contents, "Info.plist"), plist);
+  writeFileSync(join(contents, "PkgInfo"), "APPL????");
+
+  // Portable release artifacts use an ad-hoc signature plus the helper's
+  // native compatibility delivery. A release environment can provide a
+  // Developer ID identity as part of a signed + notarized distribution; that
+  // makes the modern UNUserNotificationCenter path eligible at runtime.
+  const signArgs =
+    signingIdentity === "-"
+      ? ["--force", "--deep", "--sign", "-", "--timestamp=none", appPath]
+      : [
+          "--force",
+          "--deep",
+          "--options",
+          "runtime",
+          "--sign",
+          signingIdentity,
+          "--timestamp",
+          appPath,
+        ];
+  run("codesign", signArgs);
+  run("codesign", ["--verify", "--deep", "--strict", appPath]);
+
+  const architectures = new Set(output("xcrun", ["lipo", "-archs", universalBinary]).split(/\s+/));
+  for (const architecture of ["arm64", "x86_64"]) {
+    if (!architectures.has(architecture)) {
+      throw new Error(`native notifier is missing ${architecture}`);
+    }
+  }
+
+  const assetInfo = JSON.parse(
+    output("xcrun", ["assetutil", "--info", join(resourcesDir, "Assets.car")]),
+  );
+  const iconAppearances = new Set(
+    assetInfo.filter((entry) => entry.AssetType === "IconGroup").map((entry) => entry.Appearance),
+  );
+  for (const appearance of ["NSAppearanceNameAqua", "NSAppearanceNameDarkAqua"]) {
+    if (!iconAppearances.has(appearance)) {
+      throw new Error(`native notifier icon is missing ${appearance}`);
+    }
+  }
+
+  console.log(
+    `[build-macos-notifier] wrote ${appPath} (${[...architectures].join("+")}; Aqua+DarkAqua)`,
+  );
+} finally {
+  rmSync(scratch, { recursive: true, force: true });
+}

package/scripts/build-tui.mjs

@@ -16,7 +16,9 @@
  * node-only for CI) — run `pnpm build:tui` on a machine with bun.
  *
  * Cross-compile: pass `--target bun-<os>-<arch>` (e.g. bun-linux-x64) to build
- * for another platform. Defaults to the host target.
+ * for another platform. Defaults to the host target. Pass `--outfile <path>` to
+ * write somewhere other than the default dist path (the release workflow uses
+ * this to emit per-platform artifacts side by side).
  */
 
 import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin";
@@ -27,8 +29,7 @@ import { fileURLToPath } from "node:url";
 const here = dirname(fileURLToPath(import.meta.url));
 const repoRoot = resolve(here, "..");
 const entry = resolve(repoRoot, "packages/daemon/src/tui/main.ts");
-const outDir = resolve(repoRoot, "packages/daemon/dist/tui");
-const outfile = resolve(outDir, "tmux-ide-tui");
+const defaultOutDir = resolve(repoRoot, "packages/daemon/dist/tui");
 
 if (!existsSync(entry)) {
   throw new Error(`[build-tui] entry not found: ${entry}`);
@@ -38,7 +39,13 @@ const targetArg = process.argv.indexOf("--target");
 const target =
   targetArg !== -1 ? process.argv[targetArg + 1] : `bun-${process.platform}-${process.arch}`;
 
-mkdirSync(outDir, { recursive: true });
+const outfileArg = process.argv.indexOf("--outfile");
+const outfile =
+  outfileArg !== -1
+    ? resolve(process.argv[outfileArg + 1])
+    : resolve(defaultOutDir, "tmux-ide-tui");
+
+mkdirSync(dirname(outfile), { recursive: true });
 
 const start = Date.now();
 const result = await Bun.build({