@lattices/cli 0.6.0 → 0.6.1

package/bin/lattices.ts

@@ -1,10 +1,30 @@
 #!/usr/bin/env bun
 
-import { createHash } from "node:crypto";
 import { execSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, resolve } from "node:path";
 import { homedir } from "node:os";
+import { withDaemon, type DaemonClient } from "./cli/daemon.ts";
+import {
+  hasFlag,
+  nonFlagArgs,
+  parseFlagValue,
+  parseOptionalNumber,
+  pause,
+  run,
+  runQuiet,
+} from "./cli/helpers.ts";
+import { searchCommand, placeCommand } from "./cli/search.ts";
+import { captureCommand } from "./cli/capture.ts";
+import { layerCommand } from "./cli/layer.ts";
+import { runsCommand } from "./cli/runs.ts";
+import {
+  esc,
+  sessionExists,
+  slugify,
+  toGroupSessionName,
+  toSessionName,
+} from "./cli/session.ts";
 
 // Daemon client (lazy-loaded to avoid blocking startup for TTY commands)
 let _daemonClient: typeof import("./daemon-client.ts") | undefined;
@@ -20,25 +40,6 @@ const command: string | undefined = args[0];
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
-interface ExecOpts {
-  encoding?: string;
-  stdio?: string | string[];
-  cwd?: string;
-  [key: string]: any;
-}
-
-function run(cmd: string, opts: ExecOpts = {}): string {
-  return execSync(cmd, { encoding: "utf8", ...opts } as any).trim();
-}
-
-function runQuiet(cmd: string): string | null {
-  try {
-    return run(cmd, { stdio: "pipe" });
-  } catch {
-    return null;
-  }
-}
-
 function hasTmux(): boolean {
   return runQuiet("which tmux") !== null;
 }
@@ -78,70 +79,10 @@ function isInsideTmux(): boolean {
   return !!process.env.TMUX;
 }
 
-function sessionExists(name: string): boolean {
-  return runQuiet(`tmux has-session -t "${name}" 2>&1`) !== null;
-}
-
-function pathHash(dir: string): string {
-  return createHash("sha256").update(resolve(dir)).digest("hex").slice(0, 6);
-}
-
-function toSessionName(dir: string): string {
-  const base = basename(dir).replace(/[^a-zA-Z0-9_-]/g, "-");
-  return `${base}-${pathHash(dir)}`;
-}
-
-function esc(str: string): string {
-  return str.replace(/'/g, "'\\''");
-}
-
 function appleScriptString(str: string): string {
   return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
 
-function slugify(str: string): string {
-  return str
-    .toLowerCase()
-    .replace(/\.app$/i, "")
-    .replace(/[^a-z0-9_-]+/g, "-")
-    .replace(/^-+|-+$/g, "") || "app";
-}
-
-function parseFlagValue(args: string[], name: string): string | undefined {
-  const prefix = `--${name}=`;
-  const exact = `--${name}`;
-  for (let i = 0; i < args.length; i++) {
-    if (args[i].startsWith(prefix)) return args[i].slice(prefix.length);
-    if (args[i] === exact) return args[i + 1];
-  }
-  return undefined;
-}
-
-function hasFlag(args: string[], name: string): boolean {
-  return args.includes(`--${name}`);
-}
-
-function nonFlagArgs(args: string[]): string[] {
-  const valueFlags = new Set([
-    "id", "state", "ttl", "ttlMs", "x", "y", "gap", "placement", "style", "name", "scale",
-    "hud-url", "hudUrl", "hud-html", "hudHTML", "hudHtml", "hud-title", "hudTitle",
-    "hud-width", "hudWidth", "hud-height", "hudHeight", "width", "height",
-    "manifest", "root", "max-depth", "maxDepth", "read-access", "readAccess",
-    "pause",
-  ]);
-  const out: string[] = [];
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (!arg.startsWith("--")) {
-      out.push(arg);
-      continue;
-    }
-    const flagName = arg.slice(2);
-    if (!arg.includes("=") && valueFlags.has(flagName)) i++;
-  }
-  return out;
-}
-
 // ── Config ───────────────────────────────────────────────────────────
 
 function readConfig(dir: string): any | null {
@@ -170,10 +111,6 @@ function readWorkspaceConfig(): any | null {
   }
 }
 
-function toGroupSessionName(groupId: string): string {
-  return `lattices-group-${groupId}`;
-}
-
 /** Get ordered pane IDs for a specific window within a session */
 function getPaneIdsForWindow(sessionName: string, windowIndex: number): string[] {
   const out = runQuiet(
@@ -883,15 +820,16 @@ function restartPane(target?: string): void {
 // ── Daemon-aware commands ────────────────────────────────────────────
 
 async function mouseCommand(sub?: string): Promise<void> {
-  const { daemonCall } = await getDaemonClient();
-  if (sub === "summon") {
-    const result = await daemonCall("mouse.summon") as any;
-    console.log(`🎯 Mouse summoned to (${result.x}, ${result.y})`);
-  } else {
-    // Default: find
-    const result = await daemonCall("mouse.find") as any;
-    console.log(`🔍 Mouse at (${result.x}, ${result.y})`);
-  }
+  await withDaemon(async ({ daemonCall }) => {
+    if (sub === "summon") {
+      const result = await daemonCall("mouse.summon") as any;
+      console.log(`🎯 Mouse summoned to (${result.x}, ${result.y})`);
+    } else {
+      // Default: find
+      const result = await daemonCall("mouse.find") as any;
+      console.log(`🔍 Mouse at (${result.x}, ${result.y})`);
+    }
+  });
 }
 
 async function daemonStatusCommand(): Promise<void> {
@@ -907,7 +845,7 @@ async function daemonStatusCommand(): Promise<void> {
     console.log(`  uptime:    ${uptimeStr}`);
     console.log(`  clients:   ${status.clientCount}`);
     console.log(`  windows:   ${status.windowCount}`);
-    console.log(`  tmux:      ${status.tmuxSessionCount} sessions`);
+    console.log(`  sessions:  ${status.tmuxSessionCount}`);
     console.log(`  version:   ${status.version}`);
   } catch {
     console.log("\x1b[90m○\x1b[0m Daemon not running (start with: lattices app)");
@@ -915,8 +853,7 @@ async function daemonStatusCommand(): Promise<void> {
 }
 
 async function windowsCommand(jsonFlag: boolean): Promise<void> {
-  try {
-    const { daemonCall } = await getDaemonClient();
+  await withDaemon(async ({ daemonCall }) => {
     const windows = await daemonCall("windows.list") as any[];
     if (jsonFlag) {
       console.log(JSON.stringify(windows, null, 2));
@@ -936,9 +873,7 @@ async function windowsCommand(jsonFlag: boolean): Promise<void> {
       console.log(`    ${Math.round(w.frame.w)}×${Math.round(w.frame.h)} at (${Math.round(w.frame.x)},${Math.round(w.frame.y)})`);
       console.log();
     }
-  } catch {
-    console.log("Daemon not running. Start with: lattices app");
-  }
+  });
 }
 
 async function windowAssignCommand(wid?: string, layerId?: string): Promise<void> {
@@ -946,18 +881,14 @@ async function windowAssignCommand(wid?: string, layerId?: string): Promise<void
     console.log("Usage: lattices window assign <wid> <layer-id>");
     return;
   }
-  try {
-    const { daemonCall } = await getDaemonClient();
+  await withDaemon(async ({ daemonCall }) => {
     await daemonCall("window.assignLayer", { wid: parseInt(wid), layer: layerId });
     console.log(`Tagged wid:${wid} → layer:${layerId}`);
-  } catch (e: unknown) {
-    console.log(`Error: ${(e as Error).message}`);
-  }
+  });
 }
 
 async function windowLayerMapCommand(jsonFlag: boolean): Promise<void> {
-  try {
-    const { daemonCall } = await getDaemonClient();
+  await withDaemon(async ({ daemonCall }) => {
     const map = await daemonCall("window.layerMap") as any;
     if (jsonFlag) {
       console.log(JSON.stringify(map, null, 2));
@@ -972,9 +903,7 @@ async function windowLayerMapCommand(jsonFlag: boolean): Promise<void> {
     for (const [wid, layer] of entries) {
       console.log(`  wid:${wid} → ${layer}`);
     }
-  } catch {
-    console.log("Daemon not running. Start with: lattices app");
-  }
+  });
 }
 
 async function focusCommand(session?: string): Promise<void> {
@@ -982,175 +911,10 @@ async function focusCommand(session?: string): Promise<void> {
     console.log("Usage: lattices focus <session-name>");
     return;
   }
-  try {
-    const { daemonCall } = await getDaemonClient();
+  await withDaemon(async ({ daemonCall }) => {
     await daemonCall("window.focus", { session });
     console.log(`Focused: ${session}`);
-  } catch (e: unknown) {
-    console.log(`Error: ${(e as Error).message}`);
-  }
-}
-
-// ── Search ───────────────────────────────────────────────────────────
-
-interface SearchResult {
-  score: number;
-  window: any;
-  tabs: { tab: number; cwd: string; title: string; hasClaude: boolean; tmuxSession: string }[];
-  reasons: string[];
-}
-
-function relativeTime(iso: string): string {
-  const ms = Date.now() - new Date(iso).getTime();
-  const s = Math.floor(ms / 1000);
-  if (s < 60) return "just now";
-  const m = Math.floor(s / 60);
-  if (m < 60) return `${m}m ago`;
-  const h = Math.floor(m / 60);
-  if (h < 24) return `${h}h ago`;
-  const d = Math.floor(h / 24);
-  return `${d}d ago`;
-}
-
-// Unified search via lattices.search daemon API.
-// All search surfaces should go through this one function.
-interface SearchOptions {
-  sources?: string[];    // e.g. ["titles", "apps", "cwd", "ocr"] — omit for smart default
-  after?: string;        // ISO8601 — only windows interacted after this time
-  before?: string;       // ISO8601 — only windows interacted before this time
-  recency?: boolean;     // boost recently-focused windows (default true)
-  mode?: string;         // legacy compat: "quick", "complete", "terminal"
-}
-
-async function search(query: string, opts: SearchOptions = {}): Promise<SearchResult[]> {
-  const { daemonCall } = await getDaemonClient();
-  const params: Record<string, any> = { query };
-  if (opts.sources) params.sources = opts.sources;
-  if (opts.after) params.after = opts.after;
-  if (opts.before) params.before = opts.before;
-  if (opts.recency !== undefined) params.recency = opts.recency;
-  if (opts.mode) params.mode = opts.mode; // legacy fallback
-  const hits = await daemonCall("lattices.search", params, 10000) as any[];
-  return hits.map((w: any) => ({
-    score: w.score || 0,
-    window: w,
-    tabs: (w.terminalTabs || []).map((t: any) => ({
-      tab: t.tabIndex, cwd: t.cwd, title: t.tabTitle, hasClaude: t.hasClaude, tmuxSession: t.tmuxSession,
-    })),
-    reasons: w.matchSources || [],
-  }));
-}
-
-// Convenience aliases
-async function deepSearch(query: string): Promise<SearchResult[]> { return search(query, { sources: ["all"] }); }
-async function terminalSearch(query: string): Promise<SearchResult[]> { return search(query, { sources: ["terminals"] }); }
-
-// Format and print search results
-function printResults(ranked: SearchResult[]): void {
-  if (!ranked.length) return;
-  for (const r of ranked) {
-    const w = r.window;
-    const age = w.lastInteraction ? ` \x1b[2m${relativeTime(w.lastInteraction)}\x1b[0m` : "";
-    console.log(`  \x1b[1m${w.app}\x1b[0m  "${w.title}"  wid:${w.wid}  score:${r.score}  (${r.reasons.join(", ")})${age}`);
-    for (const t of r.tabs) {
-      const claude = t.hasClaude ? " \x1b[32m●\x1b[0m" : "";
-      const tmux = t.tmuxSession ? ` \x1b[36m[${t.tmuxSession}]\x1b[0m` : "";
-      console.log(`    tab ${t.tab}: ${t.cwd || t.title}${claude}${tmux}`);
-    }
-    if (w.ocrSnippet) console.log(`    ocr: "${w.ocrSnippet}"`);
-  }
-  console.log();
-}
-
-// ── search command ───────────────────────────────────────────────────
-
-async function searchCommand(query: string | undefined, flags: Set<string>, rawArgs: string[] = []): Promise<void> {
-  if (!query) {
-    console.log("Usage: lattices search <query> [--quick | --terminal | --all | --sources=... | --after=... | --before=... | --json | --wid]");
-    return;
-  }
-
-  // Build search options from flags
-  const opts: SearchOptions = {};
-
-  // Source selection: explicit --sources, or legacy --quick/--terminal, or default
-  const sourcesFlag = rawArgs.find(a => a.startsWith("--sources="));
-  if (sourcesFlag) {
-    opts.sources = sourcesFlag.slice("--sources=".length).split(",");
-  } else if (flags.has("--all")) {
-    opts.sources = ["all"];
-  } else if (flags.has("--quick")) {
-    opts.sources = ["titles", "apps", "sessions"];
-  } else if (flags.has("--terminal")) {
-    opts.sources = ["terminals"];
-  }
-  // else: omit → smart default on daemon side
-
-  // Time filters
-  const afterFlag = rawArgs.find(a => a.startsWith("--after="));
-  if (afterFlag) opts.after = afterFlag.slice("--after=".length);
-  const beforeFlag = rawArgs.find(a => a.startsWith("--before="));
-  if (beforeFlag) opts.before = beforeFlag.slice("--before=".length);
-
-  // No-recency flag
-  if (flags.has("--no-recency")) opts.recency = false;
-
-  const ranked = await search(query, opts);
-  const jsonOut = flags.has("--json");
-  const widOnly = flags.has("--wid");
-
-  if (jsonOut) {
-    console.log(JSON.stringify(ranked.map(r => ({
-      wid: r.window.wid, app: r.window.app, title: r.window.title,
-      score: r.score, reasons: r.reasons, tabs: r.tabs, ocrSnippet: r.window.ocrSnippet,
-    })), null, 2));
-    return;
-  }
-
-  if (widOnly) {
-    for (const r of ranked) console.log(r.window.wid);
-    return;
-  }
-
-  if (!ranked.length) {
-    console.log(`No results for "${query}"`);
-    return;
-  }
-
-  printResults(ranked);
-}
-
-// ── place command ────────────────────────────────────────────────────
-
-async function placeCommand(query?: string, tilePosition?: string): Promise<void> {
-  if (!query) {
-    console.log("Usage: lattices place <query> [position]");
-    return;
-  }
-  try {
-    const { daemonCall } = await getDaemonClient();
-    const ranked = await deepSearch(query);
-
-    if (!ranked.length) {
-      console.log(`No window matching "${query}"`);
-      return;
-    }
-
-    const pos = tilePosition || "bottom-right";
-    const win = ranked[0].window;
-    await daemonCall("window.focus", { wid: win.wid });
-    await daemonCall("intents.execute", {
-      intent: "tile_window",
-      slots: { position: pos, wid: win.wid }
-    }, 3000);
-    console.log(`${win.app} "${win.title}" (wid:${win.wid}) → ${pos}`);
-  } catch (e: unknown) {
-    console.log(`Error: ${(e as Error).message}`);
-  }
-}
-
-function pause(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
+  });
 }
 
 function receiptLine(receipt: any): string {
@@ -1164,90 +928,90 @@ function receiptLine(receipt: any): string {
 }
 
 async function placementSmokeCommand(rawArgs: string[] = []): Promise<void> {
-  const { daemonCall } = await getDaemonClient();
   const pauseMs = Number(parseFlagValue(rawArgs, "pause") || 1200);
   const positional = nonFlagArgs(rawArgs);
 
-  let sessions = positional.slice(0, 2);
-  if (sessions.length < 2) {
-    const tmuxSessions = await daemonCall("tmux.sessions") as any[];
-    sessions = tmuxSessions
-      .map(s => s?.name)
-      .filter((name: unknown): name is string => typeof name === "string" && name.startsWith("lattices-place-"))
-      .slice(0, 2);
-  }
-
-  if (sessions.length < 2) {
-    console.log("Need two named sessions. Usage: lattices dev placement-smoke <session-a> <session-b>");
-    console.log("Tip: launch two small lattices fixture projects first, then rerun this command.");
-    return;
-  }
-
-  const [a, b] = sessions;
-  console.log(`Placement smoke: ${a} + ${b}`);
+  await withDaemon(async ({ daemonCall }) => {
+    let sessions = positional.slice(0, 2);
+    if (sessions.length < 2) {
+      const tmuxSessions = await daemonCall("tmux.sessions") as any[];
+      sessions = tmuxSessions
+        .map(s => s?.name)
+        .filter((name: unknown): name is string => typeof name === "string" && name.startsWith("lattices-place-"))
+        .slice(0, 2);
+    }
 
-  for (const session of sessions) {
-    const resolved = await daemonCall("window.resolve", {
-      target: { kind: "session", session },
-      placement: "left",
-    }) as any;
-    console.log(`  resolve ${session}: wid=${resolved.wid ?? "?"} app=${resolved.app ?? "?"} resolution=${resolved.targetResolution ?? "?"}`);
-  }
+    if (sessions.length < 2) {
+      console.log("Need two named sessions. Usage: lattices dev placement-smoke <session-a> <session-b>");
+      console.log("Tip: launch two small lattices fixture projects first, then rerun this command.");
+      return;
+    }
 
-  const beats = [
-    {
-      label: "beat 1: halves",
-      actions: [
-        { id: "a-left-half", type: "window.place", target: { kind: "session", session: a }, args: { placement: "left" } },
-        { id: "b-right-half", type: "window.place", target: { kind: "session", session: b }, args: { placement: "right" } },
-      ],
-    },
-    {
-      label: "beat 2: 4x4 corners",
-      actions: [
-        { id: "a-top-left-4x4", type: "window.place", target: { kind: "session", session: a }, args: { placement: "grid:4x4:0,0" } },
-        { id: "b-bottom-right-4x4", type: "window.place", target: { kind: "session", session: b }, args: { placement: "grid:4x4:3,3" } },
-      ],
-    },
-    {
-      label: "beat 3: workbench",
-      actions: [
-        {
-          id: "a-workbench-left",
-          type: "window.place",
-          target: { kind: "session", session: a },
-          args: { placement: { kind: "fractions", x: 0.02, y: 0.05, w: 0.62, h: 0.9 } },
-        },
-        {
-          id: "b-console-right",
-          type: "window.place",
-          target: { kind: "session", session: b },
-          args: { placement: { kind: "fractions", x: 0.67, y: 0.12, w: 0.3, h: 0.76 } },
-        },
-      ],
-    },
-  ];
+    const [a, b] = sessions;
+    console.log(`Placement smoke: ${a} + ${b}`);
+
+    for (const session of sessions) {
+      const resolved = await daemonCall("window.resolve", {
+        target: { kind: "session", session },
+        placement: "left",
+      }) as any;
+      console.log(`  resolve ${session}: wid=${resolved.wid ?? "?"} app=${resolved.app ?? "?"} resolution=${resolved.targetResolution ?? "?"}`);
+    }
+
+    const beats = [
+      {
+        label: "beat 1: halves",
+        actions: [
+          { id: "a-left-half", type: "window.place", target: { kind: "session", session: a }, args: { placement: "left" } },
+          { id: "b-right-half", type: "window.place", target: { kind: "session", session: b }, args: { placement: "right" } },
+        ],
+      },
+      {
+        label: "beat 2: 4x4 corners",
+        actions: [
+          { id: "a-top-left-4x4", type: "window.place", target: { kind: "session", session: a }, args: { placement: "grid:4x4:0,0" } },
+          { id: "b-bottom-right-4x4", type: "window.place", target: { kind: "session", session: b }, args: { placement: "grid:4x4:3,3" } },
+        ],
+      },
+      {
+        label: "beat 3: workbench",
+        actions: [
+          {
+            id: "a-workbench-left",
+            type: "window.place",
+            target: { kind: "session", session: a },
+            args: { placement: { kind: "fractions", x: 0.02, y: 0.05, w: 0.62, h: 0.9 } },
+          },
+          {
+            id: "b-console-right",
+            type: "window.place",
+            target: { kind: "session", session: b },
+            args: { placement: { kind: "fractions", x: 0.67, y: 0.12, w: 0.3, h: 0.76 } },
+          },
+        ],
+      },
+    ];
 
-  for (const beat of beats) {
-    console.log(`\n${beat.label}`);
-    const result = await daemonCall("actions.execute", {
-      source: "placement-smoke",
-      actions: beat.actions,
-    }, 15000) as any;
-    console.log(`  batch=${result.status || "?"} request=${result.requestId || "?"}`);
-    for (const receipt of result.receipts || []) {
-      console.log(receiptLine(receipt));
+    for (const beat of beats) {
+      console.log(`\n${beat.label}`);
+      const result = await daemonCall("actions.execute", {
+        source: "placement-smoke",
+        actions: beat.actions,
+      }, 15000) as any;
+      console.log(`  batch=${result.status || "?"} request=${result.requestId || "?"}`);
+      for (const receipt of result.receipts || []) {
+        console.log(receiptLine(receipt));
+      }
+      await pause(pauseMs);
     }
-    await pause(pauseMs);
-  }
 
-  const focused = await daemonCall("window.focus", { session: a }, 5000) as any;
-  console.log(`\nfocus ${a}: ok=${focused.ok === true} wid=${focused.wid ?? "?"} raised=${focused.raised === true}`);
+    const focused = await daemonCall("window.focus", { session: a }, 5000) as any;
+    console.log(`\nfocus ${a}: ok=${focused.ok === true} wid=${focused.wid ?? "?"} raised=${focused.raised === true}`);
+  });
 }
 
 async function sessionsCommand(jsonFlag: boolean): Promise<void> {
-  try {
-    const { daemonCall } = await getDaemonClient();
+  await withDaemon(async ({ daemonCall }) => {
     const sessions = await daemonCall("tmux.sessions") as any[];
     if (jsonFlag) {
       console.log(JSON.stringify(sessions, null, 2));
@@ -1262,71 +1026,388 @@ async function sessionsCommand(jsonFlag: boolean): Promise<void> {
       const windows = s.windowCount || s.windows || "?";
       console.log(`  \x1b[1m${s.name}\x1b[0m  (${windows} windows)`);
     }
-  } catch {
-    console.log("Daemon not running. Start with: lattices app");
+  });
+}
+
+async function terminalsCommand(rawArgs: string[] = []): Promise<void> {
+  await withDaemon(async ({ daemonCall }) => {
+    const jsonFlag = hasFlag(rawArgs, "json");
+    const refresh = hasFlag(rawArgs, "refresh");
+    const terminals = await daemonCall("terminals.list", { refresh }, refresh ? 15000 : undefined) as any[];
+
+    if (jsonFlag) {
+      console.log(JSON.stringify(terminals, null, 2));
+      return;
+    }
+    if (!terminals.length) {
+      console.log("No terminal instances found.");
+      return;
+    }
+
+    console.log(`Terminals (${terminals.length}):\n`);
+    for (const terminal of terminals) {
+      const app = terminal.app || "terminal";
+      const wid = terminal.windowId ? ` wid=${terminal.windowId}` : "";
+      const cwd = terminal.cwd ? ` cwd=${terminal.cwd}` : "";
+      const session = terminal.tmuxSession ? ` session=${terminal.tmuxSession}` : "";
+      const claude = terminal.hasClaude ? " claude" : "";
+      console.log(`  ${app} ${terminal.tty}${wid}${session}${claude}`);
+      if (terminal.displayName) console.log(`    ${terminal.displayName}`);
+      if (cwd) console.log(`   ${cwd.trim()}`);
+    }
+  });
+}
+
+async function computerCommand(subcommand?: string, ...rawArgs: string[]): Promise<void> {
+  const sub = subcommand || "demo-terminal";
+  const jsonFlag = hasFlag(rawArgs, "json");
+  const aliases: Record<string, string> = {
+    "demo-terminal": "computer.demoTerminal",
+    "terminal-demo": "computer.demoTerminal",
+    "term-demo": "computer.demoTerminal",
+    "demo-scout": "computer.demoScout",
+    "scout-demo": "computer.demoScout",
+    "scout": "computer.demoScout",
+    "prepare": "computer.prepare",
+    "observe": "computer.prepare",
+    "stage": "computer.prepare",
+    "launch": "computer.launchApp",
+    "launch-app": "computer.launchApp",
+    "app": "computer.launchApp",
+    "focus": "computer.focusWindow",
+    "focus-window": "computer.focusWindow",
+    "click": "computer.click",
+    "mouse-click": "computer.click",
+    "cursor": "computer.showCursor",
+    "show-cursor": "computer.showCursor",
+    "mouse-cursor": "computer.showCursor",
+    "magic-cursor": "computer.magicCursor",
+    "ghost-cursor": "computer.magicCursor",
+    "move-cursor": "computer.magicCursor",
+    "magic-scout": "computer.magicCursor",
+    "scout-magic": "computer.magicCursor",
+    "type": "computer.typeText",
+    "type-text": "computer.typeText",
+    "typetext": "computer.typeText",
+    "type-window": "computer.typeWindowText",
+    "type-app": "computer.typeWindowText",
+    "app-type": "computer.typeWindowText",
+  };
+  const method = aliases[sub];
+
+  if (!method) {
+    console.log(`lattices computer — run bounded computer-use actions
+
+Usage:
+  lattices computer prepare [--json] [--text "hello"]
+  lattices computer focus-window [--json] [--wid id] [--app name]
+  lattices computer launch-app Scout [--json]
+  lattices computer type-window --app Scout --text "hello" [--x-ratio .5 --y-ratio .86] [--execute]
+  lattices computer click --app Scout --x-ratio .5 --y-ratio .86 --treatment execute
+  lattices computer click --app Scout --x-ratio .74 --y-ratio .95 --transport ax --ax-label Send --execute
+  lattices cua click --app Scout --x-ratio .74 --y-ratio .95 --transport ax --ax-label Send --execute
+  lattices computer magic-scout "draft text" --execute
+  lattices computer scout [message] [--treatment present|execute] [--send]
+  lattices computer cursor [--json] [--style marker] [--shape arrow] [--size tiny] [--trail thread]
+  lattices computer type-text --text "hello" [--json] [--enter]
+  lattices computer demo-terminal [--json] [--dry-run]
+  lattices computer demo-terminal --text "hello" [--wid id] [--tty tty] [--iterm-session-id id] [--app iTerm2]
+
+Common flags:
+  --treatment observe|stage|present|execute
+  --style spotlight|pulse|marker
+  --shape arrow|needle|petal|shard|chevron|facet|wedge|prism|notch|kite
+  --angle-deg -16..16
+  --size tiny|small|regular|large
+  --trail thread|ribbon|spark|comet|route|none
+  --motion glide|snap|float|rush|crawl|accelerate|teleport|spring|magnet|slingshot
+  --trajectory straight|soft|arc|swoop|overshoot
+  --glow none|soft|halo|comet
+  --idle still|breathe|wiggle|orbit|hover|nod|drift|shimmer|blink|tremble
+  --edge none|pulse|ripple|tick|reticle|blink|spark|underline|echo|scan|pin
+  --caption auto
+  --caption-title "Spring reticle" --caption-body "AX text follows the cursor"
+  --caption-tags "shape arrow,motion spring,edge reticle"
+  --caption-placement top-left|top-right|bottom-left|bottom-right|top-center|center|near-cursor
+  --caption-x-ratio 0.04 --caption-y-ratio 0.08
+  --caption-lead-ms 650 --caption-sound engage
+  --typewriter --type-interval-ms 18
+  --transport auto|tmux|iterm|pasteboard
+  --transport ax|pointer for app clicks
+  --ax-label Send --no-focus
+  --x-ratio 0..1 --y-ratio 0..1
+  --from-x-ratio 0..1 --from-y-ratio 0..1
+  --send
+  --no-capture
+`);
+    return;
   }
+
+  const params: Record<string, unknown> = { source: "cli" };
+  const magicScout = sub === "magic-scout" || sub === "scout-magic";
+  const positional = nonFlagArgs(rawArgs);
+  let text = parseFlagValue(rawArgs, "text");
+  const tty = parseFlagValue(rawArgs, "tty");
+  const app = parseFlagValue(rawArgs, "app");
+  const name = parseFlagValue(rawArgs, "name");
+  const bundleId = parseFlagValue(rawArgs, "bundleId") || parseFlagValue(rawArgs, "bundle-id") || parseFlagValue(rawArgs, "bundleIdentifier");
+  const path = parseFlagValue(rawArgs, "path") || parseFlagValue(rawArgs, "appPath") || parseFlagValue(rawArgs, "app-path");
+  const wid = parseFlagValue(rawArgs, "wid");
+  const terminalSessionId = parseFlagValue(rawArgs, "terminalSessionId")
+    || parseFlagValue(rawArgs, "terminal-session-id")
+    || parseFlagValue(rawArgs, "itermSessionId")
+    || parseFlagValue(rawArgs, "iterm-session-id");
+  const session = parseFlagValue(rawArgs, "session");
+  const title = parseFlagValue(rawArgs, "title");
+  const treatment = parseFlagValue(rawArgs, "treatment") || parseFlagValue(rawArgs, "mode") || parseFlagValue(rawArgs, "phase");
+  const transport = parseFlagValue(rawArgs, "transport");
+  const capture = parseFlagValue(rawArgs, "capture");
+  const x = parseFlagValue(rawArgs, "x");
+  const y = parseFlagValue(rawArgs, "y");
+  const fromX = parseFlagValue(rawArgs, "fromX") || parseFlagValue(rawArgs, "from-x") || parseFlagValue(rawArgs, "startX") || parseFlagValue(rawArgs, "start-x");
+  const fromY = parseFlagValue(rawArgs, "fromY") || parseFlagValue(rawArgs, "from-y") || parseFlagValue(rawArgs, "startY") || parseFlagValue(rawArgs, "start-y");
+  const xRatio = parseFlagValue(rawArgs, "xRatio") || parseFlagValue(rawArgs, "x-ratio") || parseFlagValue(rawArgs, "relativeX") || parseFlagValue(rawArgs, "relative-x") || parseFlagValue(rawArgs, "windowX") || parseFlagValue(rawArgs, "window-x");
+  const yRatio = parseFlagValue(rawArgs, "yRatio") || parseFlagValue(rawArgs, "y-ratio") || parseFlagValue(rawArgs, "relativeY") || parseFlagValue(rawArgs, "relative-y") || parseFlagValue(rawArgs, "windowY") || parseFlagValue(rawArgs, "window-y");
+  const fromXRatio = parseFlagValue(rawArgs, "fromXRatio") || parseFlagValue(rawArgs, "from-x-ratio") || parseFlagValue(rawArgs, "startXRatio") || parseFlagValue(rawArgs, "start-x-ratio");
+  const fromYRatio = parseFlagValue(rawArgs, "fromYRatio") || parseFlagValue(rawArgs, "from-y-ratio") || parseFlagValue(rawArgs, "startYRatio") || parseFlagValue(rawArgs, "start-y-ratio");
+  const button = parseFlagValue(rawArgs, "button");
+  const axLabel = parseFlagValue(rawArgs, "axLabel") || parseFlagValue(rawArgs, "ax-label") || parseFlagValue(rawArgs, "targetText") || parseFlagValue(rawArgs, "target-text");
+  const appearance = parseFlagValue(rawArgs, "appearance") || parseFlagValue(rawArgs, "style") || parseFlagValue(rawArgs, "cursor-style") || parseFlagValue(rawArgs, "cursorStyle");
+  const shape = parseFlagValue(rawArgs, "shape") || parseFlagValue(rawArgs, "marker-shape") || parseFlagValue(rawArgs, "markerShape") || parseFlagValue(rawArgs, "cursor-shape") || parseFlagValue(rawArgs, "cursorShape");
+  const angleDeg = parseFlagValue(rawArgs, "angleDeg") || parseFlagValue(rawArgs, "angle-deg") || parseFlagValue(rawArgs, "rotationDeg") || parseFlagValue(rawArgs, "rotation-deg") || parseFlagValue(rawArgs, "rotation") || parseFlagValue(rawArgs, "angle");
+  const size = parseFlagValue(rawArgs, "size") || parseFlagValue(rawArgs, "marker-size") || parseFlagValue(rawArgs, "markerSize") || parseFlagValue(rawArgs, "cursor-size") || parseFlagValue(rawArgs, "cursorSize");
+  const color = parseFlagValue(rawArgs, "color");
+  const durationMs = parseFlagValue(rawArgs, "durationMs") || parseFlagValue(rawArgs, "duration-ms");
+  const typeIntervalMs = parseFlagValue(rawArgs, "typeIntervalMs")
+    || parseFlagValue(rawArgs, "type-interval-ms")
+    || parseFlagValue(rawArgs, "typingIntervalMs")
+    || parseFlagValue(rawArgs, "typing-interval-ms");
+  const label = parseFlagValue(rawArgs, "label");
+  const caption = parseFlagValue(rawArgs, "caption")
+    || parseFlagValue(rawArgs, "treatmentLabel")
+    || parseFlagValue(rawArgs, "treatment-label")
+    || parseFlagValue(rawArgs, "variant");
+  const captionTitle = parseFlagValue(rawArgs, "captionTitle") || parseFlagValue(rawArgs, "caption-title");
+  const captionBody = parseFlagValue(rawArgs, "captionBody")
+    || parseFlagValue(rawArgs, "caption-body")
+    || parseFlagValue(rawArgs, "captionDetail")
+    || parseFlagValue(rawArgs, "caption-detail");
+  const captionTags = parseFlagValue(rawArgs, "captionTags") || parseFlagValue(rawArgs, "caption-tags");
+  const captionMode = parseFlagValue(rawArgs, "captionMode") || parseFlagValue(rawArgs, "caption-mode");
+  const captionEyebrow = parseFlagValue(rawArgs, "captionEyebrow") || parseFlagValue(rawArgs, "caption-eyebrow");
+  const captionLeadMs = parseFlagValue(rawArgs, "captionLeadMs") || parseFlagValue(rawArgs, "caption-lead-ms");
+  const captionSound = parseFlagValue(rawArgs, "captionSound") || parseFlagValue(rawArgs, "caption-sound");
+  const captionPlacement = parseFlagValue(rawArgs, "captionPlacement") || parseFlagValue(rawArgs, "caption-placement");
+  const captionMargin = parseFlagValue(rawArgs, "captionMargin") || parseFlagValue(rawArgs, "caption-margin");
+  const captionX = parseFlagValue(rawArgs, "captionX") || parseFlagValue(rawArgs, "caption-x");
+  const captionY = parseFlagValue(rawArgs, "captionY") || parseFlagValue(rawArgs, "caption-y");
+  const captionXRatio = parseFlagValue(rawArgs, "captionXRatio") || parseFlagValue(rawArgs, "caption-x-ratio") || parseFlagValue(rawArgs, "captionLeftRatio") || parseFlagValue(rawArgs, "caption-left-ratio");
+  const captionYRatio = parseFlagValue(rawArgs, "captionYRatio") || parseFlagValue(rawArgs, "caption-y-ratio") || parseFlagValue(rawArgs, "captionTopRatio") || parseFlagValue(rawArgs, "caption-top-ratio");
+  const sound = parseFlagValue(rawArgs, "sound") || parseFlagValue(rawArgs, "sfx");
+  const trail = parseFlagValue(rawArgs, "trail") || parseFlagValue(rawArgs, "effect");
+  const pathStyle = parseFlagValue(rawArgs, "pathStyle") || parseFlagValue(rawArgs, "path-style");
+  const motion = parseFlagValue(rawArgs, "motion") || parseFlagValue(rawArgs, "easing") || parseFlagValue(rawArgs, "velocity");
+  const trajectory = parseFlagValue(rawArgs, "trajectory") || parseFlagValue(rawArgs, "curve") || parseFlagValue(rawArgs, "arc");
+  const glow = parseFlagValue(rawArgs, "glow") || parseFlagValue(rawArgs, "bloom");
+  const idle = parseFlagValue(rawArgs, "idle") || parseFlagValue(rawArgs, "settle") || parseFlagValue(rawArgs, "presence");
+  const edge = parseFlagValue(rawArgs, "edge") || parseFlagValue(rawArgs, "edgeEffect") || parseFlagValue(rawArgs, "edge-effect") || parseFlagValue(rawArgs, "arrival");
+
+  if (!app && !name && method === "computer.launchApp" && positional[0]) {
+    params.app = positional[0];
+  }
+  if (magicScout && !app && !name) {
+    params.app = "Scout";
+  }
+  if (!text && (method === "computer.typeWindowText" || method === "computer.demoScout" || method === "computer.magicCursor")) {
+    const targetApp = String(params.app || app || name || "");
+    const messageOffset = targetApp && positional[0] === targetApp ? 1 : 0;
+    const positionalText = positional.slice(messageOffset).join(" ").trim();
+    if (positionalText) text = positionalText;
+  }
+  if (method === "computer.click" && !x && !y && positional.length >= 2) {
+    const px = Number(positional[0]);
+    const py = Number(positional[1]);
+    if (Number.isFinite(px) && Number.isFinite(py)) {
+      params.x = px;
+      params.y = py;
+    }
+  }
+
+  if (text) params.text = text;
+  if (tty) params.tty = tty;
+  if (app) params.app = app;
+  if (name) params.name = name;
+  if (bundleId) params.bundleId = bundleId;
+  if (path) params.path = path;
+  if (wid && Number.isFinite(Number(wid))) params.wid = Number(wid);
+  if (terminalSessionId) params.terminalSessionId = terminalSessionId;
+  if (session) params.session = session;
+  if (title) params.title = title;
+  if (treatment) params.treatment = treatment;
+  if (transport) params.transport = transport;
+  if (x && Number.isFinite(Number(x))) params.x = Number(x);
+  if (y && Number.isFinite(Number(y))) params.y = Number(y);
+  if (fromX && Number.isFinite(Number(fromX))) params.fromX = Number(fromX);
+  if (fromY && Number.isFinite(Number(fromY))) params.fromY = Number(fromY);
+  if (xRatio && Number.isFinite(Number(xRatio))) params.xRatio = Number(xRatio);
+  if (yRatio && Number.isFinite(Number(yRatio))) params.yRatio = Number(yRatio);
+  if (fromXRatio && Number.isFinite(Number(fromXRatio))) params.fromXRatio = Number(fromXRatio);
+  if (fromYRatio && Number.isFinite(Number(fromYRatio))) params.fromYRatio = Number(fromYRatio);
+  if (magicScout && params.xRatio === undefined) params.xRatio = 0.5;
+  if (magicScout && params.yRatio === undefined) params.yRatio = 0.86;
+  if (button) params.button = button;
+  if (axLabel) params.axLabel = axLabel;
+  if (appearance) params.appearance = appearance;
+  if (shape) params.shape = shape;
+  if (angleDeg && Number.isFinite(Number(angleDeg))) params.angleDeg = Number(angleDeg);
+  if (size) params.size = size;
+  if (color) params.color = color;
+  if (durationMs && Number.isFinite(Number(durationMs))) params.durationMs = Number(durationMs);
+  if (typeIntervalMs && Number.isFinite(Number(typeIntervalMs))) params.typeIntervalMs = Number(typeIntervalMs);
+  if (label) params.label = label;
+  if (caption) params.caption = caption;
+  if (captionTitle) params.captionTitle = captionTitle;
+  if (captionBody) params.captionBody = captionBody;
+  if (captionTags) params.captionTags = captionTags;
+  if (captionMode) params.captionMode = captionMode;
+  if (captionEyebrow) params.captionEyebrow = captionEyebrow;
+  if (captionLeadMs && Number.isFinite(Number(captionLeadMs))) params.captionLeadMs = Number(captionLeadMs);
+  if (captionSound) params.captionSound = captionSound;
+  if (captionPlacement) params.captionPlacement = captionPlacement;
+  if (captionMargin && Number.isFinite(Number(captionMargin))) params.captionMargin = Number(captionMargin);
+  if (captionX && Number.isFinite(Number(captionX))) params.captionX = Number(captionX);
+  if (captionY && Number.isFinite(Number(captionY))) params.captionY = Number(captionY);
+  if (captionXRatio && Number.isFinite(Number(captionXRatio))) params.captionXRatio = Number(captionXRatio);
+  if (captionYRatio && Number.isFinite(Number(captionYRatio))) params.captionYRatio = Number(captionYRatio);
+  if (sound) params.sound = sound;
+  if (trail) params.trail = trail;
+  if (pathStyle) params.pathStyle = pathStyle;
+  if (motion) params.motion = motion;
+  if (trajectory) params.trajectory = trajectory;
+  if (glow) params.glow = glow;
+  if (idle) params.idle = idle;
+  if (edge) params.edge = edge;
+  if (capture === "false" || capture === "0") params.capture = false;
+  if (hasFlag(rawArgs, "no-capture") || hasFlag(rawArgs, "noCapture")) params.capture = false;
+  if (hasFlag(rawArgs, "no-focus") || hasFlag(rawArgs, "noFocus") || hasFlag(rawArgs, "nofocus")) params.noFocus = true;
+  if (hasFlag(rawArgs, "dry-run") || hasFlag(rawArgs, "dryRun")) params.dryRun = true;
+  if (hasFlag(rawArgs, "enter")) params.enter = true;
+  if (hasFlag(rawArgs, "send")) params.send = true;
+  if (hasFlag(rawArgs, "append")) params.append = true;
+  if (hasFlag(rawArgs, "show-caption") || hasFlag(rawArgs, "showCaption")) params.showCaption = true;
+  if (hasFlag(rawArgs, "no-caption-selections") || hasFlag(rawArgs, "noCaptionSelections")) params.captionSelections = false;
+  if (hasFlag(rawArgs, "typewriter") || hasFlag(rawArgs, "typing")) params.typewriter = true;
+  if (hasFlag(rawArgs, "execute")) params.treatment = "execute";
+  if (hasFlag(rawArgs, "present")) params.treatment = "present";
+  if (hasFlag(rawArgs, "stage")) params.treatment = "stage";
+  if (hasFlag(rawArgs, "observe")) params.treatment = "observe";
+  if (hasFlag(rawArgs, "click")) params.click = true;
+
+  await withDaemon(async ({ daemonCall }) => {
+    let result: any;
+    if (method === "computer.click" || method === "computer.magicCursor") {
+      const cua = await import("./cua.ts");
+      result = method === "computer.click"
+        ? await cua.click(params as any)
+        : await cua.magicCursor(params as any);
+    } else {
+      result = await daemonCall(method, params, 30000) as any;
+    }
+    if (jsonFlag) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const selected = result.selected || {};
+    const terminal = selected.terminal || {};
+    const target = result.target || terminal;
+    const run = result.run || {};
+    console.log(`${result.action || sub} ${result.treatment ? `(${result.treatment})` : ""}`);
+    if (result.cursor) {
+      console.log("  target: cursor");
+    } else {
+      console.log(`  target: ${target.app || result.app || "terminal"} ${terminal.tty || ""}${target.windowId || target.wid ? ` wid:${target.windowId || target.wid}` : ""}`);
+    }
+	    if (result.cursor) console.log(`  cursor: (${Math.round(result.cursor.x)}, ${Math.round(result.cursor.y)})`);
+	    if (result.from) console.log(`  from: (${Math.round(result.from.x)}, ${Math.round(result.from.y)})`);
+	    console.log(`  run: ${run.id || "?"}`);
+    if (typeof result.launched === "boolean") console.log(`  launched: ${result.launched}`);
+    if (typeof result.focused === "boolean") console.log(`  focused: ${result.focused}`);
+    if (typeof result.clicked === "boolean") console.log(`  clicked: ${result.clicked}`);
+    if (typeof result.shown === "boolean") console.log(`  shown: ${result.shown}`);
+    if (result.button) console.log(`  button: ${result.button}`);
+    if (result.appearance?.style) console.log(`  appearance: ${result.appearance.style}${result.appearance.color ? ` ${result.appearance.color}` : ""}${result.appearance.shape ? ` shape:${result.appearance.shape}` : ""}${result.appearance.angleDeg !== undefined ? ` angle:${result.appearance.angleDeg}` : ""}${result.appearance.size ? ` size:${result.appearance.size}` : ""}`);
+    if (result.typedText !== undefined) console.log(`  typed: ${result.dryRun ? "dry run" : JSON.stringify(result.typedText || "")}`);
+    if (result.transport) console.log(`  transport: ${result.transport}`);
+    if (result.beforeArtifact?.path) console.log(`  before: ${result.beforeArtifact.path}`);
+    if (result.afterArtifact?.path) console.log(`  after: ${result.afterArtifact.path}`);
+  });
 }
 
 async function voiceCommand(subcommand?: string, ...rest: string[]): Promise<void> {
-  const { daemonCall } = await getDaemonClient();
-  try {
+  if (subcommand !== "status" && subcommand !== "simulate" && subcommand !== "sim" && subcommand !== "intents") {
+    console.log("Usage: lattices voice <subcommand>\n");
+    console.log("  status      Show voice provider status");
+    console.log("  simulate    Parse and execute a voice command");
+    console.log("  intents     List all available intents");
+    console.log("\nExamples:");
+    console.log('  lattices voice simulate "tile this left"');
+    console.log('  lattices voice simulate "focus chrome" --dry-run');
+    return;
+  }
+
+  if (subcommand === "simulate" || subcommand === "sim") {
+    const text = rest.join(" ");
+    if (!text) {
+      console.log("Usage: lattices voice simulate <text>");
+      return;
+    }
+  }
+
+  await withDaemon(async ({ daemonCall }) => {
     switch (subcommand) {
-      case "status": {
-        const status = await daemonCall("voice.status") as any;
-        console.log(`Provider: ${status.provider}`);
-        console.log(`Available: ${status.available}`);
-        console.log(`Listening: ${status.listening}`);
-        if (status.lastTranscript) console.log(`Last: "${status.lastTranscript}"`);
-        break;
+    case "status": {
+      const status = await daemonCall("voice.status") as any;
+      console.log(`Provider: ${status.provider}`);
+      console.log(`Available: ${status.available}`);
+      console.log(`Listening: ${status.listening}`);
+      if (status.lastTranscript) console.log(`Last: "${status.lastTranscript}"`);
+      break;
+    }
+    case "simulate":
+    case "sim": {
+      const text = rest.join(" ");
+      const execute = !rest.includes("--dry-run");
+      const dryFlag = rest.includes("--dry-run");
+      const cleanText = dryFlag ? rest.filter(r => r !== "--dry-run").join(" ") : text;
+      const result = await daemonCall("voice.simulate", { text: cleanText, execute }, 15000) as any;
+      if (!result.parsed) {
+        console.log(`\x1b[33mNo match:\x1b[0m "${cleanText}"`);
+        return;
       }
-      case "simulate":
-      case "sim": {
-        const text = rest.join(" ");
-        if (!text) {
-          console.log("Usage: lattices voice simulate <text>");
-          return;
-        }
-        const execute = !rest.includes("--dry-run");
-        const dryFlag = rest.includes("--dry-run");
-        const cleanText = dryFlag ? rest.filter(r => r !== "--dry-run").join(" ") : text;
-        const result = await daemonCall("voice.simulate", { text: cleanText, execute }, 15000) as any;
-        if (!result.parsed) {
-          console.log(`\x1b[33mNo match:\x1b[0m "${cleanText}"`);
-          return;
-        }
-        const slots = Object.entries(result.slots || {}).map(([k,v]) => `${k}: ${v}`).join(", ");
-        const conf = result.confidence ? ` (${(result.confidence * 100).toFixed(0)}%)` : "";
-        console.log(`\x1b[36m${result.intent}\x1b[0m${slots ? `  ${slots}` : ""}${conf}`);
-        if (result.executed) {
-          console.log(`\x1b[32mExecuted\x1b[0m`);
-        } else if (result.error) {
-          console.log(`\x1b[31mError:\x1b[0m ${result.error}`);
-        }
-        break;
+      const slots = Object.entries(result.slots || {}).map(([k,v]) => `${k}: ${v}`).join(", ");
+      const conf = result.confidence ? ` (${(result.confidence * 100).toFixed(0)}%)` : "";
+      console.log(`\x1b[36m${result.intent}\x1b[0m${slots ? `  ${slots}` : ""}${conf}`);
+      if (result.executed) {
+        console.log(`\x1b[32mExecuted\x1b[0m`);
+      } else if (result.error) {
+        console.log(`\x1b[31mError:\x1b[0m ${result.error}`);
       }
-      case "intents": {
-        const intents = await daemonCall("intents.list") as any[];
-        for (const intent of intents) {
-          const slots = intent.slots.map((s: any) => `${s.name}:${s.type}${s.required ? "*" : ""}`).join(", ");
-          console.log(`  \x1b[1m${intent.intent}\x1b[0m  ${intent.description}`);
-          if (slots) console.log(`    slots: ${slots}`);
-          console.log(`    e.g. "${intent.examples[0]}"`);
-          console.log();
-        }
-        break;
+      break;
+    }
+    case "intents": {
+      const intents = await daemonCall("intents.list") as any[];
+      for (const intent of intents) {
+        const slots = intent.slots.map((s: any) => `${s.name}:${s.type}${s.required ? "*" : ""}`).join(", ");
+        console.log(`  \x1b[1m${intent.intent}\x1b[0m  ${intent.description}`);
+        if (slots) console.log(`    slots: ${slots}`);
+        console.log(`    e.g. "${intent.examples[0]}"`);
+        console.log();
       }
-      default:
-        console.log("Usage: lattices voice <subcommand>\n");
-        console.log("  status      Show voice provider status");
-        console.log("  simulate    Parse and execute a voice command");
-        console.log("  intents     List all available intents");
-        console.log("\nExamples:");
-        console.log('  lattices voice simulate "tile this left"');
-        console.log('  lattices voice simulate "focus chrome" --dry-run');
+      break;
     }
-  } catch (e: unknown) {
-    console.log(`Error: ${(e as Error).message}`);
-  }
+    }
+  });
 }
 
 async function assistantCommand(subcommand?: string, ...rest: string[]): Promise<void> {
@@ -1366,14 +1447,11 @@ async function callCommand(method?: string, ...rest: string[]): Promise<void> {
     console.log('  lattices call window.place \'{"session":"vox","placement":"left"}\'');
     return;
   }
-  try {
-    const { daemonCall } = await getDaemonClient();
+  await withDaemon(async ({ daemonCall }) => {
     const params = rest[0] ? JSON.parse(rest[0]) : null;
     const result = await daemonCall(method, params, 15000);
     console.log(JSON.stringify(result, null, 2));
-  } catch (e: unknown) {
-    console.log(`Error: ${(e as Error).message}`);
-  }
+  });
 }
 
 interface AppActorAsset {
@@ -1566,40 +1644,42 @@ async function actorHUDCommand(rest: string[]): Promise<void> {
     return;
   }
 
-  const { daemonCall } = await getDaemonClient();
   const url = positional[1];
   const clear = hasFlag(rest, "clear");
-  const result = await daemonCall("overlay.actor.hud", {
-    id,
-    clear,
-    ...(url && !clear ? { hudUrl: url } : {}),
-    ...actorHUDOptions(rest),
-  }, 15000) as any;
+  await withDaemon(async ({ daemonCall }) => {
+    const result = await daemonCall("overlay.actor.hud", {
+      id,
+      clear,
+      ...(url && !clear ? { hudUrl: url } : {}),
+      ...actorHUDOptions(rest),
+    }, 15000) as any;
 
-  if (hasFlag(rest, "json")) {
-    console.log(JSON.stringify(result, null, 2));
-  } else if (clear) {
-    console.log(`Cleared HUD for ${id}.`);
-  } else {
-    console.log(`Attached hover HUD to ${id}.`);
-  }
+    if (hasFlag(rest, "json")) {
+      console.log(JSON.stringify(result, null, 2));
+    } else if (clear) {
+      console.log(`Cleared HUD for ${id}.`);
+    } else {
+      console.log(`Attached hover HUD to ${id}.`);
+    }
+  });
 }
 
 async function actorVisibilityCommand(action: string, rest: string[]): Promise<void> {
-  const { daemonCall } = await getDaemonClient();
-  const result = await daemonCall("overlay.actor.visibility", {
-    action,
-    feedback: !hasFlag(rest, "quiet") && action !== "status",
-  }, 15000) as any;
+  await withDaemon(async ({ daemonCall }) => {
+    const result = await daemonCall("overlay.actor.visibility", {
+      action,
+      feedback: !hasFlag(rest, "quiet") && action !== "status",
+    }, 15000) as any;
 
-  if (hasFlag(rest, "json")) {
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
+    if (hasFlag(rest, "json")) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
 
-  const state = result.visible ? "shown" : "hidden";
-  const count = Number(result.actorCount ?? 0);
-  console.log(`Actor layer ${state} (${count} actor${count === 1 ? "" : "s"}).`);
+    const state = result.visible ? "shown" : "hidden";
+    const count = Number(result.actorCount ?? 0);
+    console.log(`Actor layer ${state} (${count} actor${count === 1 ? "" : "s"}).`);
+  });
 }
 
 async function actorAppCommand(rest: string[]): Promise<void> {
@@ -1610,86 +1690,28 @@ async function actorAppCommand(rest: string[]): Promise<void> {
     return;
   }
   const message = positional.slice(1).join(" ") || `Tap to switch to ${appQuery}.`;
-  const asset = ensureAppActorAsset(appQuery);
-  const { daemonCall } = await getDaemonClient();
-  const id = parseFlagValue(rest, "id") || `app-${slugify(asset.appName)}`;
-  const state = parseFlagValue(rest, "state") || "idle";
-  const ttlMs = Number(parseFlagValue(rest, "ttl") || parseFlagValue(rest, "ttlMs") || 0);
-  const x = Number(parseFlagValue(rest, "x") || 520);
-  const y = Number(parseFlagValue(rest, "y") || 340);
-  const placement = parseFlagValue(rest, "placement") || "point";
-  const style = parseFlagValue(rest, "style") || "playful";
-  const dismissible = hasFlag(rest, "dismissible");
-  const labelHidden = shouldHideActorLabel(rest);
-  const closeOnActivate = hasFlag(rest, "close-on-activate") || hasFlag(rest, "closeOnActivate");
-  const scale = Number(parseFlagValue(rest, "scale") || 1);
-
-  const result = await daemonCall("overlay.actor.publish", {
-    id,
-    renderer: "sprite",
-    asset: asset.id,
-    state,
-    name: parseFlagValue(rest, "name") || asset.appName,
-    message,
-    placement,
-    x,
-    y,
-    style,
-    ttlMs,
-    dismissible,
-    labelHidden,
-    closeOnActivate,
-    scale,
-    ...actorHUDOptions(rest),
-    targetApp: asset.appName,
-    targetBundleId: asset.bundleIdentifier,
-    targetAppPath: asset.appPath,
-  }, 15000) as any;
-
-  if (!hasFlag(rest, "no-move")) {
-    await daemonCall("overlay.actor.moveTo", {
-      id,
-      x: x + 40,
-      y: y + 50,
-      durationMs: 700,
-      easing: "spring",
-    }, 15000);
-  }
+  await withDaemon(async ({ daemonCall }) => {
+    const asset = ensureAppActorAsset(appQuery);
+    const id = parseFlagValue(rest, "id") || `app-${slugify(asset.appName)}`;
+    const state = parseFlagValue(rest, "state") || "idle";
+    const ttlMs = Number(parseFlagValue(rest, "ttl") || parseFlagValue(rest, "ttlMs") || 0);
+    const x = Number(parseFlagValue(rest, "x") || 520);
+    const y = Number(parseFlagValue(rest, "y") || 340);
+    const placement = parseFlagValue(rest, "placement") || "point";
+    const style = parseFlagValue(rest, "style") || "playful";
+    const dismissible = hasFlag(rest, "dismissible");
+    const labelHidden = shouldHideActorLabel(rest);
+    const closeOnActivate = hasFlag(rest, "close-on-activate") || hasFlag(rest, "closeOnActivate");
+    const scale = Number(parseFlagValue(rest, "scale") || 1);
 
-  if (hasFlag(rest, "json")) {
-    console.log(JSON.stringify({ ...result, asset: asset.id, appPath: asset.appPath }, null, 2));
-  } else {
-    console.log(`Published ${asset.appName} actor (${id}). Click it to switch to ${asset.appName}.`);
-  }
-}
-
-async function actorSwitcherCommand(rest: string[]): Promise<void> {
-  const appNames = nonFlagArgs(rest);
-  const apps = appNames.length ? appNames : ["Codex", "Talkie"];
-  const { daemonCall } = await getDaemonClient();
-  const startX = Number(parseFlagValue(rest, "x") || 420);
-  const y = Number(parseFlagValue(rest, "y") || 220);
-  const gap = Number(parseFlagValue(rest, "gap") || 270);
-  const ttlMs = Number(parseFlagValue(rest, "ttl") || parseFlagValue(rest, "ttlMs") || 0);
-  const style = parseFlagValue(rest, "style") || "info";
-  const dismissible = hasFlag(rest, "dismissible");
-  const labelHidden = shouldHideActorLabel(rest);
-  const closeOnActivate = hasFlag(rest, "close-on-activate") || hasFlag(rest, "closeOnActivate");
-  const scale = Number(parseFlagValue(rest, "scale") || 1);
-  const results: any[] = [];
-
-  for (let i = 0; i < apps.length; i++) {
-    const asset = ensureAppActorAsset(apps[i]);
-    const id = `switch-${slugify(asset.appName)}`;
-    const x = startX + i * gap;
     const result = await daemonCall("overlay.actor.publish", {
       id,
       renderer: "sprite",
       asset: asset.id,
-      state: "ready",
-      name: asset.appName,
-      message: `Tap to switch to ${asset.appName}.`,
-      placement: "point",
+      state,
+      name: parseFlagValue(rest, "name") || asset.appName,
+      message,
+      placement,
       x,
       y,
       style,
@@ -1703,21 +1725,81 @@ async function actorSwitcherCommand(rest: string[]): Promise<void> {
       targetBundleId: asset.bundleIdentifier,
       targetAppPath: asset.appPath,
     }, 15000) as any;
-    results.push({ ...result, asset: asset.id, appPath: asset.appPath });
-    await daemonCall("overlay.actor.moveTo", {
-      id,
-      x: x + 28,
-      y: y + 36,
-      durationMs: 650,
-      easing: "spring",
-    }, 15000);
-  }
 
-  if (hasFlag(rest, "json")) {
-    console.log(JSON.stringify(results, null, 2));
-  } else {
-    console.log(`Published app switcher for ${apps.join(", ")}.`);
-  }
+    if (!hasFlag(rest, "no-move")) {
+      await daemonCall("overlay.actor.moveTo", {
+        id,
+        x: x + 40,
+        y: y + 50,
+        durationMs: 700,
+        easing: "spring",
+      }, 15000);
+    }
+
+    if (hasFlag(rest, "json")) {
+      console.log(JSON.stringify({ ...result, asset: asset.id, appPath: asset.appPath }, null, 2));
+    } else {
+      console.log(`Published ${asset.appName} actor (${id}). Click it to switch to ${asset.appName}.`);
+    }
+  });
+}
+
+async function actorSwitcherCommand(rest: string[]): Promise<void> {
+  const appNames = nonFlagArgs(rest);
+  const apps = appNames.length ? appNames : ["Codex", "Talkie"];
+  await withDaemon(async ({ daemonCall }) => {
+    const startX = Number(parseFlagValue(rest, "x") || 420);
+    const y = Number(parseFlagValue(rest, "y") || 220);
+    const gap = Number(parseFlagValue(rest, "gap") || 270);
+    const ttlMs = Number(parseFlagValue(rest, "ttl") || parseFlagValue(rest, "ttlMs") || 0);
+    const style = parseFlagValue(rest, "style") || "info";
+    const dismissible = hasFlag(rest, "dismissible");
+    const labelHidden = shouldHideActorLabel(rest);
+    const closeOnActivate = hasFlag(rest, "close-on-activate") || hasFlag(rest, "closeOnActivate");
+    const scale = Number(parseFlagValue(rest, "scale") || 1);
+    const results: any[] = [];
+
+    for (let i = 0; i < apps.length; i++) {
+      const asset = ensureAppActorAsset(apps[i]);
+      const id = `switch-${slugify(asset.appName)}`;
+      const x = startX + i * gap;
+      const result = await daemonCall("overlay.actor.publish", {
+        id,
+        renderer: "sprite",
+        asset: asset.id,
+        state: "ready",
+        name: asset.appName,
+        message: `Tap to switch to ${asset.appName}.`,
+        placement: "point",
+        x,
+        y,
+        style,
+        ttlMs,
+        dismissible,
+        labelHidden,
+        closeOnActivate,
+        scale,
+        ...actorHUDOptions(rest),
+        targetApp: asset.appName,
+        targetBundleId: asset.bundleIdentifier,
+        targetAppPath: asset.appPath,
+      }, 15000) as any;
+      results.push({ ...result, asset: asset.id, appPath: asset.appPath });
+      await daemonCall("overlay.actor.moveTo", {
+        id,
+        x: x + 28,
+        y: y + 36,
+        durationMs: 650,
+        easing: "spring",
+      }, 15000);
+    }
+
+    if (hasFlag(rest, "json")) {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      console.log(`Published app switcher for ${apps.join(", ")}.`);
+    }
+  });
 }
 
 type HUDPathField = string | {
@@ -2022,20 +2104,21 @@ function upsertHUDRegistryEntry(resolved: ResolvedHUDManifest, published = false
 }
 
 async function publishHUDManifest(resolved: ResolvedHUDManifest, rest: string[], index = 0): Promise<Record<string, unknown>> {
-  const { daemonCall } = await getDaemonClient();
-  const payload = hudPublishPayload(resolved, rest, index);
-  const result = await daemonCall("overlay.actor.publish", payload, 15000) as Record<string, unknown>;
-  if (!hasFlag(rest, "no-move")) {
-    await daemonCall("overlay.actor.moveTo", {
-      id: resolved.id,
-      x: Number(payload.x) + 24,
-      y: Number(payload.y) + 30,
-      durationMs: 600,
-      easing: "spring",
-    }, 15000);
-  }
-  upsertHUDRegistryEntry(resolved, true);
-  return result;
+  return withDaemon(async ({ daemonCall }) => {
+    const payload = hudPublishPayload(resolved, rest, index);
+    const result = await daemonCall("overlay.actor.publish", payload, 15000) as Record<string, unknown>;
+    if (!hasFlag(rest, "no-move")) {
+      await daemonCall("overlay.actor.moveTo", {
+        id: resolved.id,
+        x: Number(payload.x) + 24,
+        y: Number(payload.y) + 30,
+        durationMs: 600,
+        easing: "spring",
+      }, 15000);
+    }
+    upsertHUDRegistryEntry(resolved, true);
+    return result;
+  });
 }
 
 async function hudRegisterCommand(rest: string[]): Promise<void> {
@@ -2157,190 +2240,8 @@ async function hudCommand(sub?: string, ...rest: string[]): Promise<void> {
   }
 }
 
-async function layerCommand(sub?: string, ...rest: string[]): Promise<void> {
-  try {
-    const { daemonCall } = await getDaemonClient();
-
-    // ── Subcommands ──
-    if (sub === "create") {
-      await layerCreateCommand(rest);
-      return;
-    }
-    if (sub === "snap") {
-      await layerSnapCommand(rest[0]);
-      return;
-    }
-    if (sub === "session" || sub === "sessions") {
-      await layerSessionCommand(rest[0]);
-      return;
-    }
-    if (sub === "clear") {
-      await daemonCall("session.layers.clear");
-      console.log("Cleared all session layers.");
-      return;
-    }
-    if (sub === "delete" || sub === "rm") {
-      if (!rest[0]) { console.log("Usage: lattices layer delete <name>"); return; }
-      await daemonCall("session.layers.delete", { name: rest[0] });
-      console.log(`Deleted session layer "${rest[0]}".`);
-      return;
-    }
-
-    // ── List or switch (original behavior) ──
-    if (sub === undefined || sub === null || sub === "") {
-      const result = await daemonCall("layers.list") as any;
-      if (!result.layers.length) {
-        console.log("No layers configured.");
-        return;
-      }
-      console.log("Layers:\n");
-      for (const layer of result.layers) {
-        const active = layer.index === result.active ? " \x1b[32m● active\x1b[0m" : "";
-        console.log(`  [${layer.index}] ${layer.label}  (${layer.projectCount} projects)${active}`);
-      }
-      return;
-    }
-    const idx = parseInt(sub, 10);
-    if (!isNaN(idx)) {
-      await daemonCall("layer.activate", { index: idx, mode: "launch" });
-      console.log(`Activated layer ${idx}`);
-    } else {
-      await daemonCall("layer.activate", { name: sub, mode: "launch" });
-      console.log(`Activated layer "${sub}"`);
-    }
-  } catch (e: unknown) {
-    console.log(`Error: ${(e as Error).message}`);
-  }
-}
-
-// ── Layer create: build a session layer from window specs ────────────
-// Usage: lattices layer create <name> [wid:123 wid:456 ...]
-//        lattices layer create <name> --json '[{"app":"Chrome","tile":"left"},...]'
-async function layerCreateCommand(args: string[]): Promise<void> {
-  const { daemonCall } = await getDaemonClient();
-  const name = args[0];
-  if (!name) {
-    console.log("Usage: lattices layer create <name> [wid:123 ...] [--json '<specs>']");
-    return;
-  }
-
-  const jsonIdx = args.indexOf("--json");
-  if (jsonIdx !== -1 && args[jsonIdx + 1]) {
-    // JSON mode: parse window specs with tile positions
-    const specs = JSON.parse(args[jsonIdx + 1]) as Array<{
-      wid?: number; app?: string; title?: string; tile?: string;
-    }>;
-
-    // Collect wids, resolve app-based specs
-    const windowIds: number[] = [];
-    const windows: Array<{ app: string; contentHint?: string }> = [];
-    const tiles: Array<{ wid?: number; app?: string; title?: string; tile: string }> = [];
-
-    for (const spec of specs) {
-      if (spec.wid) {
-        windowIds.push(spec.wid);
-        if (spec.tile) tiles.push({ wid: spec.wid, tile: spec.tile });
-      } else if (spec.app) {
-        windows.push({ app: spec.app, contentHint: spec.title });
-        if (spec.tile) tiles.push({ app: spec.app, title: spec.title, tile: spec.tile });
-      }
-    }
-
-    const result = await daemonCall("session.layers.create", {
-      name,
-      ...(windowIds.length ? { windowIds } : {}),
-      ...(windows.length ? { windows } : {}),
-    }) as any;
-
-    console.log(`Created session layer "${name}" with ${specs.length} window(s).`);
-
-    // Apply tile positions
-    for (const t of tiles) {
-      try {
-        await daemonCall("window.place", {
-          ...(t.wid ? { wid: t.wid } : { app: t.app, title: t.title }),
-          placement: t.tile,
-        });
-      } catch { /* window may not be resolved yet */ }
-    }
-
-    if (tiles.length) console.log(`Tiled ${tiles.length} window(s).`);
-    return;
-  }
-
-  // Simple wid mode: lattices layer create <name> wid:123 wid:456
-  const wids = args.slice(1)
-    .filter(a => a.startsWith("wid:"))
-    .map(a => parseInt(a.slice(4), 10))
-    .filter(n => !isNaN(n));
-
-  const result = await daemonCall("session.layers.create", {
-    name,
-    ...(wids.length ? { windowIds: wids } : {}),
-  }) as any;
-
-  console.log(`Created session layer "${name}"${wids.length ? ` with ${wids.length} window(s)` : ""}.`);
-}
-
-// ── Layer snap: snapshot current visible windows into a session layer ─
-async function layerSnapCommand(name?: string): Promise<void> {
-  const { daemonCall } = await getDaemonClient();
-  const layerName = name || `snap-${new Date().toISOString().slice(11, 19).replace(/:/g, "")}`;
-
-  // Get all current windows
-  const windows = await daemonCall("windows.list") as any[];
-  const visibleWids = windows
-    .filter((w: any) => !w.isMinimized && w.app !== "lattices")
-    .map((w: any) => w.wid);
-
-  if (!visibleWids.length) {
-    console.log("No visible windows to snapshot.");
-    return;
-  }
-
-  await daemonCall("session.layers.create", {
-    name: layerName,
-    windowIds: visibleWids,
-  });
-
-  console.log(`Snapped ${visibleWids.length} window(s) → session layer "${layerName}".`);
-}
-
-// ── Layer session: list or switch session layers ─────────────────────
-async function layerSessionCommand(nameOrIndex?: string): Promise<void> {
-  const { daemonCall } = await getDaemonClient();
-  const result = await daemonCall("session.layers.list") as any;
-
-  if (!nameOrIndex) {
-    // List session layers
-    if (!result.layers.length) {
-      console.log("No session layers. Create one with: lattices layer create <name>");
-      return;
-    }
-    console.log("Session layers:\n");
-    for (let i = 0; i < result.layers.length; i++) {
-      const l = result.layers[i];
-      const active = i === result.activeIndex ? " \x1b[32m● active\x1b[0m" : "";
-      const winCount = l.windows?.length || 0;
-      console.log(`  [${i}] ${l.name}  (${winCount} windows)${active}`);
-    }
-    return;
-  }
-
-  // Switch by index or name
-  const idx = parseInt(nameOrIndex, 10);
-  if (!isNaN(idx)) {
-    await daemonCall("session.layers.switch", { index: idx });
-    console.log(`Switched to session layer ${idx}.`);
-  } else {
-    await daemonCall("session.layers.switch", { name: nameOrIndex });
-    console.log(`Switched to session layer "${nameOrIndex}".`);
-  }
-}
-
 async function diagCommand(limit?: string): Promise<void> {
-  try {
-    const { daemonCall } = await getDaemonClient();
+  await withDaemon(async ({ daemonCall }) => {
     const result = await daemonCall("diagnostics.list", { limit: parseInt(limit || "", 10) || 40 }) as any;
     if (!result.entries || !result.entries.length) {
       console.log("No diagnostic entries.");
@@ -2352,9 +2253,7 @@ async function diagCommand(limit?: string): Promise<void> {
                    entry.level === "error"   ? "\x1b[31m✗\x1b[0m" : "›";
       console.log(`  \x1b[90m${entry.time}\x1b[0m ${icon} ${entry.message}`);
     }
-  } catch (e: unknown) {
-    console.log(`Error: ${(e as Error).message}`);
-  }
+  });
 }
 
 async function distributeCommand(rawArgs: string[] = []): Promise<void> {
@@ -2373,7 +2272,7 @@ async function daemonLsCommand(): Promise<boolean> {
     if (!(await isDaemonRunning())) return false;
     const sessions = await daemonCall("tmux.sessions") as any[];
     if (!sessions.length) {
-      console.log("No active tmux sessions.");
+      console.log("No active sessions.");
       return true;
     }
 
@@ -2474,12 +2373,10 @@ async function daemonStatusInventory(): Promise<boolean> {
 // ── OCR commands ──────────────────────────────────────────────────────
 
 async function scanCommand(sub?: string, ...rest: string[]): Promise<void> {
-  const { daemonCall } = await getDaemonClient();
-
   if (!sub || sub === "snapshot" || sub === "ls" || sub === "--full" || sub === "-f" || sub === "--json") {
     const full = sub === "--full" || sub === "-f" || rest.includes("--full") || rest.includes("-f");
     const json = sub === "--json" || rest.includes("--json");
-    try {
+    await withDaemon(async ({ daemonCall }) => {
       const results = await daemonCall("ocr.snapshot", null, 5000) as any[];
       if (!results.length) {
         console.log("No scan results yet. The first scan runs ~60s after launch.");
@@ -2517,9 +2414,7 @@ async function scanCommand(sub?: string, ...rest: string[]): Promise<void> {
         }
         console.log();
       }
-    } catch {
-      console.log("Daemon not running. Start with: lattices app");
-    }
+    });
     return;
   }
 
@@ -2529,7 +2424,7 @@ async function scanCommand(sub?: string, ...rest: string[]): Promise<void> {
       console.log("Usage: lattices scan search <query>");
       return;
     }
-    try {
+    await withDaemon(async ({ daemonCall }) => {
       const results = await daemonCall("ocr.search", { query }, 5000) as any[];
       if (!results.length) {
         console.log(`No matches for "${query}".`);
@@ -2544,9 +2439,7 @@ async function scanCommand(sub?: string, ...rest: string[]): Promise<void> {
         console.log(`    ${snippet}`);
         console.log();
       }
-    } catch (e: unknown) {
-      console.log(`Error: ${(e as Error).message}`);
-    }
+    });
     return;
   }
 
@@ -2554,7 +2447,7 @@ async function scanCommand(sub?: string, ...rest: string[]): Promise<void> {
     const full = rest.includes("--full") || rest.includes("-f");
     const numArg = rest.find(a => !a.startsWith("-"));
     const limit = parseInt(numArg || "", 10) || 20;
-    try {
+    await withDaemon(async ({ daemonCall }) => {
       const results = await daemonCall("ocr.recent", { limit }, 5000) as any[];
       if (!results.length) {
         console.log("No history yet. The first scan runs ~60s after launch.");
@@ -2583,20 +2476,16 @@ async function scanCommand(sub?: string, ...rest: string[]): Promise<void> {
         }
         console.log();
       }
-    } catch {
-      console.log("Daemon not running. Start with: lattices app");
-    }
+    });
     return;
   }
 
   if (sub === "deep" || sub === "now" || sub === "scan") {
-    try {
+    await withDaemon(async ({ daemonCall }) => {
       console.log("Triggering deep scan (Vision OCR)...");
       await daemonCall("ocr.scan", null, 30000);
       console.log("Done.");
-    } catch (e: unknown) {
-      console.log(`Error: ${(e as Error).message}`);
-    }
+    });
     return;
   }
 
@@ -2606,7 +2495,7 @@ async function scanCommand(sub?: string, ...rest: string[]): Promise<void> {
       console.log("Usage: lattices scan history <wid>");
       return;
     }
-    try {
+    await withDaemon(async ({ daemonCall }) => {
       const results = await daemonCall("ocr.history", { wid }, 5000) as any[];
       if (!results.length) {
         console.log(`No history for wid:${wid}.`);
@@ -2624,9 +2513,7 @@ async function scanCommand(sub?: string, ...rest: string[]): Promise<void> {
         }
         console.log();
       }
-    } catch (e: unknown) {
-      console.log(`Error: ${(e as Error).message}`);
-    }
+    });
     return;
   }
 
@@ -2645,14 +2532,13 @@ Usage:
 }
 
 function printUsage(): void {
-  console.log(`lattices — workspace launcher for tmux, windows, layers, and the menu bar app
+  console.log(`lattices — workspace launcher for sessions, windows, layers, and the menu bar app
 
 Usage:
   lattices                    Show workspace status and common commands
-  lattices start              Start or reattach the current directory's tmux workspace
-  lattices tmux               Alias for lattices start
+  lattices start              Start or reattach the current directory's workspace
   lattices init               Generate .lattices.json config for this project
-  lattices ls                 List active tmux sessions
+  lattices ls                 List active sessions
   lattices status             Show managed vs unmanaged session inventory
   lattices kill [name]        Kill a session (defaults to current project)
   lattices sync               Reconcile session to match declared config
@@ -2667,7 +2553,25 @@ Usage:
   lattices place <query> [pos]  Deep search + focus + tile (default: bottom-right)
   lattices focus <session>    Raise a session's window
   lattices windows [--json]   List all desktop windows (daemon required)
-  lattices sessions [--json]  List active tmux sessions via daemon
+  lattices sessions [--json]  List active sessions via daemon
+  lattices terminals [--json] [--refresh]
+                         List synthesized terminal instances
+  lattices capture window [wid]  Save a screenshot run artifact
+  lattices capture record window [wid]  Record a window/visible region as a .mov artifact
+  lattices capture record-command --app Scout -- <cmd>
+                         Record a target while running an action command
+  lattices capture stop <run-id> Stop a running capture recording
+  lattices runs [id] [--json] List recent runs or inspect one run
+  lattices computer prepare      Resolve/stage a safe terminal action
+  lattices computer focus-window Focus and verify a target window
+  lattices computer launch-app  Launch/focus a normal macOS app
+  lattices computer type-window Type into a normal app window
+  lattices computer click       Stage or post a window-relative click
+  lattices cua click            CLI alias for the CUA SDK click action
+  lattices computer scout       Scout warm-up run for memo/demo recording
+  lattices computer cursor       Show a recorded cursor appearance
+  lattices computer type-text    Type text into a safe terminal target
+  lattices computer demo-terminal  Record/focus/type a safe terminal demo
   lattices tile <position>    Tile the frontmost window (left, right, top, etc.)
   lattices tile family [app] [region]  Smart-grid the frontmost app family, or a named app
   lattices distribute [app] [region]   Smart-grid visible windows or just one app (daemon required)
@@ -2770,11 +2674,11 @@ Workspace:
   session   ${sessionName}
   config    ${config ? ".lattices.json" : "none yet"}
   panes     ${panes.map((p) => p.name || "pane").join(", ")}
-  tmux      ${tmuxReady ? (sessionRunning ? "running" : "ready") : "missing"}
+  sessions  ${tmuxReady ? (sessionRunning ? "running" : "ready") : "missing"}
   app       ${appRunning ? "running" : "not running"}
 
 Common commands:
-  lattices start        Start or reattach this directory's tmux workspace
+  lattices start        Start or reattach this directory's workspace
   lattices init         Create a .lattices.json for this project
   lattices app          Launch the menu bar app
   lattices ls           List active sessions
@@ -2811,7 +2715,7 @@ function listSessions(): void {
     "tmux list-sessions -F '#{session_name}  (#{session_windows} windows, created #{session_created_string})'"
   );
   if (!out) {
-    console.log("No active tmux sessions.");
+    console.log("No active sessions.");
     return;
   }
 
@@ -2914,7 +2818,7 @@ interface SpaceOptimizeRequest {
 function isPlacementToken(value?: string): boolean {
   if (!value) return false;
   const normalized = value.toLowerCase();
-  return normalized in tilePresets || /^grid:\d+x\d+:\d+,\d+$/i.test(normalized);
+  return normalized in tilePresets || /^(?:grid:)?\d+x\d+:\d+,\d+(?:-\d+,\d+)?$/i.test(normalized);
 }
 
 function parseSpaceOptimizeArgs(rawArgs: string[], defaultScope: SpaceOptimizeScope): SpaceOptimizeRequest {
@@ -2939,8 +2843,7 @@ async function optimizeWindowsCommand(
   request: SpaceOptimizeRequest,
   successVerb: string
 ): Promise<void> {
-  try {
-    const { daemonCall } = await getDaemonClient();
+  await withDaemon(async ({ daemonCall }) => {
     const params: Record<string, unknown> = {
       scope: request.scope,
       strategy: "balanced",
@@ -2961,20 +2864,59 @@ async function optimizeWindowsCommand(
     console.log(
       `${successVerb} ${count} window${count === 1 ? "" : "s"} for ${target}${regionSuffix}.`
     );
-  } catch {
-    console.log("Daemon not running. Start with: lattices app");
+  });
+}
+
+function gridTileBounds(position: string, screen: ScreenBounds): number[] | null {
+  const match = position.toLowerCase().match(/^(grid:)?(\d+)x(\d+):(\d+),(\d+)(?:-(\d+),(\d+))?$/);
+  if (!match) return null;
+
+  const oneBased = !match[1];
+  const columns = Number(match[2]);
+  const rows = Number(match[3]);
+  let c0 = Number(match[4]);
+  let r0 = Number(match[5]);
+  let c1 = match[6] === undefined ? c0 : Number(match[6]);
+  let r1 = match[7] === undefined ? r0 : Number(match[7]);
+  if (oneBased) {
+    c0 -= 1;
+    r0 -= 1;
+    c1 -= 1;
+    r1 -= 1;
+  }
+  const leftCell = Math.min(c0, c1);
+  const rightCell = Math.max(c0, c1);
+  const topCell = Math.min(r0, r1);
+  const bottomCell = Math.max(r0, r1);
+
+  if (
+    columns <= 0 || rows <= 0 ||
+    leftCell < 0 || topCell < 0 ||
+    rightCell >= columns || bottomCell >= rows
+  ) {
+    return null;
   }
+
+  const cellW = screen.w / columns;
+  const cellH = screen.h / rows;
+  return [
+    screen.x + leftCell * cellW,
+    screen.y + topCell * cellH,
+    screen.x + (rightCell + 1) * cellW,
+    screen.y + (bottomCell + 1) * cellH,
+  ];
 }
 
 function tileWindow(position: string): void {
-  const preset = tilePresets[position];
-  if (!preset) {
+  const normalized = position.toLowerCase();
+  const screen = getScreenBounds();
+  const bounds = tilePresets[normalized]?.(screen) ?? gridTileBounds(normalized, screen);
+  if (!bounds) {
     console.log(`Unknown position: ${position}`);
-    console.log(`Available: ${Object.keys(tilePresets).filter(k => !k.includes("-half") && k !== "max").join(", ")}`);
+    console.log(`Available: ${Object.keys(tilePresets).filter(k => !k.includes("-half") && k !== "max").join(", ")}, grid:CxR:c,r (0-based), CxR:c,r (1-based)`);
     return;
   }
-  const screen = getScreenBounds();
-  const [x1, y1, x2, y2] = preset(screen).map(Math.round);
+  const [x1, y1, x2, y2] = bounds.map(Math.round);
   const script = `
     tell application "System Events"
       set frontApp to name of first application process whose frontmost is true
@@ -2983,7 +2925,7 @@ function tileWindow(position: string): void {
       set bounds of front window to {${x1}, ${y1}, ${x2}, ${y2}}
     end tell`;
   runQuiet(`osascript -e '${esc(script)}'`);
-  console.log(`Tiled → ${position}`);
+  console.log(`Tiled → ${normalized}`);
 }
 
 function createOrAttach(): void {
@@ -3023,7 +2965,7 @@ function statusInventory(): void {
     'tmux list-sessions -F "#{session_name}\t#{session_windows}\t#{session_attached}"'
   );
   if (!sessionsRaw) {
-    console.log("No active tmux sessions.");
+    console.log("No active sessions.");
     return;
   }
 
@@ -3212,7 +3154,7 @@ switch (command) {
     break;
   case "search":
   case "s":
-    await searchCommand(args[1], new Set(args.slice(2)));
+    await searchCommand(args[1], new Set(args.slice(2)), args.slice(2));
     break;
   case "focus":
     await focusCommand(args[1]);
@@ -3223,6 +3165,24 @@ switch (command) {
   case "sessions":
     await sessionsCommand(args[1] === "--json");
     break;
+  case "terminals":
+    await terminalsCommand(args.slice(1));
+    break;
+  case "capture":
+    await captureCommand(args[1], ...args.slice(2));
+    break;
+  case "runs":
+    await runsCommand(args.slice(1));
+    break;
+  case "run":
+    await runsCommand(args.slice(1));
+    break;
+  case "computer":
+    await computerCommand(args[1], ...args.slice(2));
+    break;
+  case "cua":
+    await computerCommand(args[1], ...args.slice(2));
+    break;
   case "voice":
     await voiceCommand(args[1], ...args.slice(2));
     break;