dsh-plugin-worktrees 0.1.0

package/lib/state-store.js

@@ -0,0 +1,512 @@
+/**
+ * StateStore — DESIGN §7 state & persistence for dsh-worktrees.
+ *
+ * One JSON file, atomically replaced on every write. Family precedent:
+ * dsh-plugin-subagents `lib/registry.js` (tmp + rename, owner-only 0600,
+ * `__proto__` key guard); dsh-atomic-write's `writeFileAtomic` semantics
+ * (wx exclusive create + rename + mode enforcement + symlink resistance)
+ * are the spec this implements locally, zero-dependency.
+ *
+ * Write discipline (§7.1):
+ *   deep-copy + sanitize the in-memory state → `JSON.stringify(,2)` →
+ *   tmp file in the SAME directory as the target — `openSync(tmp, "wx")`
+ *   (exclusive create; a symlink pre-planted at the tmp name fails loudly
+ *   instead of being followed), mode 0o600, best-effort chmod to force the
+ *   mode on filesystems that ignore the create mode → `renameSync` atomic
+ *   replace. A random suffix on the tmp name makes collisions (and hence
+ *   EEXIST races between concurrent writers) practically impossible; a
+ *   failed write removes the tmp best-effort so nothing litters the state
+ *   directory.
+ *
+ * Read discipline (§7.1):
+ *   `load()` reads the file (missing → initial state; unparseable → loud
+ *   error naming the path), rebuilds every record through the same
+ *   sanitizer (dangerous keys — `__proto__` / `constructor` / `prototype` —
+ *   are dropped RECURSIVELY, in both the load and the upsert direction),
+ *   and prunes terminal merge jobs to the newest 200.
+ *
+ * After `load()`, the in-memory index IS the truth (§7.2: single process;
+ * all writes happen inside the serial apply chain or a tool's single-step
+ * critical section). Mutations go through the upsert methods; `persist()`
+ * flushes the snapshot back atomically. The map getters hand out the live
+ * internal maps (zero-copy read access for services); the contract is
+ * read-mostly — structural abuse through those references is bounded
+ * because every persist() re-sanitizes a deep copy, so nothing dangerous
+ * or non-JSON ever reaches disk and the JSON round-trip stays exact.
+ */
+import {
+  chmodSync,
+  closeSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { randomBytes } from "node:crypto";
+import { dirname } from "node:path";
+
+/**
+ * Merge-job states that end the job's lifecycle (DESIGN §5.2.2 state
+ * machine). Terminal jobs are pruned to the newest `keep` (§7.1); `conflicted`
+ * is NOT terminal — it is an active state whose worktree is the live scene.
+ */
+export const TERMINAL_JOB_STATES = new Set([
+  "succeeded",
+  "failed",
+  "cancelled",
+  "resolved",
+]);
+
+/**
+ * Merge-job states that hold the per-branch queue slot (§6 invariants: at
+ * most one active job per repo+integrationBranch).
+ */
+export const ACTIVE_JOB_STATES = new Set(["queued", "applying", "conflicted"]);
+
+/**
+ * Key names that must never become own properties of stored records: an
+ * own `__proto__` data property (exactly what `JSON.parse` produces for a
+ * hostile document) pollutes prototypes the moment anyone merges the record
+ * with `Object.assign`; `constructor` / `prototype` are the classic gadget
+ * chain companions. Dropped on upsert AND on load, recursively — the
+ * registry.js precedent.
+ */
+const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+/** Terminal-job retention bound applied on every load() (§7.1). */
+const DEFAULT_PRUNE_KEEP = 200;
+
+/** @returns {StateFile} */
+function initialState() {
+  return { version: 1, worktrees: {}, jobs: {}, repos: {} };
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Deep copy that produces ONLY JSON-round-trip-safe data and drops dangerous
+ * keys at every level. This is simultaneously:
+ *  - the upsert-time intake sanitizer (hostile record fields never enter the
+ *    in-memory index),
+ *  - the persist-time deep copy (§7.1: write = deep copy → stringify), and
+ *  - the load-time sanitizer (a hand-tampered state file cannot smuggle a
+ *    `__proto__` key back into memory).
+ *
+ * JSON semantics are mirrored exactly so `persist() → load()` compares
+ * deep-equal: `undefined` / functions / symbols are dropped from objects and
+ * become `null` inside arrays, non-finite numbers become `null`, and objects
+ * with a `toJSON()` (e.g. Date) are converted through it. A true cycle
+ * throws a loud TypeError (a DAG — the same sub-object referenced twice — is
+ * fine and stringifies twice, exactly like JSON.stringify).
+ *
+ * @param {unknown} value
+ * @param {boolean} inArray  array-position context: JSON nulls unrepresentable
+ *   values instead of dropping them.
+ * @param {Set<object>} seen  cycle guard (entries removed on exit, so only
+ *   cycles trip it, not shared references).
+ * @returns {unknown}
+ */
+function sanitizeDeep(value, inArray = false, seen = new Set()) {
+  if (value === null) return null;
+  const type = typeof value;
+  if (type === "string" || type === "boolean") return value;
+  if (type === "number") return Number.isFinite(value) ? value : null;
+  if (type === "undefined" || type === "symbol" || type === "function" || type === "bigint") {
+    return inArray ? null : undefined; // caller drops the undefined entries
+  }
+  if (typeof value.toJSON === "function") {
+    return sanitizeDeep(value.toJSON(), inArray, seen);
+  }
+  if (seen.has(value)) {
+    throw new TypeError("state-store: circular reference in state record");
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((element) => sanitizeDeep(element, true, seen));
+    }
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      if (DANGEROUS_KEYS.has(key)) continue;
+      const clean = sanitizeDeep(entry, false, seen);
+      if (clean !== undefined) out[key] = clean;
+    }
+    return out;
+  } finally {
+    seen.delete(value);
+  }
+}
+
+/**
+ * Rebuild one top-level map from parsed data: non-object maps fail LOUD
+ * (the crash reconcile must not silently trust a corrupt file), while
+ * non-object ENTRIES are unusable as records and are dropped.
+ *
+ * @param {unknown} value
+ * @param {string} name
+ * @param {string} path
+ * @returns {Record<string, object>}
+ */
+function requireMap(value, name, path) {
+  if (value === undefined) return {};
+  if (!isPlainObject(value)) {
+    throw new Error(
+      `state-store: state file ${path} is corrupt: "${name}" must be an object`,
+    );
+  }
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (DANGEROUS_KEYS.has(key)) continue;
+    if (isPlainObject(entry)) out[key] = entry;
+  }
+  return out;
+}
+
+/**
+ * @typedef {object} WorktreeRecord  DESIGN §5.2.2 (+ §10 seam fields).
+ * @property {string} id
+ * @property {string} repoKey
+ * @property {string} repoRoot
+ * @property {string} branch
+ * @property {string} path
+ * @property {string} baseCommit
+ * @property {string} integrationBranch
+ * @property {string} sessionId
+ * @property {string} task
+ * @property {"active"|"merging"|"merged"|"conflicted"|"abandoned"|"vanished"} state
+ * @property {string} [headCommit]
+ * @property {string} [mergeJobId]
+ * @property {string} [note]
+ * @property {"tool"|"dag"} [origin]  creation provenance (§10 seam);
+ *   absent on records written before the engine facade existed — the
+ *   sanitize pass preserves whatever is present, old files stay valid.
+ * @property {string} [correlationId]  create-time correlation token (the
+ *   DAG attempt id); the reuse-ownership gate's evidence. Optional for the
+ *   same backward-compatibility reason.
+ * @property {number} createdAt
+ * @property {number} updatedAt
+ */
+
+/**
+ * @typedef {object} MergeJobRecord  DESIGN §5.2.2.
+ * @property {string} id
+ * @property {string} repoKey
+ * @property {string} integrationBranch
+ * @property {string} worktreeId
+ * @property {string} sourceBranch
+ * @property {string} sourceHead
+ * @property {number} orderIndex
+ * @property {"queued"|"applying"|"succeeded"|"conflicted"|"failed"|"cancelled"|"resolved"} state
+ * @property {string} [integrationWorktree]
+ * @property {string} [integrationHeadBefore]
+ * @property {string} [integratedCommit]
+ * @property {string[]} [conflictFiles]
+ * @property {string} [error]
+ * @property {string} [message]
+ * @property {"tool"|"dag"} origin
+ * @property {string} [correlationId]
+ * @property {number} createdAt
+ * @property {number} updatedAt
+ */
+
+/**
+ * @typedef {object} RepoRecord  DESIGN §5.2.2 — crash-reconcile enumeration
+ *   source (`repoKey → { root, lastSeenAt }`).
+ * @property {string} root
+ * @property {number} lastSeenAt
+ */
+
+/**
+ * @typedef {object} StateFile  state.json root shape.
+ * @property {number} version
+ * @property {Record<string, WorktreeRecord>} worktrees
+ * @property {Record<string, MergeJobRecord>} jobs
+ * @property {Record<string, RepoRecord>} repos
+ */
+
+/**
+ * Create a StateStore bound to one state.json path. Pure ESM, zero runtime
+ * dependencies (node:fs / node:crypto / node:path only), Node >= 18.
+ *
+ * @param {{path: string}} options  `path` is required — the default location
+ *   (`~/.dsh/dsh-worktrees/state.json`) is resolved by the config layer
+ *   (DESIGN §7.1 `statePath`), not here.
+ * @returns {{
+ *   load: () => StateFile,
+ *   persist: () => void,
+ *   worktrees: Record<string, WorktreeRecord>,
+ *   jobs: Record<string, MergeJobRecord>,
+ *   repos: Record<string, RepoRecord>,
+ *   upsertWorktree: (record: WorktreeRecord) => WorktreeRecord,
+ *   upsertJob: (record: MergeJobRecord) => MergeJobRecord,
+ *   pruneTerminalJobs: (keep?: number) => number,
+ *   findActiveJob: (repoKey: string, integrationBranch: string) => MergeJobRecord | undefined,
+ *   findQueuedJobs: (repoKey: string, integrationBranch: string) => MergeJobRecord[],
+ *   nextOrderIndex: (repoKey: string, integrationBranch: string) => number,
+ * }}
+ */
+export function createStateStore({ path }) {
+  if (typeof path !== "string" || path.length === 0) {
+    throw new Error("state-store: createStateStore requires a { path } string");
+  }
+
+  let state = initialState();
+
+  /**
+   * Read the state file into memory (startup path; §7.1 "读 = 启动一次").
+   * Missing file → initial state. Unreadable/unparseable/corrupt-shaped
+   * file → loud error naming the path. Terminal jobs are pruned to the
+   * newest 200 immediately; the pruned result flushes on the next persist().
+   *
+   * @returns {StateFile}
+   */
+  function load() {
+    let raw;
+    try {
+      raw = readFileSync(path, "utf8");
+    } catch (error) {
+      if (error && error.code === "ENOENT") {
+        state = initialState();
+        pruneTerminalJobs(DEFAULT_PRUNE_KEEP);
+        return state;
+      }
+      throw new Error(`state-store: cannot read state file ${path}: ${error.message}`);
+    }
+    let doc;
+    try {
+      doc = JSON.parse(raw);
+    } catch (error) {
+      throw new Error(`state-store: state file ${path} is not valid JSON: ${error.message}`);
+    }
+    if (!isPlainObject(doc)) {
+      throw new Error(
+        `state-store: state file ${path} is corrupt: expected a JSON object at the root`,
+      );
+    }
+    const clean = sanitizeDeep(doc);
+    state = {
+      version:
+        typeof clean.version === "number" && Number.isFinite(clean.version)
+          ? clean.version
+          : 1,
+      worktrees: requireMap(clean.worktrees, "worktrees", path),
+      jobs: requireMap(clean.jobs, "jobs", path),
+      repos: requireMap(clean.repos, "repos", path),
+    };
+    pruneTerminalJobs(DEFAULT_PRUNE_KEEP);
+    return state;
+  }
+
+  /**
+   * Atomically flush the in-memory state to disk (§7.1 write discipline).
+   * Throws on failure (after best-effort tmp cleanup) — callers in the apply
+   * chain surface the error; the previous state file is never damaged.
+   */
+  function persist() {
+    const snapshot = sanitizeDeep(state);
+    const json = JSON.stringify(snapshot, null, 2);
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+      // "wx" = O_CREAT | O_EXCL: exclusive create. A leftover tmp (or a
+      // pre-planted symlink) at this random name fails loudly instead of
+      // being followed or silently overwritten.
+      const fd = openSync(tmp, "wx", 0o600);
+      try {
+        writeFileSync(fd, json, "utf8");
+      } finally {
+        closeSync(fd);
+      }
+      // Best-effort mode enforcement (registry.js precedent): belt-and-braces
+      // against filesystems that weaken the create mode under umask.
+      try {
+        chmodSync(tmp, 0o600);
+      } catch {
+        /* best-effort */
+      }
+      renameSync(tmp, path);
+    } catch (error) {
+      // Never leave a half-written tmp behind; rethrow loudly.
+      try {
+        rmSync(tmp, { force: true });
+      } catch {
+        /* best-effort */
+      }
+      throw new Error(`state-store: failed to persist state to ${path}: ${error.message}`, {
+        cause: error,
+      });
+    }
+  }
+
+  /**
+   * Upsert one record into a map by id: sanitizer first (dangerous keys and
+   * non-JSON values never enter the index), then `updatedAt = Date.now()`;
+   * `createdAt` is set on first insert and PRESERVED across updates (a
+   * caller re-upserting a fetched record keeps its original createdAt too).
+   *
+   * @param {Record<string, object>} map
+   * @param {unknown} record
+   * @param {"Worktree"|"Job"} kind
+   */
+  function upsert(map, record, kind) {
+    if (!isPlainObject(record)) {
+      throw new Error(`state-store: upsert${kind} requires a record object`);
+    }
+    const id = record.id;
+    if (typeof id !== "string" || id.length === 0) {
+      throw new Error(`state-store: upsert${kind} requires a record with a non-empty string id`);
+    }
+    if (DANGEROUS_KEYS.has(id)) {
+      // Assigning such an id as a key would set the map's prototype instead
+      // of creating an entry — refuse loudly (ids are internal, generated).
+      throw new Error(`state-store: upsert${kind} refused dangerous record id "${id}"`);
+    }
+    const clean = sanitizeDeep(record);
+    const existing = map[id];
+    if (existing !== undefined && existing.createdAt !== undefined) {
+      clean.createdAt = existing.createdAt;
+    }
+    if (clean.createdAt === undefined) {
+      clean.createdAt = Date.now();
+    }
+    clean.updatedAt = Date.now();
+    map[id] = clean;
+    return clean;
+  }
+
+  /**
+   * Upsert a worktree record (§5.2.2 shape). Not auto-persisted — callers
+   * flush explicitly inside their critical section.
+   * @param {WorktreeRecord} record
+   * @returns {WorktreeRecord}
+   */
+  function upsertWorktree(record) {
+    return upsert(state.worktrees, record, "Worktree");
+  }
+
+  /**
+   * Upsert a merge-job record (§5.2.2 shape). Not auto-persisted.
+   * @param {MergeJobRecord} record
+   * @returns {MergeJobRecord}
+   */
+  function upsertJob(record) {
+    return upsert(state.jobs, record, "Job");
+  }
+
+  /**
+   * Prune terminal jobs (succeeded/failed/cancelled/resolved) to the newest
+   * `keep` by updatedAt, deleting the rest. Active jobs are never touched.
+   * Ties on updatedAt (same millisecond) break by insertion order — the
+   * OLDEST entries are pruned deterministically (registry.js precedent).
+   *
+   * @param {number} [keep=200]
+   * @returns {number} count of pruned jobs.
+   */
+  function pruneTerminalJobs(keep = DEFAULT_PRUNE_KEEP) {
+    const limit = Math.max(0, Math.floor(Number(keep) || 0));
+    const terminal = [];
+    const ids = Object.keys(state.jobs);
+    for (let index = 0; index < ids.length; index += 1) {
+      const job = state.jobs[ids[index]];
+      if (job !== undefined && TERMINAL_JOB_STATES.has(job.state)) {
+        terminal.push({ id: ids[index], at: Number(job.updatedAt) || 0, seq: index });
+      }
+    }
+    if (terminal.length <= limit) return 0;
+    terminal.sort((a, b) => b.at - a.at || b.seq - a.seq); // newest first
+    for (const { id } of terminal.slice(limit)) {
+      delete state.jobs[id];
+    }
+    return terminal.length - limit;
+  }
+
+  /**
+   * The active (queued/applying/conflicted) job for one repo+integration
+   * branch, or undefined. The invariant allows at most one; if a crash ever
+   * leaves several, the newest by updatedAt wins (most useful for reconcile).
+   *
+   * @param {string} repoKey
+   * @param {string} integrationBranch
+   * @returns {MergeJobRecord | undefined}
+   */
+  function findActiveJob(repoKey, integrationBranch) {
+    let best = null;
+    for (const job of Object.values(state.jobs)) {
+      if (job.repoKey !== repoKey || job.integrationBranch !== integrationBranch) continue;
+      if (!ACTIVE_JOB_STATES.has(job.state)) continue;
+      const at = Number(job.updatedAt) || 0;
+      if (best === null || at >= (Number(best.updatedAt) || 0)) best = job;
+    }
+    return best === null ? undefined : best;
+  }
+
+  /**
+   * Queued jobs for one repo+integration branch, ascending by orderIndex
+   * (stable: equal/missing orderIndex keeps insertion order; missing sorts
+   * last). This is the drain order of the serial apply chain.
+   *
+   * @param {string} repoKey
+   * @param {string} integrationBranch
+   * @returns {MergeJobRecord[]}
+   */
+  function findQueuedJobs(repoKey, integrationBranch) {
+    const orderIndexOf = (job) => {
+      const n = Number(job.orderIndex);
+      return Number.isFinite(n) ? n : Infinity;
+    };
+    return Object.values(state.jobs)
+      .filter(
+        (job) =>
+          job.repoKey === repoKey &&
+          job.integrationBranch === integrationBranch &&
+          job.state === "queued",
+      )
+      .sort((a, b) => orderIndexOf(a) - orderIndexOf(b));
+  }
+
+  /**
+   * Next queue slot for one repo+integration branch: max orderIndex across
+   * that branch's jobs (any state) + 1. With no jobs the first slot is 0;
+   * successive calls without deletions are strictly monotonic.
+   *
+   * @param {string} repoKey
+   * @param {string} integrationBranch
+   * @returns {number}
+   */
+  function nextOrderIndex(repoKey, integrationBranch) {
+    let max = -1;
+    for (const job of Object.values(state.jobs)) {
+      if (job.repoKey !== repoKey || job.integrationBranch !== integrationBranch) continue;
+      const n = Number(job.orderIndex);
+      if (Number.isFinite(n) && n > max) max = n;
+    }
+    return max + 1;
+  }
+
+  return {
+    load,
+    persist,
+    upsertWorktree,
+    upsertJob,
+    pruneTerminalJobs,
+    findActiveJob,
+    findQueuedJobs,
+    nextOrderIndex,
+    // Live internal maps (read-mostly contract — see the file header). The
+    // getters re-read `state` on every access, so a load() rebinding is
+    // always reflected.
+    get worktrees() {
+      return state.worktrees;
+    },
+    get jobs() {
+      return state.jobs;
+    },
+    get repos() {
+      return state.repos;
+    },
+  };
+}

package/lib/tools/worktree-cleanup.js

@@ -0,0 +1,127 @@
+/**
+ * `worktree_cleanup` tool (T09, DESIGN §5.8).
+ *
+ * Thin tool layer: parameters schema, worktree_id-or-path input resolution,
+ * and a projection of the WorktreeService.cleanup result into the §5.8
+ * return shape. The double-confirmation protection (force && acknowledge,
+ * two INDEPENDENT booleans) lives in the engine; `cleanup_protected`
+ * errors re-throw verbatim so the surfaced message keeps its evidence
+ * (sourceHead / integration head / the force+acknowledge usage hint).
+ *
+ * deps contract:
+ *  - service (required) createWorktreeService() product;
+ *  - cfg     (optional) reserved for T10 wiring parity (unused today).
+ *
+ * json-safe discipline (E3): the vanished-path `note` is a conditional
+ * spread; no key ever carries an `undefined` value.
+ */
+
+import { defineTool } from '@deepseek-ai/dsh-tools'
+
+/** Registered tool name (DESIGN §5.8). */
+const TOOL_NAME = 'worktree_cleanup'
+
+/** A message already starting with a stable snake_case code stays verbatim. */
+const CODED_MESSAGE = /^[a-z][a-z0-9_]*(\s*—|:)/
+
+/** Coded engine errors pass through; uncoded ones get the tool prefix. */
+function surfaceError(error) {
+  const message = String(error instanceof Error ? error.message : error)
+  if (CODED_MESSAGE.test(message)) throw error
+  throw new Error(`${TOOL_NAME}: ${message}`)
+}
+
+/**
+ * Register the `worktree_cleanup` tool (DESIGN §5.8).
+ *
+ * @param {Object} ctx host ctx (needs ctx.tools.register)
+ * @param {Object} deps see the module header for the contract
+ */
+export function registerWorktreeCleanupTool(ctx, deps = {}) {
+  const { service } = deps
+  if (!service || typeof service.cleanup !== 'function') {
+    throw new Error(
+      `${TOOL_NAME}: deps.service must be a WorktreeService (createWorktreeService product)`,
+    )
+  }
+
+  ctx.tools.register(defineTool({
+    name: TOOL_NAME,
+    description:
+      'Remove one managed worktree and — unless keep_branch — its task branch, or prune a vanished record. '
+      + 'PROTECTION: a worktree whose work is NOT yet integrated is only removed with the DOUBLE confirmation force:true AND acknowledge:true (two independent booleans — a single force is not enough); otherwise cleanup_protected is raised with the evidence. '
+      + 'Unintegrated means EITHER the task branch head has not reached the integration branch, OR the integration branch does not exist yet (no merge has run) while the worktree holds commits past its base — both are unmerged work. '
+      + 'A merged worktree (worktree_merge succeeded) needs no force. Use worktree_list first to pick the record.',
+    parameters: {
+      worktree_id: {
+        type: 'string',
+        description: 'Worktree id (alternative: path).',
+      },
+      path: {
+        type: 'string',
+        description: 'Absolute worktree path (alternative: worktree_id).',
+      },
+      force: {
+        type: 'boolean',
+        description:
+          'Also remove a worktree whose branch is NOT yet integrated (default false → protected).',
+      },
+      acknowledge: {
+        type: 'boolean',
+        description:
+          'Second confirmation gate: must be true together with force to delete unmerged work. Never implied.',
+      },
+      keep_branch: {
+        type: 'boolean',
+        description: 'Remove the worktree directory but keep the branch (default false).',
+      },
+    },
+    output: {
+      schema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          kind: { type: 'string', required: true, const: 'cleanup' },
+          id: { type: 'string', required: true },
+          removed_worktree: { type: 'boolean', required: true },
+          removed_branch: { type: 'boolean', required: true },
+          note: { type: 'string' },
+        },
+      },
+      render: (_args, value) => [{
+        type: 'text',
+        text: `cleanup ${value.id}: worktree=${value.removed_worktree ? 'removed' : 'absent'} branch=${value.removed_branch ? 'removed' : 'kept'}${value.note ? ` (${value.note})` : ''}`,
+      }],
+    },
+    // Deletes shared state (record + git objects) behind a check-then-act
+    // protection gate; sibling calls must never interleave.
+    isConcurrencySafe: () => false,
+    async execute(args) {
+      try {
+        const idOrPath = args.worktree_id !== undefined ? args.worktree_id : args.path
+        if (idOrPath === undefined || idOrPath === '') {
+          throw new Error(
+            `${TOOL_NAME}: worktree_id_or_path_missing — pass worktree_id (from worktree_create) or the absolute worktree path`,
+          )
+        }
+
+        const result = await service.cleanup({
+          idOrPath,
+          ...(args.force !== undefined ? { force: args.force } : {}),
+          ...(args.acknowledge !== undefined ? { acknowledge: args.acknowledge } : {}),
+          ...(args.keep_branch !== undefined ? { keepBranch: args.keep_branch } : {}),
+        })
+
+        return {
+          kind: 'cleanup',
+          id: result.id,
+          removed_worktree: result.removedWorktree,
+          removed_branch: result.removedBranch,
+          ...(typeof result.note === 'string' ? { note: result.note } : {}),
+        }
+      } catch (error) {
+        surfaceError(error)
+      }
+    },
+  }))
+}