@lattices/cli 0.3.0 → 0.4.1

package/bin/{lattices.js → lattices.ts}

@@ -1,32 +1,37 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 import { createHash } from "node:crypto";
 import { execSync } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, resolve, dirname } from "node:path";
+import { basename, resolve } from "node:path";
 import { homedir } from "node:os";
-import { fileURLToPath } from "node:url";
 
 // Daemon client (lazy-loaded to avoid blocking startup for TTY commands)
-let _daemonClient;
-async function getDaemonClient() {
+let _daemonClient: typeof import("./daemon-client.ts") | undefined;
+async function getDaemonClient(): Promise<typeof import("./daemon-client.ts")> {
   if (!_daemonClient) {
-    const __dirname = dirname(fileURLToPath(import.meta.url));
-    _daemonClient = await import(resolve(__dirname, "daemon-client.js"));
+    _daemonClient = await import("./daemon-client.ts");
   }
   return _daemonClient;
 }
 
-const args = process.argv.slice(2);
-const command = args[0];
+const args: string[] = process.argv.slice(2);
+const command: string | undefined = args[0];
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
-function run(cmd, opts = {}) {
-  return execSync(cmd, { encoding: "utf8", ...opts }).trim();
+interface ExecOpts {
+  encoding?: string;
+  stdio?: string | string[];
+  cwd?: string;
+  [key: string]: any;
 }
 
-function runQuiet(cmd) {
+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 {
@@ -34,77 +39,117 @@ function runQuiet(cmd) {
   }
 }
 
-function hasTmux() {
+function hasTmux(): boolean {
   return runQuiet("which tmux") !== null;
 }
 
-function isInsideTmux() {
+/** Commands that require tmux to be installed */
+const tmuxRequiredCommands = new Set([
+  "init", "ls", "list", "kill", "rm", "sync", "reconcile",
+  "restart", "respawn", "group", "groups", "tab", "status",
+  "inventory", "distribute", "sessions",
+]);
+
+function requireTmux(command: string | undefined): void {
+  if (hasTmux()) return;
+
+  const isImplicitCreate = command && !tmuxRequiredCommands.has(command)
+    && !["search", "s", "focus", "place", "tile", "t", "windows", "window",
+         "voice", "call", "layer", "layers", "diag", "diagnostics", "scan",
+         "ocr", "daemon", "dev", "app", "mouse", "help", "-h", "--help"].includes(command);
+
+  if (command && !tmuxRequiredCommands.has(command) && !isImplicitCreate) return;
+
+  console.error(`
+\x1b[1;31m✘ tmux not found\x1b[0m
+
+Lattices uses tmux for terminal session management.
+Install it with Homebrew:
+
+    \x1b[1mbrew install tmux\x1b[0m
+
+If tmux is installed somewhere else, make sure it's on your PATH:
+
+    \x1b[90mexport PATH="/path/to/tmux/bin:$PATH"\x1b[0m
+
+Then run this command again.
+`.trim());
+  process.exit(1);
+}
+
+function isInsideTmux(): boolean {
   return !!process.env.TMUX;
 }
 
-function sessionExists(name) {
+function sessionExists(name: string): boolean {
   return runQuiet(`tmux has-session -t "${name}" 2>&1`) !== null;
 }
 
-function pathHash(dir) {
+function pathHash(dir: string): string {
   return createHash("sha256").update(resolve(dir)).digest("hex").slice(0, 6);
 }
 
-function toSessionName(dir) {
+function toSessionName(dir: string): string {
   const base = basename(dir).replace(/[^a-zA-Z0-9_-]/g, "-");
   return `${base}-${pathHash(dir)}`;
 }
 
-function esc(str) {
+function esc(str: string): string {
   return str.replace(/'/g, "'\\''");
 }
 
 // ── Config ───────────────────────────────────────────────────────────
 
-function readConfig(dir) {
+function readConfig(dir: string): any | null {
   const configPath = resolve(dir, ".lattices.json");
   if (!existsSync(configPath)) return null;
   try {
     const raw = readFileSync(configPath, "utf8");
     return JSON.parse(raw);
-  } catch (e) {
-    console.warn(`Warning: invalid .lattices.json — ${e.message}`);
+  } catch (e: unknown) {
+    console.warn(`Warning: invalid .lattices.json — ${(e as Error).message}`);
     return null;
   }
 }
 
 // ── Workspace config (tab groups) ───────────────────────────────────
 
-function readWorkspaceConfig() {
+function readWorkspaceConfig(): any | null {
   const configPath = resolve(homedir(), ".lattices", "workspace.json");
   if (!existsSync(configPath)) return null;
   try {
     const raw = readFileSync(configPath, "utf8");
     return JSON.parse(raw);
-  } catch (e) {
-    console.warn(`Warning: invalid workspace.json — ${e.message}`);
+  } catch (e: unknown) {
+    console.warn(`Warning: invalid workspace.json — ${(e as Error).message}`);
     return null;
   }
 }
 
-function toGroupSessionName(groupId) {
+function toGroupSessionName(groupId: string): string {
   return `lattices-group-${groupId}`;
 }
 
 /** Get ordered pane IDs for a specific window within a session */
-function getPaneIdsForWindow(sessionName, windowIndex) {
+function getPaneIdsForWindow(sessionName: string, windowIndex: number): string[] {
   const out = runQuiet(
     `tmux list-panes -t "${sessionName}:${windowIndex}" -F "#{pane_id}"`
   );
   return out ? out.split("\n").filter(Boolean) : [];
 }
 
+interface PaneConfig {
+  name?: string;
+  cmd?: string;
+  size?: number;
+}
+
 /** Create a tmux window with pane layout for a project dir */
-function createWindowForProject(sessionName, windowIndex, dir, label) {
+function createWindowForProject(sessionName: string, windowIndex: number, dir: string, label?: string): void {
   const config = readConfig(dir);
   const d = esc(dir);
 
-  let panes;
+  let panes: PaneConfig[];
   if (config?.panes?.length) {
     panes = resolvePane(config.panes, dir);
   } else {
@@ -141,7 +186,7 @@ function createWindowForProject(sessionName, windowIndex, dir, label) {
   const paneIds = getPaneIdsForWindow(sessionName, windowIndex);
   for (let i = 0; i < panes.length && i < paneIds.length; i++) {
     if (panes[i].cmd) {
-      run(`tmux send-keys -t "${paneIds[i]}" '${esc(panes[i].cmd)}' Enter`);
+      run(`tmux send-keys -t "${paneIds[i]}" '${esc(panes[i].cmd!)}' Enter`);
     }
     if (panes[i].name) {
       runQuiet(`tmux select-pane -t "${paneIds[i]}" -T "${panes[i].name}"`);
@@ -154,8 +199,19 @@ function createWindowForProject(sessionName, windowIndex, dir, label) {
   }
 }
 
+interface TabConfig {
+  path: string;
+  label?: string;
+}
+
+interface GroupConfig {
+  id: string;
+  label?: string;
+  tabs?: TabConfig[];
+}
+
 /** Create a group session with one tmux window per tab */
-function createGroupSession(group) {
+function createGroupSession(group: GroupConfig): string | null {
   const name = toGroupSessionName(group.id);
   const tabs = group.tabs || [];
 
@@ -194,7 +250,7 @@ function createGroupSession(group) {
   return name;
 }
 
-function listGroups() {
+function listGroups(): void {
   const ws = readWorkspaceConfig();
   if (!ws?.groups?.length) {
     console.log("No tab groups configured in ~/.lattices/workspace.json");
@@ -204,12 +260,12 @@ function listGroups() {
   console.log("Tab Groups:\n");
   for (const group of ws.groups) {
     const tabs = group.tabs || [];
-    const runningCount = tabs.filter((t) => sessionExists(toSessionName(resolve(t.path)))).length;
+    const runningCount = tabs.filter((t: TabConfig) => sessionExists(toSessionName(resolve(t.path)))).length;
     const running = runningCount > 0;
     const status = running
       ? `\x1b[32m● ${runningCount}/${tabs.length} running\x1b[0m`
       : "\x1b[90m○ stopped\x1b[0m";
-    const tabLabels = tabs.map((t) => t.label || basename(t.path)).join(", ");
+    const tabLabels = tabs.map((t: TabConfig) => t.label || basename(t.path)).join(", ");
     console.log(`  ${group.label || group.id}  ${status}`);
     console.log(`    id: ${group.id}`);
     console.log(`    tabs: ${tabLabels}`);
@@ -217,7 +273,7 @@ function listGroups() {
   }
 }
 
-function groupCommand(id) {
+function groupCommand(id?: string): void {
   const ws = readWorkspaceConfig();
   if (!ws?.groups?.length) {
     console.log("No tab groups configured in ~/.lattices/workspace.json");
@@ -229,9 +285,9 @@ function groupCommand(id) {
     return;
   }
 
-  const group = ws.groups.find((g) => g.id === id);
+  const group = ws.groups.find((g: GroupConfig) => g.id === id);
   if (!group) {
-    console.log(`No group "${id}". Available: ${ws.groups.map((g) => g.id).join(", ")}`);
+    console.log(`No group "${id}". Available: ${ws.groups.map((g: GroupConfig) => g.id).join(", ")}`);
     return;
   }
 
@@ -267,7 +323,7 @@ function groupCommand(id) {
   attach(firstName);
 }
 
-function tabCommand(groupId, tabName) {
+function tabCommand(groupId?: string, tabName?: string): void {
   if (!groupId) {
     console.log("Usage: lattices tab <group-id> <tab-name|index>");
     return;
@@ -279,13 +335,13 @@ function tabCommand(groupId, tabName) {
     return;
   }
 
-  const group = ws.groups.find((g) => g.id === groupId);
+  const group = ws.groups.find((g: GroupConfig) => g.id === groupId);
   if (!group) {
     console.log(`No group "${groupId}".`);
     return;
   }
 
-  const tabs = group.tabs || [];
+  const tabs: TabConfig[] = group.tabs || [];
 
   if (!tabName) {
     // List tabs with their session status
@@ -301,7 +357,7 @@ function tabCommand(groupId, tabName) {
   }
 
   // Resolve tab target to an index
-  let tabIdx;
+  let tabIdx: number;
   if (/^\d+$/.test(tabName)) {
     tabIdx = parseInt(tabName, 10);
   } else {
@@ -337,7 +393,7 @@ function tabCommand(groupId, tabName) {
 
 // ── Detect dev command ───────────────────────────────────────────────
 
-function detectPackageManager(dir) {
+function detectPackageManager(dir: string): string {
   if (existsSync(resolve(dir, "pnpm-lock.yaml"))) return "pnpm";
   if (existsSync(resolve(dir, "bun.lockb")) || existsSync(resolve(dir, "bun.lock")))
     return "bun";
@@ -345,11 +401,11 @@ function detectPackageManager(dir) {
   return "npm";
 }
 
-function detectDevCommand(dir) {
+function detectDevCommand(dir: string): string | null {
   const pkgPath = resolve(dir, "package.json");
   if (!existsSync(pkgPath)) return null;
 
-  let pkg;
+  let pkg: any;
   try {
     pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
   } catch {
@@ -358,19 +414,19 @@ function detectDevCommand(dir) {
 
   const scripts = pkg.scripts || {};
   const pm = detectPackageManager(dir);
-  const run = pm === "npm" ? "npm run" : pm;
+  const runCmd = pm === "npm" ? "npm run" : pm;
 
-  if (scripts.dev) return `${run} dev`;
-  if (scripts.start) return `${run} start`;
-  if (scripts.serve) return `${run} serve`;
-  if (scripts.watch) return `${run} watch`;
+  if (scripts.dev) return `${runCmd} dev`;
+  if (scripts.start) return `${runCmd} start`;
+  if (scripts.serve) return `${runCmd} serve`;
+  if (scripts.watch) return `${runCmd} watch`;
   return null;
 }
 
 // ── Session creation ─────────────────────────────────────────────────
 
-function resolvePane(panes, dir) {
-  return panes.map((p) => ({
+function resolvePane(panes: any[], dir: string): PaneConfig[] {
+  return panes.map((p: any) => ({
     name: p.name || "",
     cmd: p.cmd || undefined,
     size: p.size || undefined,
@@ -378,19 +434,19 @@ function resolvePane(panes, dir) {
 }
 
 /** Get ordered pane IDs (e.g. ["%0", "%1"]) for a session */
-function getPaneIds(name) {
+function getPaneIds(name: string): string[] {
   const out = runQuiet(
     `tmux list-panes -t "${name}" -F "#{pane_id}"`
   );
   return out ? out.split("\n").filter(Boolean) : [];
 }
 
-function createSession(dir) {
+function createSession(dir: string): string {
   const name = toSessionName(dir);
   const config = readConfig(dir);
   const d = esc(dir);
 
-  let panes;
+  let panes: PaneConfig[];
   if (config?.panes?.length) {
     panes = resolvePane(config.panes, dir);
     console.log(`Using .lattices.json (${panes.length} panes)`);
@@ -425,7 +481,7 @@ function createSession(dir) {
   // Send commands and name each pane
   for (let i = 0; i < panes.length && i < paneIds.length; i++) {
     if (panes[i].cmd) {
-      run(`tmux send-keys -t "${paneIds[i]}" '${esc(panes[i].cmd)}' Enter`);
+      run(`tmux send-keys -t "${paneIds[i]}" '${esc(panes[i].cmd!)}' Enter`);
     }
     if (panes[i].name) {
       runQuiet(`tmux select-pane -t "${paneIds[i]}" -T "${panes[i].name}"`);
@@ -449,9 +505,9 @@ function createSession(dir) {
 /** Check each pane and prefill or restart commands that have exited.
  *  mode: "prefill" types the command without pressing Enter
  *  mode: "ensure" types the command and presses Enter */
-function restoreCommands(name, dir, mode) {
+function restoreCommands(name: string, dir: string, mode: "prefill" | "ensure"): void {
   const config = readConfig(dir);
-  let panes;
+  let panes: PaneConfig[];
   if (config?.panes?.length) {
     panes = resolvePane(config.panes, dir);
   } else {
@@ -469,9 +525,9 @@ function restoreCommands(name, dir, mode) {
     );
     if (cur && shells.has(cur)) {
       if (mode === "ensure") {
-        run(`tmux send-keys -t "${paneIds[i]}" '${esc(panes[i].cmd)}' Enter`);
+        run(`tmux send-keys -t "${paneIds[i]}" '${esc(panes[i].cmd!)}' Enter`);
       } else {
-        run(`tmux send-keys -t "${paneIds[i]}" '${esc(panes[i].cmd)}'`);
+        run(`tmux send-keys -t "${paneIds[i]}" '${esc(panes[i].cmd!)}'`);
       }
       count++;
     }
@@ -484,7 +540,7 @@ function restoreCommands(name, dir, mode) {
 
 // ── Sync / reconcile ────────────────────────────────────────────────
 
-function resolvePanes(dir) {
+function resolvePanes(dir: string): PaneConfig[] {
   const config = readConfig(dir);
   if (config?.panes?.length) {
     return resolvePane(config.panes, dir);
@@ -492,7 +548,117 @@ function resolvePanes(dir) {
   return defaultPanes(dir);
 }
 
-function defaultPanes(dir) {
+// ── Dev command ──────────────────────────────────────────────────────
+
+function detectProjectType(dir: string): string | null {
+  // Check for lattices-style hybrid project (Swift app + Node CLI)
+  if (existsSync(resolve(dir, "app/Package.swift")) && existsSync(resolve(dir, "bin/lattices-app.ts")))
+    return "lattices-app";
+  if (existsSync(resolve(dir, "Package.swift"))) return "swift";
+  if (existsSync(resolve(dir, "Cargo.toml"))) return "rust";
+  if (existsSync(resolve(dir, "go.mod"))) return "go";
+  if (existsSync(resolve(dir, "package.json"))) return "node";
+  if (existsSync(resolve(dir, "Makefile"))) return "make";
+  return null;
+}
+
+async function devCommand(sub?: string, ...flags: string[]): Promise<void> {
+  const dir = process.cwd();
+  const type = detectProjectType(dir);
+
+  // Helper to forward to lattices-app.ts
+  async function forwardToAppScript(cmd: string, extraFlags: string[] = []): Promise<void> {
+    const appScript = resolve(import.meta.dir, "lattices-app.ts");
+    const { execFileSync } = await import("node:child_process");
+    try {
+      execFileSync("bun", [appScript, cmd, ...extraFlags], { stdio: "inherit" });
+    } catch { /* exit code forwarded */ }
+  }
+
+  if (!sub) {
+    // bare `lattices dev` — run dev server
+    if (!type) {
+      console.log("No recognized project in current directory.");
+      return;
+    }
+    console.log(`Detected: ${type} project`);
+    if (type === "lattices-app") {
+      await forwardToAppScript("restart", flags);
+    } else if (type === "node") {
+      const cmd = detectDevCommand(dir);
+      if (cmd) {
+        console.log(`Running: ${cmd}`);
+        execSync(cmd, { cwd: dir, stdio: "inherit" });
+      } else {
+        console.log("No dev script found in package.json.");
+      }
+    } else if (type === "swift") {
+      console.log("Running: swift run");
+      execSync("swift run", { cwd: dir, stdio: "inherit" });
+    } else if (type === "rust") {
+      console.log("Running: cargo run");
+      execSync("cargo run", { cwd: dir, stdio: "inherit" });
+    } else if (type === "go") {
+      console.log("Running: go run .");
+      execSync("go run .", { cwd: dir, stdio: "inherit" });
+    } else if (type === "make") {
+      execSync("make", { cwd: dir, stdio: "inherit" });
+    }
+    return;
+  }
+
+  if (sub === "build") {
+    if (!type) {
+      console.log("No recognized project in current directory.");
+      return;
+    }
+    if (type === "lattices-app") {
+      await forwardToAppScript("build");
+    } else if (type === "swift") {
+      console.log("Building: swift build -c release");
+      execSync("swift build -c release", { cwd: dir, stdio: "inherit" });
+    } else if (type === "node") {
+      const pm = detectPackageManager(dir);
+      const runCmd = pm === "npm" ? "npm run" : pm;
+      const pkg = JSON.parse(readFileSync(resolve(dir, "package.json"), "utf8"));
+      if (pkg.scripts?.build) {
+        console.log(`Running: ${runCmd} build`);
+        execSync(`${runCmd} build`, { cwd: dir, stdio: "inherit" });
+      } else {
+        console.log("No build script found in package.json.");
+      }
+    } else if (type === "rust") {
+      console.log("Building: cargo build --release");
+      execSync("cargo build --release", { cwd: dir, stdio: "inherit" });
+    } else if (type === "go") {
+      console.log("Building: go build .");
+      execSync("go build .", { cwd: dir, stdio: "inherit" });
+    } else if (type === "make") {
+      execSync("make", { cwd: dir, stdio: "inherit" });
+    }
+    return;
+  }
+
+  if (sub === "restart") {
+    if (type === "lattices-app") {
+      await forwardToAppScript("restart", flags);
+    } else {
+      // For other project types, just rebuild
+      await devCommand("build");
+    }
+    return;
+  }
+
+  if (sub === "type") {
+    console.log(type || "unknown");
+    return;
+  }
+
+  console.log(`Unknown dev subcommand: ${sub}`);
+  console.log("Usage: lattices dev [build|restart|type]");
+}
+
+function defaultPanes(dir: string): PaneConfig[] {
   const devCmd = detectDevCommand(dir);
   if (devCmd) {
     return [
@@ -504,7 +670,7 @@ function defaultPanes(dir) {
   return [{ name: "claude", cmd: "claude" }];
 }
 
-function syncSession() {
+function syncSession(): void {
   const dir = process.cwd();
   const name = toSessionName(dir);
 
@@ -564,7 +730,7 @@ function syncSession() {
         `tmux display-message -t "${freshIds[i]}" -p "#{pane_current_command}"`
       );
       if (cur && shells.has(cur)) {
-        run(`tmux send-keys -t "${freshIds[i]}" '${esc(panes[i].cmd)}' Enter`);
+        run(`tmux send-keys -t "${freshIds[i]}" '${esc(panes[i].cmd!)}' Enter`);
         restored++;
       }
     }
@@ -583,7 +749,7 @@ function syncSession() {
 
 // ── Restart pane ────────────────────────────────────────────────────
 
-function restartPane(target) {
+function restartPane(target?: string): void {
   const dir = process.cwd();
   const name = toSessionName(dir);
 
@@ -596,7 +762,7 @@ function restartPane(target) {
   const paneIds = getPaneIds(name);
 
   // Resolve target to an index
-  let idx;
+  let idx: number;
   if (target === undefined || target === null || target === "") {
     // Default: first pane (claude)
     idx = 0;
@@ -665,10 +831,22 @@ function restartPane(target) {
 
 // ── Daemon-aware commands ────────────────────────────────────────────
 
-async function daemonStatusCommand() {
+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})`);
+  }
+}
+
+async function daemonStatusCommand(): Promise<void> {
   try {
     const { daemonCall } = await getDaemonClient();
-    const status = await daemonCall("daemon.status");
+    const status = await daemonCall("daemon.status") as any;
     const uptime = Math.round(status.uptime);
     const h = Math.floor(uptime / 3600);
     const m = Math.floor((uptime % 3600) / 60);
@@ -685,10 +863,10 @@ async function daemonStatusCommand() {
   }
 }
 
-async function windowsCommand(jsonFlag) {
+async function windowsCommand(jsonFlag: boolean): Promise<void> {
   try {
     const { daemonCall } = await getDaemonClient();
-    const windows = await daemonCall("windows.list");
+    const windows = await daemonCall("windows.list") as any[];
     if (jsonFlag) {
       console.log(JSON.stringify(windows, null, 2));
       return;
@@ -712,7 +890,7 @@ async function windowsCommand(jsonFlag) {
   }
 }
 
-async function windowAssignCommand(wid, layerId) {
+async function windowAssignCommand(wid?: string, layerId?: string): Promise<void> {
   if (!wid || !layerId) {
     console.log("Usage: lattices window assign <wid> <layer-id>");
     return;
@@ -721,15 +899,15 @@ async function windowAssignCommand(wid, layerId) {
     const { daemonCall } = await getDaemonClient();
     await daemonCall("window.assignLayer", { wid: parseInt(wid), layer: layerId });
     console.log(`Tagged wid:${wid} → layer:${layerId}`);
-  } catch (e) {
-    console.log(`Error: ${e.message}`);
+  } catch (e: unknown) {
+    console.log(`Error: ${(e as Error).message}`);
   }
 }
 
-async function windowLayerMapCommand(jsonFlag) {
+async function windowLayerMapCommand(jsonFlag: boolean): Promise<void> {
   try {
     const { daemonCall } = await getDaemonClient();
-    const map = await daemonCall("window.layerMap");
+    const map = await daemonCall("window.layerMap") as any;
     if (jsonFlag) {
       console.log(JSON.stringify(map, null, 2));
       return;
@@ -748,7 +926,7 @@ async function windowLayerMapCommand(jsonFlag) {
   }
 }
 
-async function focusCommand(session) {
+async function focusCommand(session?: string): Promise<void> {
   if (!session) {
     console.log("Usage: lattices focus <session-name>");
     return;
@@ -757,16 +935,304 @@ async function focusCommand(session) {
     const { daemonCall } = await getDaemonClient();
     await daemonCall("window.focus", { session });
     console.log(`Focused: ${session}`);
-  } catch (e) {
-    console.log(`Error: ${e.message}`);
+  } 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}`);
+  }
+}
+
+async function sessionsCommand(jsonFlag: boolean): Promise<void> {
+  try {
+    const { daemonCall } = await getDaemonClient();
+    const sessions = await daemonCall("tmux.sessions") as any[];
+    if (jsonFlag) {
+      console.log(JSON.stringify(sessions, null, 2));
+      return;
+    }
+    if (!sessions.length) {
+      console.log("No active sessions.");
+      return;
+    }
+    console.log(`Sessions (${sessions.length}):\n`);
+    for (const s of sessions) {
+      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 voiceCommand(subcommand?: string, ...rest: string[]): Promise<void> {
+  const { daemonCall } = await getDaemonClient();
+  try {
+    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 "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;
+      }
+      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;
+      }
+      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');
+    }
+  } catch (e: unknown) {
+    console.log(`Error: ${(e as Error).message}`);
+  }
+}
+
+async function callCommand(method?: string, ...rest: string[]): Promise<void> {
+  if (!method) {
+    console.log("Usage: lattices call <method> [params-json]");
+    console.log("\nExamples:");
+    console.log("  lattices call daemon.status");
+    console.log("  lattices call api.schema");
+    console.log('  lattices call window.place \'{"session":"vox","placement":"left"}\'');
+    return;
+  }
+  try {
+    const { daemonCall } = await getDaemonClient();
+    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}`);
   }
 }
 
-async function layerCommand(index) {
+async function layerCommand(sub?: string, ...rest: string[]): Promise<void> {
   try {
     const { daemonCall } = await getDaemonClient();
-    if (index === undefined || index === null || index === "") {
-      const result = await daemonCall("layers.list");
+
+    // ── 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;
@@ -778,23 +1244,148 @@ async function layerCommand(index) {
       }
       return;
     }
-    const idx = parseInt(index, 10);
+    const idx = parseInt(sub, 10);
     if (!isNaN(idx)) {
-      await daemonCall("layer.switch", { index: idx });
-      console.log(`Switched to layer ${idx}`);
+      await daemonCall("layer.activate", { index: idx, mode: "launch" });
+      console.log(`Activated layer ${idx}`);
     } else {
-      await daemonCall("layer.switch", { name: index });
-      console.log(`Switched to layer "${index}"`);
+      await daemonCall("layer.activate", { name: sub, mode: "launch" });
+      console.log(`Activated layer "${sub}"`);
     }
-  } catch (e) {
-    console.log(`Error: ${e.message}`);
+  } catch (e: unknown) {
+    console.log(`Error: ${(e as Error).message}`);
   }
 }
 
-async function diagCommand(limit) {
+// ── 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();
-    const result = await daemonCall("diagnostics.list", { limit: parseInt(limit, 10) || 40 });
+    const result = await daemonCall("diagnostics.list", { limit: parseInt(limit || "", 10) || 40 }) as any;
     if (!result.entries || !result.entries.length) {
       console.log("No diagnostic entries.");
       return;
@@ -805,26 +1396,26 @@ async function diagCommand(limit) {
                    entry.level === "error"   ? "\x1b[31m✗\x1b[0m" : "›";
       console.log(`  \x1b[90m${entry.time}\x1b[0m ${icon} ${entry.message}`);
     }
-  } catch (e) {
-    console.log(`Error: ${e.message}`);
+  } catch (e: unknown) {
+    console.log(`Error: ${(e as Error).message}`);
   }
 }
 
-async function distributeCommand() {
+async function distributeCommand(): Promise<void> {
   try {
     const { daemonCall } = await getDaemonClient();
-    await daemonCall("layout.distribute");
+    await daemonCall("space.optimize", { scope: "visible", strategy: "balanced" });
     console.log("Distributed visible windows into grid");
   } catch {
     console.log("Daemon not running. Start with: lattices app");
   }
 }
 
-async function daemonLsCommand() {
+async function daemonLsCommand(): Promise<boolean> {
   try {
     const { daemonCall, isDaemonRunning } = await getDaemonClient();
     if (!(await isDaemonRunning())) return false;
-    const sessions = await daemonCall("tmux.sessions");
+    const sessions = await daemonCall("tmux.sessions") as any[];
     if (!sessions.length) {
       console.log("No active tmux sessions.");
       return true;
@@ -832,7 +1423,7 @@ async function daemonLsCommand() {
 
     // Annotate sessions with workspace group info
     const ws = readWorkspaceConfig();
-    const sessionGroupMap = new Map();
+    const sessionGroupMap = new Map<string, { group: string; tab: string }>();
     if (ws?.groups) {
       for (const g of ws.groups) {
         for (const tab of g.tabs || []) {
@@ -858,14 +1449,14 @@ async function daemonLsCommand() {
   }
 }
 
-async function daemonStatusInventory() {
+async function daemonStatusInventory(): Promise<boolean> {
   try {
     const { daemonCall, isDaemonRunning } = await getDaemonClient();
     if (!(await isDaemonRunning())) return false;
-    const inv = await daemonCall("tmux.inventory");
+    const inv = await daemonCall("tmux.inventory") as any;
 
     // Build managed session name set
-    const managed = new Map();
+    const managed = new Map<string, string>();
     const ws = readWorkspaceConfig();
     if (ws?.groups) {
       for (const g of ws.groups) {
@@ -879,7 +1470,7 @@ async function daemonStatusInventory() {
     for (const s of inv.all) {
       if (!managed.has(s.name)) {
         // Check if it matches a scanned project (via daemon)
-        const projects = await daemonCall("projects.list");
+        const projects = await daemonCall("projects.list") as any[];
         for (const p of projects) {
           managed.set(p.sessionName, p.name);
         }
@@ -887,7 +1478,7 @@ async function daemonStatusInventory() {
       }
     }
 
-    const managedSessions = inv.all.filter((s) => managed.has(s.name));
+    const managedSessions = inv.all.filter((s: any) => managed.has(s.name));
     const orphanSessions = inv.orphans;
 
     if (managedSessions.length > 0) {
@@ -926,14 +1517,14 @@ async function daemonStatusInventory() {
 
 // ── OCR commands ──────────────────────────────────────────────────────
 
-async function scanCommand(sub, ...rest) {
+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 {
-      const results = await daemonCall("ocr.snapshot", null, 5000);
+      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.");
         return;
@@ -957,7 +1548,7 @@ async function scanCommand(sub, ...rest) {
             }
           } else {
             const maxPreview = 5;
-            const preview = lines.slice(0, maxPreview).map(l => l.length > 100 ? l.slice(0, 97) + "..." : l);
+            const preview = lines.slice(0, maxPreview).map((l: string) => l.length > 100 ? l.slice(0, 97) + "..." : l);
             for (const line of preview) {
               console.log(`    \x1b[90m${line}\x1b[0m`);
             }
@@ -983,7 +1574,7 @@ async function scanCommand(sub, ...rest) {
       return;
     }
     try {
-      const results = await daemonCall("ocr.search", { query }, 5000);
+      const results = await daemonCall("ocr.search", { query }, 5000) as any[];
       if (!results.length) {
         console.log(`No matches for "${query}".`);
         return;
@@ -997,8 +1588,8 @@ async function scanCommand(sub, ...rest) {
         console.log(`    ${snippet}`);
         console.log();
       }
-    } catch (e) {
-      console.log(`Error: ${e.message}`);
+    } catch (e: unknown) {
+      console.log(`Error: ${(e as Error).message}`);
     }
     return;
   }
@@ -1006,9 +1597,9 @@ async function scanCommand(sub, ...rest) {
   if (sub === "recent" || sub === "log") {
     const full = rest.includes("--full") || rest.includes("-f");
     const numArg = rest.find(a => !a.startsWith("-"));
-    const limit = parseInt(numArg, 10) || 20;
+    const limit = parseInt(numArg || "", 10) || 20;
     try {
-      const results = await daemonCall("ocr.recent", { limit }, 5000);
+      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.");
         return;
@@ -1026,7 +1617,7 @@ async function scanCommand(sub, ...rest) {
           }
         } else {
           const maxPreview = 5;
-          const preview = lines.slice(0, maxPreview).map(l => l.length > 100 ? l.slice(0, 97) + "..." : l);
+          const preview = lines.slice(0, maxPreview).map((l: string) => l.length > 100 ? l.slice(0, 97) + "..." : l);
           for (const line of preview) {
             console.log(`    \x1b[90m${line}\x1b[0m`);
           }
@@ -1047,8 +1638,8 @@ async function scanCommand(sub, ...rest) {
       console.log("Triggering deep scan (Vision OCR)...");
       await daemonCall("ocr.scan", null, 30000);
       console.log("Done.");
-    } catch (e) {
-      console.log(`Error: ${e.message}`);
+    } catch (e: unknown) {
+      console.log(`Error: ${(e as Error).message}`);
     }
     return;
   }
@@ -1060,7 +1651,7 @@ async function scanCommand(sub, ...rest) {
       return;
     }
     try {
-      const results = await daemonCall("ocr.history", { wid }, 5000);
+      const results = await daemonCall("ocr.history", { wid }, 5000) as any[];
       if (!results.length) {
         console.log(`No history for wid:${wid}.`);
         return;
@@ -1070,15 +1661,15 @@ async function scanCommand(sub, ...rest) {
         const ts = new Date(r.timestamp * 1000).toLocaleTimeString();
         const src = r.source === "accessibility" ? "\x1b[33mAX\x1b[0m" : "\x1b[35mOCR\x1b[0m";
         const lines = (r.fullText || "").split("\n").filter(Boolean);
-        const preview = lines.slice(0, 2).map(l => l.length > 80 ? l.slice(0, 77) + "..." : l);
+        const preview = lines.slice(0, 2).map((l: string) => l.length > 80 ? l.slice(0, 77) + "..." : l);
         console.log(`  \x1b[90m${ts}\x1b[0m  ${src}  \x1b[1m${r.app}\x1b[0m — "${r.title}"`);
         for (const line of preview) {
           console.log(`    \x1b[90m${line}\x1b[0m`);
         }
         console.log();
       }
-    } catch (e) {
-      console.log(`Error: ${e.message}`);
+    } catch (e: unknown) {
+      console.log(`Error: ${(e as Error).message}`);
     }
     return;
   }
@@ -1097,7 +1688,7 @@ Usage:
 `);
 }
 
-function printUsage() {
+function printUsage(): void {
   console.log(`lattices — Claude Code + dev server in tmux
 
 Usage:
@@ -1111,17 +1702,38 @@ Usage:
   lattices group [id]         List tab groups or launch/attach a group
   lattices groups             List all tab groups with status
   lattices tab <group> [tab]  Switch tab within a group (by label or index)
+  lattices search <query>     Search windows by title, app, session, OCR
+  lattices search <q> --deep  Deep search: index + live terminal inspection
+  lattices search <q> --wid   Print matching window IDs only (pipeable)
+  lattices search <q> --json  JSON output
+  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 focus <session>    Focus a session's terminal window (daemon required)
+  lattices sessions [--json]  List active tmux sessions via daemon
   lattices tile <position>    Tile the frontmost window (left, right, top, etc.)
   lattices distribute         Smart-grid all visible windows (daemon required)
   lattices layer [name|index]  List layers or switch by name/index (daemon required)
+  lattices layer create <name> [wid:N ...] [--json '<specs>']  Create a session layer
+  lattices layer snap [name]   Snapshot visible windows into a session layer
+  lattices layer session [n]   List or switch session layers (runtime, no restart)
+  lattices layer delete <name> Delete a session layer
+  lattices layer clear         Clear all session layers
+  lattices voice status       Voice provider status
+  lattices voice simulate <t> Parse and execute a voice command
+  lattices voice intents      List all available intents
+  lattices call <method> [p]  Raw daemon API call (params as JSON)
   lattices scan               Show text from all visible windows
   lattices scan --full        Full text dump
   lattices scan search <q>    Full-text search across scanned windows
   lattices scan recent [n]    Show recent scans chronologically
   lattices scan deep          Trigger a deep Vision OCR scan
   lattices scan history <wid> Scan timeline for a specific window
+  lattices dev                Run dev server (auto-detected)
+  lattices dev build          Build the project (swift/node/rust/go/make)
+  lattices dev restart        Build + restart (swift app) or just build
+  lattices dev type           Print detected project type
+  lattices mouse              Find mouse — sonar pulse at cursor position
+  lattices mouse summon       Summon mouse to screen center
   lattices daemon status      Show daemon status
   lattices diag [limit]       Show diagnostic log entries
   lattices app                Launch the menu bar companion app
@@ -1172,7 +1784,7 @@ Layouts:
 `);
 }
 
-function initConfig() {
+function initConfig(): void {
   const dir = process.cwd();
   const configPath = resolve(dir, ".lattices.json");
 
@@ -1192,7 +1804,7 @@ function initConfig() {
   console.log(JSON.stringify(config, null, 2));
 }
 
-function listSessions() {
+function listSessions(): void {
   const out = runQuiet(
     "tmux list-sessions -F '#{session_name}  (#{session_windows} windows, created #{session_created_string})'"
   );
@@ -1203,7 +1815,7 @@ function listSessions() {
 
   // Annotate sessions that belong to tab groups
   const ws = readWorkspaceConfig();
-  const sessionGroupMap = new Map();
+  const sessionGroupMap = new Map<string, { group: string; tab: string }>();
   if (ws?.groups) {
     for (const g of ws.groups) {
       for (const tab of g.tabs || []) {
@@ -1216,7 +1828,7 @@ function listSessions() {
     }
   }
 
-  const lines = out.split("\n").map((line) => {
+  const lines = out.split("\n").map((line: string) => {
     const sessionName = line.split("  ")[0];
     const info = sessionGroupMap.get(sessionName);
     return info
@@ -1228,7 +1840,7 @@ function listSessions() {
   console.log(lines.join("\n"));
 }
 
-function killSession(name) {
+function killSession(name?: string): void {
   if (!name) name = toSessionName(process.cwd());
   if (!sessionExists(name)) {
     console.log(`No session "${name}".`);
@@ -1240,7 +1852,14 @@ function killSession(name) {
 
 // ── Window tiling ────────────────────────────────────────────────────
 
-function getScreenBounds() {
+interface ScreenBounds {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+
+function getScreenBounds(): ScreenBounds {
   // Get the visible area (excludes menu bar and dock) in AppleScript coordinates (top-left origin)
   const script = `
     tell application "Finder"
@@ -1255,7 +1874,7 @@ function getScreenBounds() {
 }
 
 // Presets return AppleScript bounds: [left, top, right, bottom] within the visible area
-const tilePresets = {
+const tilePresets: Record<string, (s: ScreenBounds) => number[]> = {
   "left":         (s) => [s.x, s.y, s.x + s.w / 2, s.y + s.h],
   "left-half":    (s) => [s.x, s.y, s.x + s.w / 2, s.y + s.h],
   "right":        (s) => [s.x + s.w / 2, s.y, s.x + s.w, s.y + s.h],
@@ -1282,7 +1901,7 @@ const tilePresets = {
   "right-third":  (s) => [s.x + Math.round(s.w * 0.667), s.y, s.x + s.w, s.y + s.h],
 };
 
-function tileWindow(position) {
+function tileWindow(position: string): void {
   const preset = tilePresets[position];
   if (!preset) {
     console.log(`Unknown position: ${position}`);
@@ -1302,7 +1921,7 @@ function tileWindow(position) {
   console.log(`Tiled → ${position}`);
 }
 
-function createOrAttach() {
+function createOrAttach(): void {
   const dir = process.cwd();
   const name = toSessionName(dir);
 
@@ -1323,7 +1942,7 @@ function createOrAttach() {
   attach(name);
 }
 
-function attach(name) {
+function attach(name: string): void {
   if (isInsideTmux()) {
     execSync(`tmux switch-client -t "${name}"`, { stdio: "inherit" });
   } else {
@@ -1333,7 +1952,7 @@ function attach(name) {
 
 // ── Status / Inventory ───────────────────────────────────────────────
 
-function statusInventory() {
+function statusInventory(): void {
   // Query all tmux sessions
   const sessionsRaw = runQuiet(
     'tmux list-sessions -F "#{session_name}\t#{session_windows}\t#{session_attached}"'
@@ -1349,17 +1968,17 @@ function statusInventory() {
   );
 
   // Parse panes grouped by session
-  const panesBySession = new Map();
+  const panesBySession = new Map<string, { title: string; cmd: string }[]>();
   if (panesRaw) {
     for (const line of panesRaw.split("\n").filter(Boolean)) {
       const [sess, title, cmd] = line.split("\t");
       if (!panesBySession.has(sess)) panesBySession.set(sess, []);
-      panesBySession.get(sess).push({ title, cmd });
+      panesBySession.get(sess)!.push({ title, cmd });
     }
   }
 
   // Build managed session name set
-  const managed = new Map(); // name -> label
+  const managed = new Map<string, string>(); // name -> label
 
   // From workspace groups
   const ws = readWorkspaceConfig();
@@ -1391,7 +2010,7 @@ function statusInventory() {
   }
 
   // Parse sessions and classify
-  const sessions = sessionsRaw.split("\n").filter(Boolean).map((line) => {
+  const sessions = sessionsRaw.split("\n").filter(Boolean).map((line: string) => {
     const [name, windows, attached] = line.split("\t");
     return { name, windows: parseInt(windows) || 1, attached: attached !== "0" };
   });
@@ -1437,10 +2056,7 @@ function statusInventory() {
 
 // ── Main ─────────────────────────────────────────────────────────────
 
-if (!hasTmux()) {
-  console.error("tmux is not installed. Install with: brew install tmux");
-  process.exit(1);
-}
+requireTmux(command);
 
 switch (command) {
   case "init":
@@ -1509,12 +2125,28 @@ switch (command) {
       console.log("  lattices window map [--json]               Show all layer tags");
     }
     break;
+  case "search":
+  case "s":
+    await searchCommand(args[1], new Set(args.slice(2)));
+    break;
   case "focus":
     await focusCommand(args[1]);
     break;
+  case "place":
+    await placeCommand(args[1], args[2]);
+    break;
+  case "sessions":
+    await sessionsCommand(args[1] === "--json");
+    break;
+  case "voice":
+    await voiceCommand(args[1], ...args.slice(2));
+    break;
+  case "call":
+    await callCommand(args[1], ...args.slice(2));
+    break;
   case "layer":
   case "layers":
-    await layerCommand(args[1]);
+    await layerCommand(args[1], ...args.slice(2));
     break;
   case "diag":
   case "diagnostics":
@@ -1524,6 +2156,9 @@ switch (command) {
   case "ocr":
     await scanCommand(args[1], ...args.slice(2));
     break;
+  case "mouse":
+    await mouseCommand(args[1]);
+    break;
   case "daemon":
     if (args[1] === "status") {
       await daemonStatusCommand();
@@ -1531,13 +2166,15 @@ switch (command) {
       console.log("Usage: lattices daemon status");
     }
     break;
+  case "dev":
+    await devCommand(args[1], ...args.slice(2));
+    break;
   case "app": {
     // Forward to lattices-app script
     const { execFileSync } = await import("node:child_process");
-    const __dirname2 = dirname(fileURLToPath(import.meta.url));
-    const appScript = resolve(__dirname2, "lattices-app.js");
+    const appScript = resolve(import.meta.dir, "lattices-app.ts");
     try {
-      execFileSync("node", [appScript, ...args.slice(1)], { stdio: "inherit" });
+      execFileSync("bun", [appScript, ...args.slice(1)], { stdio: "inherit" });
     } catch { /* exit code forwarded */ }
     break;
   }