wave-code 1.5.0 → 1.6.0

package/src/utils/usageSummary.ts

@@ -17,6 +17,45 @@ export interface TokenSummary {
   cache_creation_input_tokens?: number;
 }
 
+/**
+ * Totals across every usage record — what the structured `usage` field reports.
+ *
+ * Claude Code's `input_tokens` excludes cached tokens; ours (`prompt_tokens`,
+ * OpenAI shape) already contains them, so the two are not interchangeable and
+ * this deliberately keeps our own field names.
+ */
+export interface UsageTotals {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+}
+
+/** Sum of all usage records, cache fields included only when they appear. */
+export function sumUsage(usages: Usage[]): UsageTotals {
+  const totals: UsageTotals = {
+    prompt_tokens: 0,
+    completion_tokens: 0,
+    total_tokens: 0,
+  };
+  for (const usage of usages) {
+    totals.prompt_tokens += usage.prompt_tokens;
+    totals.completion_tokens += usage.completion_tokens;
+    totals.total_tokens += usage.total_tokens;
+    if (usage.cache_read_input_tokens) {
+      totals.cache_read_input_tokens =
+        (totals.cache_read_input_tokens || 0) + usage.cache_read_input_tokens;
+    }
+    if (usage.cache_creation_input_tokens) {
+      totals.cache_creation_input_tokens =
+        (totals.cache_creation_input_tokens || 0) +
+        usage.cache_creation_input_tokens;
+    }
+  }
+  return totals;
+}
+
 /**
  * Calculate token usage summary by model from usage array
  * @param usages Array of usage data from agent operations
@@ -83,26 +122,41 @@ export function calculateTokenSummary(
   return result;
 }
 
+/**
+ * Where the summary lines go. Called with no argument for a blank line.
+ */
+export type UsageLineWriter = (line?: string) => void;
+
 /**
  * Display usage summary in a formatted way
  * @param usages Array of usage data from agent operations
  * @param sessionFilePath Optional session file path to display
+ * @param writer Where the lines go — stdout by default; structured print modes
+ *   hand it stderr so their stdout stays pure JSON
  */
 export function displayUsageSummary(
   usages: Usage[],
   sessionFilePath?: string,
+  writer?: UsageLineWriter,
 ): void {
   if (usages.length === 0) {
     return; // No usage data to display
   }
 
+  const write: UsageLineWriter =
+    writer ??
+    ((line) => {
+      if (line === undefined) console.log();
+      else console.log(line);
+    });
+
   const summaries = calculateTokenSummary(usages);
 
-  console.log("\nToken Usage Summary:");
-  console.log("==================");
+  write("\nToken Usage Summary:");
+  write("==================");
 
   if (sessionFilePath) {
-    console.log(`Session: ${sessionFilePath}`);
+    write(`Session: ${sessionFilePath}`);
   }
 
   let totalPrompt = 0;
@@ -115,12 +169,10 @@ export function displayUsageSummary(
   let hasCacheData = false;
 
   for (const [, summary] of Object.entries(summaries)) {
-    console.log(`Model: ${summary.model}`);
-    console.log(`  Prompt tokens: ${summary.prompt_tokens.toLocaleString()}`);
-    console.log(
-      `  Completion tokens: ${summary.completion_tokens.toLocaleString()}`,
-    );
-    console.log(`  Total tokens: ${summary.total_tokens.toLocaleString()}`);
+    write(`Model: ${summary.model}`);
+    write(`  Prompt tokens: ${summary.prompt_tokens.toLocaleString()}`);
+    write(`  Completion tokens: ${summary.completion_tokens.toLocaleString()}`);
+    write(`  Total tokens: ${summary.total_tokens.toLocaleString()}`);
 
     // Display cache information if available
     if (
@@ -128,13 +180,13 @@ export function displayUsageSummary(
       summary.cache_creation_input_tokens
     ) {
       hasCacheData = true;
-      console.log("  Cache Usage:");
+      write("  Cache Usage:");
 
       if (
         summary.cache_read_input_tokens &&
         summary.cache_read_input_tokens > 0
       ) {
-        console.log(
+        write(
           `    Read from cache: ${summary.cache_read_input_tokens.toLocaleString()} tokens`,
         );
         totalCacheRead += summary.cache_read_input_tokens;
@@ -144,17 +196,17 @@ export function displayUsageSummary(
         summary.cache_creation_input_tokens &&
         summary.cache_creation_input_tokens > 0
       ) {
-        console.log(
+        write(
           `    Created cache: ${summary.cache_creation_input_tokens.toLocaleString()} tokens`,
         );
         totalCacheCreation += summary.cache_creation_input_tokens;
       }
     }
 
-    console.log(
+    write(
       `  Operations: ${summary.operations.agent_calls} agent calls, ${summary.operations.compactions} compactions`,
     );
-    console.log();
+    write();
 
     totalPrompt += summary.prompt_tokens;
     totalCompletion += summary.completion_tokens;
@@ -164,26 +216,24 @@ export function displayUsageSummary(
   }
 
   if (Object.keys(summaries).length > 1) {
-    console.log("Overall Total:");
-    console.log(`  Prompt tokens: ${totalPrompt.toLocaleString()}`);
-    console.log(`  Completion tokens: ${totalCompletion.toLocaleString()}`);
-    console.log(`  Total tokens: ${totalTokens.toLocaleString()}`);
+    write("Overall Total:");
+    write(`  Prompt tokens: ${totalPrompt.toLocaleString()}`);
+    write(`  Completion tokens: ${totalCompletion.toLocaleString()}`);
+    write(`  Total tokens: ${totalTokens.toLocaleString()}`);
 
     if (hasCacheData) {
-      console.log("  Cache Usage:");
+      write("  Cache Usage:");
       if (totalCacheRead > 0) {
-        console.log(
-          `    Read from cache: ${totalCacheRead.toLocaleString()} tokens`,
-        );
+        write(`    Read from cache: ${totalCacheRead.toLocaleString()} tokens`);
       }
       if (totalCacheCreation > 0) {
-        console.log(
+        write(
           `    Created cache: ${totalCacheCreation.toLocaleString()} tokens`,
         );
       }
     }
 
-    console.log(
+    write(
       `  Operations: ${totalAgentCalls} agent calls, ${totalCompactions} compactions`,
     );
   }

package/src/utils/worktree.ts

@@ -21,6 +21,12 @@ const execFileAsync = promisify(execFile);
 export interface WorktreeSession {
   name: string;
   path: string;
+  /**
+   * The branch the worktree was CREATED on — `worktree-<name>` for a worktree
+   * wave created, and what callers must record and hand back to
+   * `removeWorktree`. It is not read back from the worktree: an agent may have
+   * checked another branch out in there (see `removeWorktree`).
+   */
   branch: string;
   repoRoot: string;
   hasUncommittedChanges: boolean;
@@ -39,6 +45,12 @@ export interface WorktreeSession {
 const VALID_WORKTREE_SLUG_SEGMENT = /^[a-zA-Z0-9._-]+$/;
 const MAX_WORKTREE_SLUG_LENGTH = 64;
 
+/** Where `createWorktree` puts worktrees, relative to the repo root. */
+const WORKTREE_PARENT_SEGMENTS = [".wave", "worktrees"];
+
+/** Branch prefix `createWorktree` gives a worktree it creates. */
+const WORKTREE_BRANCH_PREFIX = "worktree-";
+
 /**
  * Validate a worktree name before any side effects. Names are slash-separated
  * slugs: every segment must be non-empty and contain only letters, digits,
@@ -164,8 +176,8 @@ async function createWorktreeInternal(
   options?: { baseRef?: "fresh" | "head"; baseBranch?: string },
 ): Promise<WorktreeSession> {
   const repoRoot = getGitMainRepoRoot(cwd);
-  const worktreePath = path.join(repoRoot, ".wave", "worktrees", name);
-  const branchName = `worktree-${name}`;
+  const worktreePath = path.join(repoRoot, ...WORKTREE_PARENT_SEGMENTS, name);
+  const branchName = `${WORKTREE_BRANCH_PREFIX}${name}`;
   const useHead = options?.baseRef === "head";
   const resolvedBaseBranch =
     options?.baseBranch ?? (useHead ? "HEAD" : getDefaultRemoteBranch(cwd));
@@ -384,6 +396,43 @@ function rmWorktreeDirWithFs(worktreePath: string): unknown | null {
   }
 }
 
+/**
+ * Waits between `fs.rmSync` attempts on the worktree directory. Mutable so
+ * tests can zero them out.
+ *
+ * The first attempt still runs immediately; these only spread the retries.
+ * Windows keeps a directory alive for as long as any process holds it as its
+ * cwd (a killed shell, `node --watch`, a test runner), and that handle is
+ * released asynchronously — the caller's teardown may well have returned before
+ * the OS let go (issue #2763: the same `rm -rf` succeeds a few seconds later by
+ * hand). Three attempts over ~0.9s covers the release lag without turning a
+ * genuinely locked directory into a multi-second stall.
+ */
+export const worktreeRemoveRetry = { delaysMs: [300, 600] };
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * `rmWorktreeDirWithFs` with the short retry above. Returns null once the
+ * directory is gone (or the deletion reported success), the last error
+ * otherwise. Existence is deliberately not probed here: the caller already
+ * decides "did it actually go" from the filesystem, and an extra stat per
+ * attempt would only make that harder to reason about.
+ */
+async function rmWorktreeDirWithRetries(
+  worktreePath: string,
+): Promise<unknown | null> {
+  let error = rmWorktreeDirWithFs(worktreePath);
+  for (const delayMs of worktreeRemoveRetry.delaysMs) {
+    if (!error) return null;
+    await sleep(delayMs);
+    error = rmWorktreeDirWithFs(worktreePath);
+  }
+  return error;
+}
+
 /**
  * Describe what is still on disk after a failed removal. Without this a
  * failure log cannot distinguish "directory already gone" from "the whole
@@ -410,10 +459,19 @@ export interface WorktreeChanges {
 /**
  * The linked worktree a directory sits in, derived from the filesystem only.
  * Same field semantics as `createWorktree`'s result, so a caller can hand it
- * straight to `removeWorktree`.
+ * straight to `removeWorktree` — except for `branch`, which is read off the
+ * worktree's HEAD and is therefore **the branch it has checked out now**, not
+ * the branch it was created on. Removal must pass the creation branch (the
+ * session's snapshot, or `worktreeCreationBranch`); see `removeWorktree`.
  */
 export interface DerivedWorktree {
   path: string;
+  /**
+   * The branch checked out in the worktree right now (`<gitdir>/HEAD`), or `""`
+   * for a detached HEAD. Informational: never use it as "the worktree's branch"
+   * for deletion — an agent may have checked a branch of the user's out in
+   * there.
+   */
   branch: string;
   repoRoot: string;
   hookBased: boolean;
@@ -504,6 +562,62 @@ export function deriveWorktreeInfo(
   }
 }
 
+/**
+ * The branch `createWorktree` created for a worktree, recovered from where that
+ * worktree sits: `<repoRoot>/.wave/worktrees/<name>` is on
+ * `worktree-<name>` (see `createWorktreeInternal`).
+ *
+ * This exists because git keeps no record of it. `git worktree list
+ * --porcelain` and `<gitdir>/HEAD` both report the branch a worktree has
+ * checked out *at the moment you ask*, so once an agent runs `git checkout
+ * <something-else>` inside the worktree they name that branch instead — the
+ * branch the user owns, possibly holding commits reachable from nowhere else.
+ * A removal must delete the branch wave created, and the path is the only
+ * surviving record of it besides a caller's own snapshot.
+ *
+ * The name is taken from the **tail** of `path` — every segment below
+ * `.wave/worktrees` — and the parent directory is never string-compared
+ * against `repoRoot`. The two paths reach us from different sources: `path` is
+ * whatever the OS or host handed over (`fs.mkdtempSync`, a session's cwd, a
+ * transcript header), while `repoRoot` is the path **git** canonicalized and
+ * wrote into `<gitdir>/commondir`. On Windows the same directory routinely
+ * arrives in two forms — 8.3 short name (`C:\Users\RUNNER~1\…`), unexpanded
+ * symlink/junction, drive-letter case — and Windows compares paths
+ * case-insensitively while a string compare does not, so the old
+ * `path.startsWith(parentDir)` called a legitimate worktree "not wave's" and
+ * the creation branch was never deleted. That is what turned `check-windows`
+ * red on main after #2721. Whether the path really sits in *this* repo's
+ * directory is not decidable from the strings anyway; `removeWorktree` asks git
+ * whether the branch it is about to delete exists there instead.
+ *
+ * Returns `undefined` for a path that is not laid out under a
+ * `.wave/worktrees` directory (a hand-made `git worktree add`, a hook-managed
+ * one): its branch is not wave's to name — and for an unknown `repoRoot`,
+ * because a caller that cannot resolve the repository has nothing to look a
+ * branch up in.
+ */
+export function worktreeCreationBranch(
+  worktree: Pick<DerivedWorktree, "path" | "repoRoot">,
+): string | undefined {
+  if (!worktree.repoRoot || !worktree.path) return undefined;
+  const segments = path.resolve(worktree.path).split(path.sep).filter(Boolean);
+  // Deepest `.wave/worktrees` pair first: a repository checked out *inside*
+  // another wave worktree still names the innermost worktree.
+  for (let i = segments.length - 2; i >= 0; i--) {
+    if (
+      segments[i] !== WORKTREE_PARENT_SEGMENTS[0] ||
+      segments[i + 1] !== WORKTREE_PARENT_SEGMENTS[1]
+    ) {
+      continue;
+    }
+    // Names are slug paths (see validateWorktreeSlug), so the branch keeps the
+    // slashes; a path that ends at `worktrees` itself names nothing.
+    const name = segments.slice(i + 2).join("/");
+    return name ? `${WORKTREE_BRANCH_PREFIX}${name}` : undefined;
+  }
+  return undefined;
+}
+
 /**
  * Count what deleting a worktree would throw away, so the caller can warn
  * before it happens. Both counts are best-effort: an unknown base branch (never
@@ -547,18 +661,35 @@ export async function getWorktreeChanges(
 }
 
 /**
- * Remove a git worktree and its associated branch
- * @param session Worktree session details
+ * Remove a git worktree and the branch it was created on.
+ * @param session Worktree session details. `branch` must be the branch the
+ *   worktree was CREATED on (a snapshot the caller recorded at creation time,
+ *   or `worktreeCreationBranch`) — never the branch that directory happens to
+ *   have checked out, which an in-session `git checkout` can change.
  *
  * Removal is best-effort: `git worktree remove --force` deletes the worktree
  * metadata before the working directory, and on Windows its recursive deletion
  * is MAX_PATH-limited — deep paths (e.g. node_modules) can fail with "Filename
  * too long", leaving an orphan directory. When git fails we fall back to
  * fs.rmSync with an extended-length path (bypasses MAX_PATH) and prune stale
- * metadata. Failures are logged; when the directory survives, its branch is
- * deliberately kept so the leftover checkout stays reachable through git.
+ * metadata. The fallback retries a couple of times (`worktreeRemoveRetry`): a
+ * directory locked by a process that is only now exiting — the usual Windows
+ * case — becomes deletable a moment later. Failures are logged; when the
+ * directory still survives, its branch is deliberately kept so the leftover
+ * checkout stays reachable through git.
+ *
+ * Returns whether the directory is actually gone (not whether the removal was
+ * attempted) — a caller that reports the outcome to a user must print it rather
+ * than assume success, because every failure mode above is silent by design.
+ *
+ * The branch is deleted only when `repoRoot` actually has it (`branchExists`),
+ * so a name inferred from the path — which no longer depends on how the two
+ * path strings are spelled, see `worktreeCreationBranch` — can never delete
+ * something else.
  */
-export async function removeWorktree(session: WorktreeSession): Promise<void> {
+export async function removeWorktree(
+  session: WorktreeSession,
+): Promise<boolean> {
   // Hook-based worktrees are removed by the WorktreeRemove hook; wave never
   // runs `git worktree remove` for them. If no WorktreeRemove hook is
   // configured, the worktree is left in place with a warning (CC semantics).
@@ -578,7 +709,9 @@ export async function removeWorktree(session: WorktreeSession): Promise<void> {
         `No WorktreeRemove hook configured, hook-based worktree left at: ${session.path}`,
       );
     }
-    return;
+    // The hook decides what it deletes (it may be a VCS wave knows nothing
+    // about), so the filesystem is the only honest answer.
+    return !fs.existsSync(session.path);
   }
 
   const repoRoot = session.repoRoot;
@@ -602,7 +735,7 @@ export async function removeWorktree(session: WorktreeSession): Promise<void> {
           `path=${session.path} residue=${probeResidue(session.path)} — ` +
           `deleting with fs.rmSync instead`,
       );
-      const rmError = rmWorktreeDirWithFs(session.path);
+      const rmError = await rmWorktreeDirWithRetries(session.path);
       if (rmError) {
         logger.error(
           `Failed to remove worktree or branch: path=${session.path} ` +
@@ -617,7 +750,7 @@ export async function removeWorktree(session: WorktreeSession): Promise<void> {
       `git worktree remove failed, falling back to fs.rmSync: ${describeGitFailure(error)}`,
       error,
     );
-    const rmError = rmWorktreeDirWithFs(session.path);
+    const rmError = await rmWorktreeDirWithRetries(session.path);
     if (rmError) {
       // Removal failures are best-effort, so this line is often the only trace
       // of an orphaned worktree directory: record which stage failed, why, and
@@ -645,16 +778,39 @@ export async function removeWorktree(session: WorktreeSession): Promise<void> {
   // still on disk, and the branch is the only ref still leading back to it.
   if (fs.existsSync(session.path)) {
     logger.warn(
-      `Worktree directory survived removal — keeping ${session.branch} so the ` +
-        `leftover checkout stays reachable: path=${session.path} ` +
-        `residue=${probeResidue(session.path)}`,
+      `Worktree directory survived removal — keeping ` +
+        `${session.branch || "its branches"} so the leftover checkout stays ` +
+        `reachable: path=${session.path} residue=${probeResidue(session.path)}`,
     );
-    return;
+    return false;
   }
 
   // Delete the worktree's own branch. Branches the user checked out inside the
   // worktree are never touched — they may hold commits that are not reachable
-  // from anywhere else (aligned with Claude Code).
+  // from anywhere else (aligned with Claude Code). That is why `session.branch`
+  // has to be the creation-time branch: reading it back from the worktree (its
+  // HEAD) would name whatever was checked out last, i.e. exactly the branch
+  // that must survive. An unknown branch deletes nothing at all.
+  if (!session.branch) {
+    logger.warn(
+      `No branch recorded for the worktree at ${session.path} — keeping every ` +
+        `branch rather than deleting the one it had checked out`,
+    );
+    return true;
+  }
+  // A name derived from the worktree's path layout (rather than snapshotted at
+  // creation) is only a candidate: the layout says what name wave *would* have
+  // used, not that this repository has that branch. Ask git before deleting —
+  // a name that does not resolve here means the guess was wrong or the branch
+  // is already gone, and either way the safe outcome is to delete nothing.
+  if (!(await branchExists(repoRoot, session.branch))) {
+    logger.warn(
+      `No branch ${session.branch} in ${repoRoot} — keeping every branch ` +
+        `(the worktree at ${session.path} was not created on it, or it is ` +
+        `already gone)`,
+    );
+    return true;
+  }
   try {
     await execFileAsync("git", ["branch", "-D", session.branch], {
       cwd: repoRoot,
@@ -662,4 +818,54 @@ export async function removeWorktree(session: WorktreeSession): Promise<void> {
   } catch {
     // Ignore errors deleting original branch
   }
+  return true;
+}
+
+/**
+ * What to tell the user when `removeWorktree` returned `false`: where the
+ * directory still is, which branch was kept for it (removal keeps that ref so
+ * the leftover checkout stays reachable through git), and the two commands that
+ * finish the job by hand.
+ *
+ * Single-sourced because every CLI entry point that removes a worktree used to
+ * print a flat "Done." whether or not anything was deleted — TUI exit, `-p`, and
+ * `wave daemon destroy --remove-worktree` (issue #2763). One wording, one place.
+ */
+export function describeWorktreeSurvival(worktree: {
+  path: string;
+  branch: string;
+  repoRoot: string;
+}): string {
+  const branch = worktree.branch ? `branch ${worktree.branch}` : "every branch";
+  return (
+    `Worktree directory survived at ${worktree.path}; kept ${branch} so the ` +
+    `leftover checkout stays reachable\n` +
+    `Clean up manually: rm -rf ${worktree.path}` +
+    (worktree.branch
+      ? ` && git -C ${worktree.repoRoot} branch -D ${worktree.branch}`
+      : "")
+  );
+}
+
+/**
+ * Does `repoRoot` have a local branch called exactly `branch`?
+ *
+ * `git branch --list` takes a glob pattern, so the listing is compared back
+ * against the exact name instead of trusting "it printed something". Any git
+ * failure counts as "no such branch" — the caller then keeps every branch.
+ */
+async function branchExists(
+  repoRoot: string,
+  branch: string,
+): Promise<boolean> {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["branch", "--list", "--format=%(refname:short)", branch],
+      { cwd: repoRoot, encoding: "utf8" },
+    );
+    return stdout.trim() === branch;
+  } catch {
+    return false;
+  }
 }

package/src/utils/rewindCheckpoints.ts

@@ -1,14 +0,0 @@
-import type { Message } from "wave-agent-sdk";
-
-/**
- * 判断一条 user 消息能否作为 /rewind 检查点。
- * 后台任务通知（task_notification）与 hook 注入的消息都是系统生成、
- * 用户不可见的（meta），不能作为回滚点。bash 模式命令消息
- * （`!ls`）是用户真正输入，与 fork skill 命令消息一致，可作为回滚点。
- * CLI 交互式选择器与 stdio listRewindCheckpoints 共用此判定，避免两处漂移。
- */
-export function isUserCheckpointMessage(m: Message): boolean {
-  if (m.role !== "user" || m.isMeta) return false;
-  if (m.blocks.some((b) => b.type === "task_notification")) return false;
-  return true;
-}