mandrel 2.66.0 → 2.67.0

package/.agents/scripts/lib/temp-retention.js

@@ -1,6 +1,7 @@
 /**
  * Allowlisted auto-purge of spent temp artifacts: only a declared class's
- * entries are candidates; the rest are reported, never touched. Never throws
+ * entries are candidates; the rest are reported, never touched by the
+ * auto-purge (only `/clean-temp`'s operator-confirmed path). Never throws
  * — a failed purge must not fail a land, boot, or persist.
  */
 
@@ -13,6 +14,14 @@ import {
   tempRootFrom,
 } from './config/temp-paths.js';
 import { Logger } from './Logger.js';
+import {
+  KEEP_BASENAMES,
+  removeSparingKept,
+  safeReaddir,
+  sizeOf,
+} from './temp-removal.js';
+
+export { KEEP_BASENAMES };
 
 /**
  * Defaults for `delivery.tempRetention`; purge is on unless turned off.
@@ -26,6 +35,7 @@ export const TEMP_RETENTION_DEFAULTS = Object.freeze({
     validationEvidence: true,
     auditResults: true,
     planDirs: true,
+    scratch: true,
   }),
 });
 
@@ -33,12 +43,6 @@ export const PURGE_CLASS_NAMES = Object.freeze(
   Object.keys(TEMP_RETENTION_DEFAULTS.classes),
 );
 
-/**
- * Never deleted, re-checked at the deletion site: `signals.ndjson` is read
- * long after merge and its loss is silent and unrecoverable.
- */
-export const KEEP_BASENAMES = Object.freeze(['signals.ndjson']);
-
 /** Explicit allowlist: an untaught file in a Story dir is kept. */
 const STORY_EVIDENCE_BASENAMES = Object.freeze([
   'validation-evidence.json',
@@ -49,6 +53,9 @@ const STORY_EVIDENCE_BASENAMES = Object.freeze([
 /** Framework-owned, never purged (`*.lock` files are also skipped). */
 const RESERVED_TOP_LEVEL = Object.freeze(['qa', 'cache']);
 
+/** Agent-authored scratch: `scratch/story-<id>/` or any other child. */
+const SCRATCH_DIRNAME = 'scratch';
+
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 
 const STORY_DIR_PATTERN = /^story-(\d+)$/;
@@ -77,50 +84,6 @@ export function resolveTempRetention(config) {
   };
 }
 
-/**
- * `readdir` yielding `[]` for an absent or unreadable directory.
- *
- * @param {typeof fsPromises} fsp
- * @param {string} dir
- * @returns {Promise<import('node:fs').Dirent[]>}
- */
-async function safeReaddir(fsp, dir) {
-  try {
-    return await fsp.readdir(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Recursive byte total; a vanished child is skipped.
- *
- * @param {typeof fsPromises} fsp
- * @param {string} target
- * @returns {Promise<number>}
- */
-async function sizeOf(fsp, target) {
-  let total = 0;
-  const stack = [target];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    let stats;
-    try {
-      stats = await fsp.stat(current);
-    } catch {
-      continue;
-    }
-    if (!stats.isDirectory()) {
-      total += stats.size;
-      continue;
-    }
-    for (const child of await safeReaddir(fsp, current)) {
-      stack.push(path.join(current, child.name));
-    }
-  }
-  return total;
-}
-
 /**
  * One classified entry. `mtimeMs` is the entry's own mtime, not the newest
  * beneath it; widening it would change when an abandoned dir becomes eligible.
@@ -257,13 +220,44 @@ async function scanPlanDirs(tempRoot, fsp) {
   return entries;
 }
 
+/**
+ * `<tempRoot>/scratch/*`: `story-<id>/` is Story-keyed, anything else is
+ * age-floored — the one place an agent's ad-hoc files are reapable.
+ */
+async function scanScratch(tempRoot, fsp) {
+  const dir = path.join(tempRoot, SCRATCH_DIRNAME);
+  const entries = [];
+  for (const dirent of await safeReaddir(fsp, dir)) {
+    const match = dirent.isDirectory()
+      ? STORY_DIR_PATTERN.exec(dirent.name)
+      : null;
+    const entry = await makeEntry(
+      fsp,
+      path.join(dir, dirent.name),
+      'scratch',
+      match ? Number(match[1]) : null,
+    );
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+
 const SCANNERS = Object.freeze({
   orchestrationLogs: scanOrchestrationLogs,
   validationEvidence: scanValidationEvidence,
   auditResults: scanAuditResults,
   planDirs: scanPlanDirs,
+  scratch: scanScratch,
 });
 
+/** Fixed top-level dirs a class scanner walks. */
+const CLASS_OWNED_DIRNAMES = Object.freeze([
+  ORCHESTRATION_DIRNAME,
+  'standalone',
+  'audits',
+  SCRATCH_DIRNAME,
+]);
+
 /**
  * Keep in lockstep with the scanners: an entry no class walks must surface
  * as unrecognized.
@@ -273,29 +267,49 @@ const SCANNERS = Object.freeze({
  */
 function isClassOwnedTopLevel(name) {
   return (
-    name === ORCHESTRATION_DIRNAME ||
-    name === 'standalone' ||
-    name === 'audits' ||
+    CLASS_OWNED_DIRNAMES.includes(name) ||
     name.startsWith('plan-') ||
     RUN_DIR_PATTERN.test(name)
   );
 }
 
 /**
- * Unclaimed, non-reserved top-level entries: reported with sizes, never deleted.
+ * Top-level names no path may ever delete: the reserved trees, lock files,
+ * and the never-purged basenames.
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function isReservedTopLevel(name) {
+  return (
+    RESERVED_TOP_LEVEL.includes(name) ||
+    name.endsWith('.lock') ||
+    KEEP_BASENAMES.includes(name)
+  );
+}
+
+/**
+ * Unclaimed, non-reserved top-level entries: reported with sizes and the
+ * entry's own mtime. The auto-purge never deletes one; only an operator-
+ * confirmed `purgeUnrecognizedEntries` call does.
  *
  * @param {string} tempRoot
  * @param {typeof fsPromises} fsp
- * @returns {Promise<Array<{ path: string, bytes: number }>>}
+ * @returns {Promise<Array<{ path: string, bytes: number, mtimeMs: number }>>}
  */
 async function collectUnrecognized(tempRoot, fsp) {
   const found = [];
   for (const dirent of await safeReaddir(fsp, tempRoot)) {
     const { name } = dirent;
-    if (isClassOwnedTopLevel(name)) continue;
-    if (RESERVED_TOP_LEVEL.includes(name) || name.endsWith('.lock')) continue;
-    const target = path.join(tempRoot, name);
-    found.push({ path: target, bytes: await sizeOf(fsp, target) });
+    if (isClassOwnedTopLevel(name) || isReservedTopLevel(name)) continue;
+    const entry = await makeEntry(fsp, path.join(tempRoot, name), null, null);
+    if (entry) {
+      found.push({
+        path: entry.path,
+        bytes: entry.bytes,
+        mtimeMs: entry.mtimeMs,
+      });
+    }
   }
   return found;
 }
@@ -304,7 +318,7 @@ async function collectUnrecognized(tempRoot, fsp) {
  * Classify a temp tree without deleting anything.
  *
  * @param {{ config?: object, tempRoot?: string, fsp?: typeof fsPromises }} [args]
- * @returns {Promise<{ tempRoot: string, entries: object[], unrecognized: Array<{ path: string, bytes: number }> }>}
+ * @returns {Promise<{ tempRoot: string, entries: object[], unrecognized: Array<{ path: string, bytes: number, mtimeMs: number }> }>}
  */
 export async function collectTempEntries({
   config,
@@ -353,6 +367,7 @@ function isPurgeable(entry, ctx) {
  * @param {typeof fsPromises} [args.fsp]
  * @param {{ info: Function }} [args.logger]
  * @param {string} [args.label]
+ * @param {boolean} [args.dryRun] Report what would go; delete nothing.
  * @returns {Promise<object>} Result envelope; never throws.
  */
 async function purgeTempArtifacts({
@@ -366,6 +381,7 @@ async function purgeTempArtifacts({
   fsp = fsPromises,
   logger = Logger,
   label = 'temp-retention',
+  dryRun = false,
 } = {}) {
   const policy = resolveTempRetention(config);
   const base = {
@@ -402,22 +418,55 @@ async function purgeTempArtifacts({
       if (entry.keep) result.kept.push(entry.path);
       continue;
     }
-    try {
-      await fsp.rm(entry.path, { recursive: true, force: true });
-      result.purged.push({ path: entry.path, bytes: entry.bytes });
-      result.bytesReclaimed += entry.bytes;
-    } catch (err) {
-      result.errors.push(`${entry.path}: ${String(err?.message ?? err)}`);
-    }
+    await purgeOne(fsp, entry, result, dryRun);
   }
 
-  if (result.purged.length > 0) {
-    logger?.info?.(
-      `[${label}] purged ${result.purged.length} spent temp artifact(s), ` +
-        `reclaimed ${formatBytes(result.bytesReclaimed)} under ${result.tempRoot}.`,
+  if (!dryRun) reportPurge(logger, label, result);
+  return result;
+}
+
+/**
+ * One summary line for a purge that deleted something.
+ *
+ * @param {{ info?: Function }|undefined} logger
+ * @param {string} label
+ * @param {object} result
+ */
+function reportPurge(logger, label, result) {
+  if (result.purged.length === 0) return;
+  logger?.info?.(
+    `[${label}] purged ${result.purged.length} spent temp artifact(s), ` +
+      `reclaimed ${formatBytes(result.bytesReclaimed)} under ${result.tempRoot}.`,
+  );
+}
+
+/**
+ * Remove (or, on a dry run, only record) one purgeable entry into `result`.
+ *
+ * @param {typeof fsPromises} fsp
+ * @param {{ path: string, bytes: number }} entry
+ * @param {object} result Mutated in place.
+ * @param {boolean} dryRun
+ * @returns {Promise<void>}
+ */
+async function purgeOne(fsp, entry, result, dryRun) {
+  if (dryRun) {
+    result.purged.push({ path: entry.path, bytes: entry.bytes });
+    result.bytesReclaimed += entry.bytes;
+    return;
+  }
+  try {
+    const { bytes, kept } = await removeSparingKept(
+      fsp,
+      entry.path,
+      entry.bytes,
     );
+    result.kept.push(...kept);
+    result.purged.push({ path: entry.path, bytes });
+    result.bytesReclaimed += bytes;
+  } catch (err) {
+    result.errors.push(`${entry.path}: ${String(err?.message ?? err)}`);
   }
-  return result;
 }
 
 /**

package/.agents/scripts/lib/worktree/canonical-path.js

@@ -0,0 +1,34 @@
+/**
+ * worktree/canonical-path.js — the on-disk identity of a path, for every
+ * worktree identity and containment comparison.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * `realpathSync.native` resolves symlinks (macOS `/var` ↔ `/private/var`) and
+ * expands Windows 8.3 short names (`RUNNER~1` ↔ `runneradmin`) — `git
+ * worktree list` reports the long form while `os.tmpdir()` / `process.cwd()`
+ * may carry the short one. A path that no longer exists canonicalises its
+ * nearest existing ancestor and re-appends the rest.
+ *
+ * @param {string} p
+ * @param {{ realpath?: (p: string) => string }} [deps]
+ * @returns {string}
+ */
+export function canonicalPath(p, { realpath = fs.realpathSync.native } = {}) {
+  const resolved = path.resolve(p);
+  const tail = [];
+  let current = resolved;
+  for (;;) {
+    try {
+      return path.join(realpath(current), ...tail);
+    } catch {
+      const parent = path.dirname(current);
+      if (parent === current) return resolved;
+      tail.unshift(path.basename(current));
+      current = parent;
+    }
+  }
+}

package/.agents/scripts/lib/worktree/lifecycle/reap.js

@@ -7,6 +7,7 @@
 import fs from 'node:fs';
 import { rm as fsPromisesRm } from 'node:fs/promises';
 import { fileURLToPath } from 'node:url';
+import { canonicalPath } from '../canonical-path.js';
 import { isInsideWorktree, samePath } from '../inspector.js';
 import { sleepSync } from '../node-modules-strategy.js';
 import { checkMergeReachability } from './merge-reachability.js';
@@ -441,15 +442,25 @@ function runningCodePaths() {
  * The running-code path inside `wtPath`, or `null`. Reaping the tree the
  * running script was loaded from kills the process later, at its first lazy
  * read or dynamic `import()`; refusing only defers the tree to the next sweep.
+ * Shared by every reaper (close, the boot worktree sweep, `/clean-worktrees`).
+ * Both sides are canonicalised first: a short-name or symlinked spelling of
+ * the same tree must still be recognised.
  *
- * @param {object} ctx
+ * @param {{ platform?: string }} ctx
  * @param {string} wtPath
+ * @param {string[]} [extraPaths] Further paths to guard (e.g. `process.cwd()`).
  * @returns {string|null}
  */
-function findRunningCodeInside(ctx, wtPath) {
+export function findRunningCodeInside(ctx, wtPath, extraPaths = []) {
+  const guarded = [...runningCodePaths(), ...extraPaths];
+  const target = canonicalPath(wtPath);
   return (
-    runningCodePaths().find((p) => isInsideWorktree(p, wtPath, ctx.platform)) ??
-    null
+    guarded.find(
+      (p) =>
+        typeof p === 'string' &&
+        p !== '' &&
+        isInsideWorktree(canonicalPath(p), target, ctx.platform),
+    ) ?? null
   );
 }
 

package/.agents/scripts/single-story-init.js

@@ -229,10 +229,60 @@ export function decideStoryBranchSeed({ localHas, remoteHas }) {
 }
 
 /**
- * Reap merged `story-*` branches (excluding the current one). Never blocks
- * init. Protected candidates (unpushed work, dirty worktree, open Story) are
- * skipped; the lockfile is shared with `boot-sweep.js` via
- * `resolveSweepLockPath` so concurrent reaps cannot race.
+ * Remove closed-Story `.worktrees/story-<id>` trees through the boot sweep's
+ * own seam (`runWorktreeSweep`: same lock, same invariants). The Story being
+ * initialized is always kept, whatever its ticket state. Never throws: a
+ * failure lands in the returned outcome, which rides the init envelope.
+ *
+ * @returns {Promise<object>} `{ ok, reaped, skipped, reason?, error? }`.
+ */
+export async function reapClosedStoryWorktrees({
+  cwd,
+  storyBranch,
+  provider,
+  lockPath,
+  lockTimeoutMs,
+  worktreeSweepFn,
+  acquireLockFn,
+}) {
+  const logger = {
+    info: (m) => progress('CLEANUP', m),
+    warn: (m) => progress('CLEANUP', `⚠️ ${m}`),
+  };
+  try {
+    const { runWorktreeSweep } = await import('./boot-sweep.js');
+    const outcome = await runWorktreeSweep({
+      root: cwd,
+      provider,
+      lockPath,
+      lockTimeoutMs,
+      ...(worktreeSweepFn ? { sweepFn: worktreeSweepFn } : {}),
+      ...(acquireLockFn ? { acquireLockFn } : {}),
+      logger,
+      logTag: '[worktree-sweep]',
+      keepPaths: [path.join(cwd, '.worktrees', storyBranch)],
+    });
+    if (outcome.reaped?.length > 0) {
+      progress(
+        'CLEANUP',
+        `🧹 removed ${outcome.reaped.length} closed-Story worktree(s).`,
+      );
+    }
+    return outcome;
+  } catch (err) {
+    const msg = err?.message ?? String(err);
+    logger.warn(`worktree sweep threw (init continues): ${msg}`);
+    return { ok: false, error: msg, reaped: [], skipped: [] };
+  }
+}
+
+/**
+ * Reap merged `story-*` branches (excluding the current one), then the
+ * closed-Story worktrees. Never blocks init. Protected candidates (unpushed
+ * work, dirty worktree, open Story) are skipped; the lockfile is shared with
+ * `boot-sweep.js` via `resolveSweepLockPath` so concurrent reaps cannot race.
+ *
+ * @returns {Promise<{ worktreeSweep: object }>}
  */
 export async function reapMergedStoryBranches({
   cwd,
@@ -241,6 +291,8 @@ export async function reapMergedStoryBranches({
   config,
   provider,
   injectedSweep,
+  worktreeSweepFn,
+  acquireLockFn,
 }) {
   const sweepFn =
     injectedSweep ??
@@ -248,7 +300,37 @@ export async function reapMergedStoryBranches({
   const tempRoot = config?.project?.paths?.tempRoot ?? 'temp';
   const lockPath = resolveSweepLockPath({ cwd, tempRoot });
   const lockTimeoutMs =
-    config.delivery?.worktreeIsolation?.sweepLockMs ?? 60_000;
+    config?.delivery?.worktreeIsolation?.sweepLockMs ?? 60_000;
+  await reapMergedBranches({
+    cwd,
+    baseBranch,
+    storyBranch,
+    provider,
+    sweepFn,
+    lockPath,
+    lockTimeoutMs,
+  });
+  const worktreeSweep = await reapClosedStoryWorktrees({
+    cwd,
+    storyBranch,
+    provider,
+    lockPath,
+    lockTimeoutMs,
+    worktreeSweepFn,
+    acquireLockFn,
+  });
+  return { worktreeSweep };
+}
+
+async function reapMergedBranches({
+  cwd,
+  baseBranch,
+  storyBranch,
+  provider,
+  sweepFn,
+  lockPath,
+  lockTimeoutMs,
+}) {
   try {
     const sweep = await sweepFn({
       cwd,
@@ -300,9 +382,12 @@ export async function reapMergedStoryBranches({
  * @param {object} opts.config
  * @param {object} opts.provider
  * @param {Function|undefined} opts.injectedSweep
+ * @param {Function} [opts.worktreeSweepFn] Test override for the
+ *   closed-Story worktree sweep.
  * @param {Function} opts.progress
  * @param {import('./lib/git/cached-fetch.js').FetchCache} [opts.fetchCache]
  *   Test override; production shares the module singleton.
+ * @returns {Promise<{ worktreeSweep: object }>}
  */
 export async function materializeBaseBranch({
   cwd,
@@ -311,6 +396,7 @@ export async function materializeBaseBranch({
   config,
   provider,
   injectedSweep,
+  worktreeSweepFn,
   progress,
   fetchCache,
 }) {
@@ -326,13 +412,14 @@ export async function materializeBaseBranch({
     );
   }
 
-  await reapMergedStoryBranches({
+  const { worktreeSweep } = await reapMergedStoryBranches({
     cwd,
     baseBranch,
     storyBranch,
     config,
     provider,
     injectedSweep,
+    worktreeSweepFn,
   });
 
   if (!branchExistsLocally(baseBranch, cwd)) {
@@ -342,10 +429,19 @@ export async function materializeBaseBranch({
         `Failed to fetch base branch ${baseBranch}: ${r.stderr || '(no stderr)'}`,
       );
     }
-    return;
+    return { worktreeSweep };
   }
 
-  // `git fetch` leaves local base at the old tip until fast-forwarded.
+  fastForwardBase({ cwd, baseBranch, progress });
+  return { worktreeSweep };
+}
+
+/**
+ * `git fetch` leaves local base at the old tip until fast-forwarded.
+ *
+ * @param {{ cwd: string, baseBranch: string, progress: Function }} opts
+ */
+function fastForwardBase({ cwd, baseBranch, progress }) {
   const ffPlan = planFastForward({ cwd, baseBranch });
   const ff = executeFastForward({
     cwd,
@@ -461,6 +557,7 @@ export async function runSingleStoryInit({
   injectedProvider,
   injectedConfig,
   injectedSweep,
+  injectedWorktreeSweep,
   injectedAcquireLease,
   steal = false,
   injectedVerifyRemote,
@@ -533,6 +630,7 @@ export async function runSingleStoryInit({
   let workCwd = cwd;
   let worktreeCreated = false;
   let installStatus = { status: 'skipped', reason: 'dry-run' };
+  let worktreeSweep = null;
 
   if (!dryRun) {
     const acquire = injectedAcquireLease ?? acquireStoryLease;
@@ -563,15 +661,17 @@ export async function runSingleStoryInit({
     await rollUpContainerEpic(provider, storyId, config);
 
     try {
-      await injectedMaterialize({
-        cwd,
-        baseBranch,
-        storyBranch,
-        config,
-        provider,
-        injectedSweep,
-        progress,
-      });
+      ({ worktreeSweep } =
+        (await injectedMaterialize({
+          cwd,
+          baseBranch,
+          storyBranch,
+          config,
+          provider,
+          injectedSweep,
+          worktreeSweepFn: injectedWorktreeSweep,
+          progress,
+        })) ?? {});
       injectedSeedBranch({ cwd, storyBranch, baseBranch, progress });
       ({ workCwd, worktreeCreated, installStatus } =
         await injectedProvisionWorktree({
@@ -610,6 +710,9 @@ export async function runSingleStoryInit({
     installStatus,
     dependenciesInstalled,
     installFailed: installStatus.status === 'failed',
+    // Closed-Story worktree sweep outcome; a failure degrades here, never
+    // into an init failure. `null` under --dry-run.
+    worktreeSweep: worktreeSweep ?? null,
     dryRun,
     remoteVerified: remote.remoteVerified,
     remoteProbe: { remoteUrl: remote.remoteUrl, detail: remote.detail },

package/.agents/workflows/{git-cleanup.md → clean-git.md}

@@ -5,9 +5,9 @@ description: >-
   `git stash` entries — each step gated by operator confirmation.
 ---
 
-# /git-cleanup [--fast-forward-main] [--prune-remotes] [--branches] [--stashes] [--execute] [--remote] [--yes] [--include-content-merged] [--drop-stashes <ref>] [--exclude <pattern>] [--json]
+# /clean-git [--fast-forward-main] [--prune-remotes] [--branches] [--stashes] [--execute] [--remote] [--yes] [--include-content-merged] [--drop-stashes <ref>] [--exclude <pattern>] [--json]
 
-`/git-cleanup` folds the four cleanup steps operators routinely run by hand
+`/clean-git` folds the four cleanup steps operators routinely run by hand
 after a busy session into a single pipeline with per-step confirmation. It is a
 **recovery tool**, not a routine chore: the delivering flows already reap their
 own merged refs and fast-forward the base branch (see
@@ -22,13 +22,13 @@ Reach for it when the automated hygiene left an unusual state behind.
 > skill citation.
 
 The enumeration + reap logic lives in
-[`git-cleanup.js`](../scripts/git-cleanup.js) — it computes the candidate list,
+[`clean-git.js`](../scripts/clean-git.js) — it computes the candidate list,
 the skip taxonomy, the detection signals, and the JSON envelope, and prints them
 itself. Without `--execute` the script is a **dry-run preview**; nothing is
 mutated. When no phase flag is passed, **all four phases run** sequentially; a
 phase flag narrows the run. A failure in one phase does not short-circuit the
 others — each runs and reports independently. The script documents its own
-flags: `node .agents/scripts/git-cleanup.js --help`.
+flags: `node .agents/scripts/clean-git.js --help`.
 
 ## Phases
 
@@ -65,24 +65,24 @@ merged-PR branch in scope unless `--exclude`d.
 
 ```bash
 # Preview all four phases (no mutation).
-node .agents/scripts/git-cleanup.js
+node .agents/scripts/clean-git.js
 
 # Run everything non-interactively, including origin refs. Branches detected
 # only by content-equivalence keep their origin ref — see the note below.
-node .agents/scripts/git-cleanup.js --execute --remote --yes
+node .agents/scripts/clean-git.js --execute --remote --yes
 
 # Same, but also delete the origin refs of content-merged branches. Nobody is
 # watching, so opting in is the whole confirmation this delete ever gets.
-node .agents/scripts/git-cleanup.js --execute --remote --yes \
+node .agents/scripts/clean-git.js --execute --remote --yes \
   --include-content-merged
 
 # Only fast-forward main.
-node .agents/scripts/git-cleanup.js --fast-forward-main --execute
+node .agents/scripts/clean-git.js --fast-forward-main --execute
 
 # Only sweep merged branches + their origin refs.
-node .agents/scripts/git-cleanup.js --branches --execute --remote
+node .agents/scripts/clean-git.js --branches --execute --remote
 
 # Drop specific stashes under --yes.
-node .agents/scripts/git-cleanup.js --stashes --execute --yes \
+node .agents/scripts/clean-git.js --stashes --execute --yes \
   --drop-stashes 'stash@{0}' --drop-stashes 'stash@{2}'
 ```