wave-code 1.1.5 → 1.2.0

package/src/daemon/commands.ts

@@ -1,8 +1,14 @@
 /**
  * `wave daemon` client subcommands — talk to the wave daemon's unix socket
- * (JSON-RPC over newline-delimited JSON) to list hosted sessions, inspect
- * progress, inject messages, respond to pending permission requests and abort
- * in-flight message generation.
+ * (JSON-RPC over newline-delimited JSON) to create/destroy sessions, list
+ * hosted sessions, inspect progress, inject messages, respond to pending
+ * permission requests, abort in-flight message generation, and stop/restart
+ * the daemon itself. When the daemon is not running (stopped / killed /
+ * machine reboot), every subcommand except `stop` starts one on demand
+ * (detached --daemon spawn, the local equivalent of the remote nohup
+ * launcher) and retries the connection — once started the daemon stays
+ * resident (it does not exit on idle), so a subcommand usually finds it up.
+ * `stop` never auto-starts: with no daemon running it is an idempotent no-op.
  *
  * All subcommands are non-interactive: results go to stdout, diagnostics to
  * stderr, and every handler calls process.exit() itself (yargs would fall
@@ -19,6 +25,7 @@
  * must be destroyed via the envelope sessionId returned by `initialize`.
  */
 
+import { execFile, spawn } from "node:child_process";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
@@ -26,7 +33,11 @@ import {
   ASK_USER_QUESTION_TOOL_NAME,
   ENTER_PLAN_MODE_TOOL_NAME,
   EXIT_PLAN_MODE_TOOL_NAME,
+  getGitMainRepoRoot,
   getMessageContent,
+  hasWorktreeCreateHook,
+  loadMergedWaveConfig,
+  type AskUserQuestion,
   type Message,
   type PermissionDecision,
   type PermissionMode,
@@ -49,6 +60,10 @@ const PERMISSION_MODES: PermissionMode[] = [
   "dontAsk",
 ];
 
+/** How long to wait for an auto-started daemon's socket to come up (mutable so tests can shorten it). */
+export const daemonStartTimeout = { ms: 10_000 };
+const DAEMON_POLL_INTERVAL_MS = 500;
+
 // ── Connection helpers ─────────────────────────────────────────
 
 function connectDaemon(socketPath: string): Promise<SocketClient> {
@@ -62,14 +77,49 @@ function connectDaemon(socketPath: string): Promise<SocketClient> {
   });
 }
 
-/** Connect or fail fast with the spec'd error; daemon idle-exits after 60s. */
+/**
+ * Start a wave daemon on demand, detached — the local equivalent of the remote
+ * nohup launcher `nohup <wave> --daemon <socket> </dev/null >/dev/null 2>&1 &`
+ * (spec: daemon-command.md 按需即用). Re-execs the current wave CLI (`node
+ * <this script> --daemon <socket>`) with no stdio and unrefs the child so the
+ * client exits without waiting; the daemon cleans stale socket files itself on
+ * start.
+ */
+function startDaemon(socketPath: string): void {
+  const entry = process.argv[1];
+  if (!entry) {
+    fail("Cannot start the wave daemon: unknown CLI entry path");
+  }
+  const child = spawn(process.execPath, [entry, "--daemon", socketPath], {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+}
+
+/**
+ * Connect or start the daemon on demand: try the socket, and when the daemon is
+ * not running, launch one detached and retry until its socket accepts a
+ * connection (or daemonStartTimeout.ms elapses). Exits (nonzero) with the
+ * spec'd error when the daemon cannot be started/reached.
+ */
 async function connectDaemonOrExit(socketPath: string): Promise<SocketClient> {
   try {
     return await connectDaemon(socketPath);
   } catch (err) {
     const code = (err as NodeJS.ErrnoException).code;
+    startDaemon(socketPath);
+    const deadline = Date.now() + daemonStartTimeout.ms;
+    while (Date.now() < deadline) {
+      await sleep(DAEMON_POLL_INTERVAL_MS);
+      try {
+        return await connectDaemon(socketPath);
+      } catch {
+        // Daemon still coming up — keep polling.
+      }
+    }
     console.error(
-      `Cannot connect to daemon socket ${socketPath}: is the daemon running? (it auto-exits after 60s idle)` +
+      `Cannot connect to daemon socket ${socketPath}: started a daemon but it did not come up` +
         (code ? ` (${code})` : ""),
     );
     process.exit(1);
@@ -136,6 +186,70 @@ function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// ── create ─────────────────────────────────────────────────────
+
+export interface CreateOptions {
+  /** Working directory for the new session (default: current directory). */
+  workdir?: string;
+  /** Permission mode for the new session (default: bypassPermissions). */
+  permissionMode?: string;
+  /** Model override for the new session (default: configured model). */
+  model?: string;
+  /** Create the session in a new git worktree (name auto-generated when omitted). */
+  worktree?: string;
+}
+
+/**
+ * Create a fresh session in the daemon. initialize WITHOUT restoreSessionId
+ * always creates a brand-new session (never an attach), so no existence checks
+ * are needed. Defaults mirror the daemon's background-task use case: workdir =
+ * current directory, permissionMode = bypassPermissions. With --worktree the
+ * daemon first creates a git worktree (protocol createWorktree) and the session
+ * is created inside it. Prints the new sessionId (first line, for scripts),
+ * plus the worktree path/branch when --worktree was used.
+ */
+export async function daemonCreateCommand(
+  socketPath: string,
+  options: CreateOptions = {},
+): Promise<void> {
+  const mode = options.permissionMode ?? "bypassPermissions";
+  if (!PERMISSION_MODES.includes(mode as PermissionMode)) {
+    fail(
+      `Invalid permission mode: ${mode} (options: ${PERMISSION_MODES.join(", ")})`,
+    );
+  }
+  let client: SocketClient | undefined;
+  try {
+    client = await connectDaemonOrExit(socketPath);
+    let workdir = options.workdir ?? process.cwd();
+    let worktreePath: string | undefined;
+    let worktreeBranch: string | undefined;
+    if (options.worktree !== undefined) {
+      const wt = (await client.request("createWorktree", {
+        workdir,
+        name: options.worktree,
+      })) as { name: string; path: string; branch: string; repoRoot: string };
+      workdir = wt.path;
+      worktreePath = wt.path;
+      worktreeBranch = wt.branch;
+    }
+    const result = (await client.request("initialize", {
+      workdir,
+      permissionMode: mode,
+      model: options.model,
+    })) as { sessionId: string };
+    console.log(result.sessionId);
+    if (worktreePath !== undefined) {
+      console.log(`Worktree: ${worktreePath} (branch: ${worktreeBranch})`);
+    }
+  } catch (err) {
+    fail(`wave daemon create failed: ${(err as Error).message}`);
+  } finally {
+    await client?.dispose();
+  }
+  process.exit(0);
+}
+
 // ── list ───────────────────────────────────────────────────────
 
 export async function daemonListCommand(socketPath: string): Promise<void> {
@@ -194,6 +308,96 @@ function summarizeToolInput(context: ToolPermissionContext): string {
   return text.length > 80 ? `${text.slice(0, 80)}…` : text;
 }
 
+/** The questions array of an AskUserQuestion toolInput (SDK schema), if any. */
+function getAskUserQuestions(
+  context: ToolPermissionContext,
+): AskUserQuestion[] | undefined {
+  const raw = context.toolInput?.questions;
+  return Array.isArray(raw) && raw.length > 0
+    ? (raw as AskUserQuestion[])
+    : undefined;
+}
+
+/**
+ * Multi-line full render of an AskUserQuestion tool input, mirroring the
+ * desktop ConfirmationDialog layout so the CLI user sees every question and
+ * option (spec: daemon-command.md AskUserQuestion 多行完整渲染). Question
+ * lines carry the 1-based question number + header; option lines carry the
+ * 0-based number that `respond --answer` accepts.
+ */
+function renderAskUserQuestions(context: ToolPermissionContext): string {
+  const questions = getAskUserQuestions(context);
+  if (!questions) return "";
+  return questions
+    .map((q, qi) => {
+      const title = `    Q${qi + 1} [${q.header}] ${q.question}`;
+      const options = (q.options ?? []).map(
+        (o, oi) =>
+          `      ${oi}. ${o.label}${o.description ? ` — ${o.description}` : ""}`,
+      );
+      return [title, ...options].join("\n");
+    })
+    .join("\n");
+}
+
+/**
+ * Parse `respond --answer` for an AskUserQuestion request. Legacy format — a
+ * valid JSON object keyed by the full question text (value = the option label,
+ * exactly what the desktop dialog would submit) — passes through untouched.
+ * Anything else is parsed as comma-separated option numbers: the i-th number
+ * answers the i-th question (as numbered Q1..Qn by `wave daemon status`),
+ * 0-based like the status rendering, and is mapped to that option's label so
+ * the model sees the same answers the GUI would produce.
+ */
+function parseAskUserQuestionAnswer(
+  raw: string,
+  context: ToolPermissionContext,
+): Record<string, unknown> {
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (
+      parsed !== null &&
+      typeof parsed === "object" &&
+      !Array.isArray(parsed)
+    ) {
+      return parsed as Record<string, unknown>;
+    }
+  } catch {
+    // Not JSON — fall through to per-question option numbers below.
+  }
+  const questions = getAskUserQuestions(context);
+  if (!questions) {
+    fail(
+      `Cannot parse --answer "${raw}": not a JSON object of {question: answer} and the pending request has no questions to answer by number`,
+    );
+  }
+  const numbers = raw.split(",").map((n) => n.trim());
+  if (numbers.length !== questions.length) {
+    fail(
+      `--answer must give one option number per question (${questions.length} question${questions.length > 1 ? "s" : ""}, comma-separated, matching the numbering in \`wave daemon status\`): got ${numbers.length} number${numbers.length > 1 ? "s" : ""} in "${raw}"`,
+    );
+  }
+  const answers: Record<string, unknown> = {};
+  numbers.forEach((n, qi) => {
+    const q = questions[qi];
+    if (!/^\d+$/.test(n)) {
+      fail(
+        `--answer contains a non-numeric option number "${n}" for question ${qi + 1} (${q.question})`,
+      );
+    }
+    const options = q.options ?? [];
+    const idx = Number(n);
+    if (idx >= options.length) {
+      fail(
+        `Option number ${n} is out of range for question ${qi + 1} (${q.question}): options are numbered 0..${options.length - 1}`,
+      );
+    }
+    const label = options[idx].label;
+    answers[q.question] = q.multiSelect ? [label] : label;
+  });
+  return answers;
+}
+
 export async function daemonStatusCommand(
   socketPath: string,
   sessionId: string,
@@ -240,6 +444,14 @@ export async function daemonStatusCommand(
       console.log("");
       console.log("Pending approval requests:");
       for (const r of pending) {
+        if (r.context.toolName === ASK_USER_QUESTION_TOOL_NAME) {
+          const questions = renderAskUserQuestions(r.context);
+          if (questions) {
+            console.log(`  ${r.requestId}  ${r.context.toolName}`);
+            console.log(questions);
+            continue;
+          }
+        }
         const params = summarizeToolInput(r.context);
         console.log(
           `  ${r.requestId}  ${r.context.toolName}${params ? `  ${params}` : ""}`,
@@ -268,27 +480,35 @@ export async function daemonStatusCommand(
 // ── send ───────────────────────────────────────────────────────
 
 export interface SendOptions {
-  timeout: number; // seconds; 0 = no limit (default 600)
+  /** Seconds to wait for the reply; 0 (default) = async dispatch: inject the
+   * message and exit immediately without waiting (fire-and-forget). */
+  wait: number;
 }
 
 /**
- * Send a message and wait for the reply that corresponds to it.
+ * Inject a message into a session and, when `--wait <N>` is given, wait for the
+ * reply that corresponds to it and print the pure final reply text.
+ *
+ * Default (no --wait) is async dispatch: the command exits 0 as soon as the
+ * message is delivered (the message lands in history on an idle session, or is
+ * enqueued when the session is busy) — the sender never blocks on the reply,
+ * progress is tracked via `status` (spec: send 默认异步派单).
  *
- * Completion detection: `sendMessage` on an idle session resolves only after
- * the whole turn finishes (InteractionService awaits sendAIMessage), while on a
- * busy session it enqueues and returns immediately — so stopping on a bare
- * `loadingChange:false` would exit early on the PREVIOUS turn's completion when
- * queued behind a busy session. Instead, track the message IDs: `ourUserMessage`
- * is the user message added when OUR turn starts (userMessageAdded), and the
- * reply is the last assistantMessageAdded observed after it. A stale
- * loading:false can then never satisfy the wait condition early (the reply has
- * not been added yet).
+ * Completion detection (wait mode): `sendMessage` on an idle session resolves
+ * only after the whole turn finishes (InteractionService awaits
+ * sendAIMessage), while on a busy session it enqueues and returns immediately —
+ * so stopping on a bare `loadingChange:false` would exit early on the PREVIOUS
+ * turn's completion when queued behind a busy session. Instead, track the
+ * message IDs: `ourUserMessage` is the user message added when OUR turn starts
+ * (userMessageAdded), and the reply is the last assistantMessageAdded observed
+ * after it. A stale loading:false can then never satisfy the wait condition
+ * early (the reply has not been added yet).
  */
 export async function daemonSendCommand(
   socketPath: string,
   sessionId: string,
   message: string,
-  options: SendOptions = { timeout: 600 },
+  options: SendOptions = { wait: 0 },
 ): Promise<void> {
   // connectDaemonOrExit exits on failure — no client to dispose in that case.
   const client = await connectDaemonOrExit(socketPath);
@@ -313,15 +533,54 @@ export async function daemonSendCommand(
   try {
     initId = (await attachSession(client, sessionId)).sessionId;
     sent = true;
+  } catch (err) {
+    client.dispose();
+    fail(`wave daemon send failed: ${(err as Error).message}`);
+  }
+
+  if (options.wait <= 0) {
+    // Async dispatch mode (default, --wait 0): exit as soon as the message is
+    // DELIVERED, not when the turn completes. The sendMessage RPC resolves only
+    // after the whole turn on an idle session (InteractionService awaits
+    // sendAIMessage) but returns right after enqueueing on a busy session — so
+    // delivery is the earlier of our userMessageAdded notification (idle: the
+    // message lands in history before the turn starts) and the RPC response
+    // itself (busy: enqueued immediately). The daemon keeps running the turn
+    // after this client disconnects (attach 语义) — progress is tracked via
+    // `status` (spec: send 默认异步派单).
+    const sendPromise = client.request(
+      "sendMessage",
+      { text: message },
+      initId,
+    );
+    const userMessage = new Promise<"userMessageAdded">((resolve) => {
+      client.onNotification("userMessageAdded", () => {
+        if (ourUserMessageId !== undefined) resolve("userMessageAdded");
+      });
+    });
+    try {
+      await Promise.race([sendPromise, userMessage]);
+    } catch (err) {
+      client.dispose();
+      fail(`wave daemon send failed: ${(err as Error).message}`);
+    }
+    client.dispose();
+    console.log(`Sent message to session: ${sessionId}`);
+    process.exit(0);
+  }
+
+  try {
     await client.request("sendMessage", { text: message }, initId);
   } catch (err) {
     client.dispose();
     fail(`wave daemon send failed: ${(err as Error).message}`);
   }
 
-  // Wait for the reply that corresponds to our message.
+  // Wait for the reply that corresponds to our message (--wait N mode). N is
+  // the seconds bound of the wait; the loop never hangs indefinitely (spec:
+  // --wait 兜底避免无限挂起).
   const started = Date.now();
-  const timeoutMs = options.timeout === 0 ? Infinity : options.timeout * 1000;
+  const timeoutMs = options.wait * 1000;
   while (!(loading === false && replyMessageId !== undefined)) {
     if (Date.now() - started > timeoutMs) {
       // Timeout backstop: the most likely cause is a session waiting on a
@@ -336,9 +595,7 @@ export async function daemonSendCommand(
         );
       }
       fail(
-        options.timeout === 0
-          ? "Timed out waiting for a reply"
-          : `Timed out waiting for a reply (${options.timeout}s), no assistant reply received`,
+        `Timed out waiting for a reply (${options.wait}s), no assistant reply received`,
       );
     }
     await sleep(200);
@@ -353,7 +610,16 @@ export async function daemonSendCommand(
     // reach stdout (spec: send 输出纯净性).
     if (reply) {
       const content = getMessageContent(reply).replace(/\s+/g, " ").trim();
-      if (content) console.log(content);
+      if (content) {
+        console.log(content);
+      } else if (reply.blocks.some((b) => b.type === "reasoning")) {
+        // Interrupted mid-generation (e.g. `wave daemon abort`): the reply was
+        // finalized with reasoning but no text. Surface the interruption
+        // instead of silently exiting 0 with no output (spec: 中断需明确提示).
+        fail("Message aborted before producing a reply");
+      }
+    } else {
+      fail("No reply received for the message");
     }
   } catch (err) {
     fail(`wave daemon send failed: ${(err as Error).message}`);
@@ -413,15 +679,10 @@ export async function daemonRespondCommand(
       } else if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
         if (!options.answer) {
           fail(
-            "AskUserQuestion requests require --answer with the answer JSON",
+            'AskUserQuestion requests require --answer: a JSON object of {question: answer}, or option numbers per question (e.g. "0" or "1,0", see the numbering in `wave daemon status`)',
           );
         }
-        let answers: unknown;
-        try {
-          answers = JSON.parse(options.answer);
-        } catch {
-          fail("--answer is not valid JSON");
-        }
+        const answers = parseAskUserQuestionAnswer(options.answer, req.context);
         decision = { behavior: "allow", message: JSON.stringify(answers) };
       } else {
         decision = { behavior: "allow" };
@@ -472,3 +733,198 @@ export async function daemonAbortCommand(
   }
   process.exit(0);
 }
+
+// ── destroy ────────────────────────────────────────────────────
+
+export interface DestroyOptions {
+  /** Also remove the session's git worktree before destroying (protocol removeWorktree). */
+  removeWorktree?: boolean;
+}
+
+/** Run one git command and return trimmed stdout (rejects on git failure). */
+function runGit(cwd: string, args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile("git", args, { cwd }, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout.trim());
+    });
+  });
+}
+
+/**
+ * Resolve the worktree hosting `workingDirectory` for removal, mirroring the
+ * values protocol createWorktree returns: worktree path via
+ * `git rev-parse --show-toplevel`, branch via `git branch --show-current`, and
+ * repoRoot = the MAIN repo root (first entry of `git worktree list` — where
+ * git worktree/branch operations run from). Refuses to remove the main working
+ * tree: a plain session is not a worktree, and the protocol's path-containment
+ * check would pass trivially while removeWorktree's fs.rmSync fallback could
+ * delete the whole repository.
+ */
+async function resolveWorktreeForRemoval(workingDirectory: string): Promise<{
+  path: string;
+  branch: string;
+  repoRoot: string;
+  hookBased: boolean;
+}> {
+  let worktreePath: string;
+  let branch: string;
+  try {
+    const [toplevel, current] = await Promise.all([
+      runGit(workingDirectory, ["rev-parse", "--show-toplevel"]),
+      runGit(workingDirectory, ["branch", "--show-current"]),
+    ]);
+    worktreePath = toplevel;
+    branch = current;
+  } catch {
+    throw new Error(
+      `Cannot remove worktree: ${workingDirectory} is not inside a git repository`,
+    );
+  }
+  const repoRoot = getGitMainRepoRoot(workingDirectory);
+  if (path.resolve(worktreePath) === path.resolve(repoRoot)) {
+    throw new Error(
+      `Refusing to remove the main working tree: ${repoRoot} (not a linked worktree)`,
+    );
+  }
+  // Hook-based worktrees (created via a WorktreeCreate hook) are removed by the
+  // WorktreeRemove hook — mirror createWorktree's own hookBased decision so
+  // removal never runs `git worktree remove` on a hook-managed worktree.
+  const config = loadMergedWaveConfig(repoRoot);
+  const hookBased = hasWorktreeCreateHook(config?.hooks);
+  return { path: worktreePath, branch, repoRoot, hookBased };
+}
+
+/**
+ * Destroy a hosted session (protocol destroy, idempotent — a session not in
+ * the daemon's in-memory registry is a harmless no-op). Unlike status / send /
+ * abort there is no attach step: destroy is a pure registry operation keyed by
+ * the envelope sessionId, so unknown sessions succeed without touching disk.
+ * With --remove-worktree the session's git worktree is resolved from its
+ * workingDirectory (getSessionInfo) and removed via protocol removeWorktree
+ * first, then the session is destroyed.
+ */
+export async function daemonDestroyCommand(
+  socketPath: string,
+  sessionId: string,
+  options: DestroyOptions = {},
+): Promise<void> {
+  let client: SocketClient | undefined;
+  try {
+    client = await connectDaemonOrExit(socketPath);
+    if (options.removeWorktree) {
+      const info = (await client.request(
+        "getSessionInfo",
+        undefined,
+        sessionId,
+      )) as { workingDirectory: string };
+      const wt = await resolveWorktreeForRemoval(info.workingDirectory);
+      await client.request("removeWorktree", {
+        path: wt.path,
+        branch: wt.branch,
+        repoRoot: wt.repoRoot,
+        hookBased: wt.hookBased,
+      });
+      console.log(`Removed worktree: ${wt.path} (branch: ${wt.branch})`);
+    }
+    await client.request("destroy", undefined, sessionId);
+    console.log(`Destroyed session: ${sessionId}`);
+  } catch (err) {
+    fail(`wave daemon destroy failed: ${(err as Error).message}`);
+  } finally {
+    await client?.dispose();
+  }
+  process.exit(0);
+}
+
+// ── stop / restart ─────────────────────────────────────────────
+
+/** How long stop/restart wait for a running daemon to exit (mutable so tests can shorten it). */
+export const daemonStopTimeout = { ms: 10_000 };
+const DAEMON_STOP_POLL_INTERVAL_MS = 200;
+
+/** Connect to the daemon socket without starting one; undefined when it is not running. */
+async function tryConnectDaemon(
+  socketPath: string,
+): Promise<SocketClient | undefined> {
+  try {
+    return await connectDaemon(socketPath);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Poll until the daemon socket stops accepting connections (the daemon exited). */
+async function waitForDaemonExit(socketPath: string): Promise<void> {
+  const deadline = Date.now() + daemonStopTimeout.ms;
+  while (Date.now() < deadline) {
+    const client = await tryConnectDaemon(socketPath);
+    if (!client) return;
+    client.dispose();
+    await sleep(DAEMON_STOP_POLL_INTERVAL_MS);
+  }
+  throw new Error(
+    `daemon did not exit within ${daemonStopTimeout.ms}ms (socket still accepting connections)`,
+  );
+}
+
+/**
+ * Gracefully stop a running daemon: send the `shutdown` RPC (the daemon
+ * destroys every session — each agent saves its transcript — then removes its
+ * socket file and exits) and wait for the socket to disappear. Never starts a
+ * daemon. Returns whether one was running (false = idempotent no-op).
+ * Throws when a running daemon fails to exit in time.
+ */
+async function stopDaemon(socketPath: string): Promise<boolean> {
+  const client = await tryConnectDaemon(socketPath);
+  if (!client) return false;
+  try {
+    // The daemon may drop the socket before responding to the RPC — the wait
+    // below is the source of truth, so any request error is fine.
+    await client.request("shutdown").catch(() => {});
+  } finally {
+    client.dispose();
+  }
+  await waitForDaemonExit(socketPath);
+  return true;
+}
+
+/**
+ * Gracefully stop the daemon (spec: daemon-command.md stop/restart). Sends the
+ * `shutdown` RPC so sessions are destroyed and transcripts flushed before the
+ * process exits — not a pkill. Idempotent: with no daemon running it prints
+ * "Daemon is not running" and exits 0 without starting one.
+ */
+export async function daemonStopCommand(socketPath: string): Promise<void> {
+  let stopped = false;
+  try {
+    stopped = await stopDaemon(socketPath);
+  } catch (err) {
+    fail(`wave daemon stop failed: ${(err as Error).message}`);
+  }
+  console.log(stopped ? "Daemon stopped" : "Daemon is not running");
+  process.exit(0);
+}
+
+/**
+ * Restart the daemon (spec: daemon-command.md stop/restart — the main scenario
+ * is restarting after a CLI upgrade so the fresh daemon runs the new code).
+ * A running daemon is gracefully stopped first (shutdown RPC + wait), then a
+ * fresh daemon is started on demand from the current CLI; when none is
+ * running this just starts one. Exits 1 with a clear error if the daemon
+ * cannot be stopped or the fresh one does not come up.
+ */
+export async function daemonRestartCommand(socketPath: string): Promise<void> {
+  let wasRunning = false;
+  try {
+    wasRunning = await stopDaemon(socketPath);
+  } catch (err) {
+    fail(`wave daemon restart failed: ${(err as Error).message}`);
+  }
+  // connectDaemonOrExit starts a daemon when the socket is absent and retries
+  // until it comes up (exit 1 with the spec'd error on timeout).
+  const client = await connectDaemonOrExit(socketPath);
+  client.dispose();
+  console.log(wasRunning ? "Daemon restarted" : "Daemon started");
+  process.exit(0);
+}

package/src/hooks/useInputManager.ts

@@ -62,6 +62,7 @@ export const useInputManager = (
     onClearMessages,
     onCompact,
     onAddDir,
+    onPlanCommand,
     isIdle: isIdleProp,
   } = callbacks;
 
@@ -271,12 +272,18 @@ export const useInputManager = (
                 dispatch({ type: "SET_SHOW_MODEL_SELECTOR", payload: true });
               } else if (command === "workflows") {
                 dispatch({ type: "SET_SHOW_WORKFLOW_MANAGER", payload: true });
+              } else if (command === "skills") {
+                dispatch({ type: "SET_SHOW_SKILLS_MANAGER", payload: true });
+              } else if (command === "hooks") {
+                dispatch({ type: "SET_SHOW_HOOKS_MANAGER", payload: true });
               } else if (command === "clear") {
                 await onClearMessages?.();
               } else if (command === "compact") {
                 await onCompact?.(effect.args);
               } else if (command === "add-dir") {
                 await onAddDir?.(effect.args);
+              } else if (command === "plan") {
+                await onPlanCommand?.(effect.args);
               }
             }
             break;
@@ -306,6 +313,7 @@ export const useInputManager = (
     onClearMessages,
     onCompact,
     onAddDir,
+    onPlanCommand,
   ]);
 
   useEffect(() => {
@@ -531,6 +539,10 @@ export const useInputManager = (
     dispatch({ type: "SET_SHOW_SKILLS_MANAGER", payload: show });
   }, []);
 
+  const setShowHooksManager = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_HOOKS_MANAGER", payload: show });
+  }, []);
+
   const setPermissionMode = useCallback(
     (mode: PermissionMode) => {
       dispatch({ type: "SET_PERMISSION_MODE", payload: mode });
@@ -676,6 +688,7 @@ export const useInputManager = (
     showModelSelector: state.showModelSelector,
     showWorkflowManager: state.showWorkflowManager,
     showSkillsManager: state.showSkillsManager,
+    showHooksManager: state.showHooksManager,
     permissionMode: state.permissionMode,
     attachedImages: state.attachedImages,
     btwState: state.btwState,
@@ -723,6 +736,7 @@ export const useInputManager = (
     setShowModelSelector,
     setShowWorkflowManager,
     setShowSkillsManager,
+    setShowHooksManager,
     setPermissionMode,
     setBtwState,