svamp-cli 0.2.346 → 0.2.358

package/dist/{commands-C2aODeVc.mjs → commands-nkvTnUJj.mjs}

@@ -1,22 +1,23 @@
 import { existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { connectAndGetMachine, resolveSessionId, createWorktree, connectAndResolveSession } from './commands-D1pZq3d4.mjs';
+import { c as connectAndGetMachine, r as resolveSessionId, b as createWorktree, a as connectAndResolveSession } from './commands-CcdoQIkb.mjs';
 import { execFileSync } from 'node:child_process';
 import { w as withFileLock } from './fileLock-BMPwCrB6.mjs';
-import { u as updateIssue, f as addComment, h as addIssue, n as resolveCrewIssueOnMerge } from './store-Bn0ByYev.mjs';
-import { s as shortId } from './friendlyName-1UZcyDhu.mjs';
+import { u as updateIssue, b as addComment, i as addIssue, o as resolveCrewIssueOnMerge } from './store-D8dok6_d.mjs';
+import { s as shortId } from './friendlyName-B-OEwt0t.mjs';
 import { w as wantsHelp } from './wantsHelp-6bMOeNUz.mjs';
 import 'node:os';
 import './hyphaClient-ybivOjZo.mjs';
 import './types-57J3Re0n.mjs';
 import './securityContext-Cm5UTCuD.mjs';
-import './loopVerify-B47sSjxe.mjs';
+import './loopVerify-CxAKJB5a.mjs';
 import './instance-CeHz5C8v.mjs';
 import 'fs';
 import 'path';
 import 'os';
-import './flushExit-C-i6SGjj.mjs';
+import './inboxGuard-CDqmIypF.mjs';
 import 'node:crypto';
+import './flushExit-C-i6SGjj.mjs';
 
 function git(cwd, args) {
   return execFileSync("git", args, { cwd, stdio: "pipe", encoding: "utf-8" }).toString();
@@ -306,6 +307,7 @@ async function featureStart(brief, opts = {}) {
     const standalone = !!opts.noWorktree;
     let childDir;
     let base = "";
+    const leadDir = opts.directory || lead.directory;
     if (standalone) {
       const dir = opts.directory;
       if (!dir) {
@@ -319,15 +321,14 @@ async function featureStart(brief, opts = {}) {
       }
       console.log(`Standalone child folder: ${childDir} (no worktree)`);
     } else {
-      const leadDir = opts.directory || lead.directory;
       if (!leadDir) {
         console.error("Could not determine the lead project directory.");
         process.exit(1);
       }
-      const projectRoot2 = canonicalProjectRoot(leadDir);
-      base = opts.baseBranch || currentBranch(projectRoot2) || "main";
+      const worktreeRoot = canonicalProjectRoot(leadDir);
+      base = opts.baseBranch || currentBranch(worktreeRoot) || "main";
       try {
-        wt = createWorktree(projectRoot2);
+        wt = createWorktree(worktreeRoot);
       } catch (e) {
         console.error(`Failed to create worktree: ${e.message}`);
         process.exit(1);
@@ -335,7 +336,7 @@ async function featureStart(brief, opts = {}) {
       childDir = wt.path;
       console.log(`Worktree: ${wt.branch} \u2192 ${wt.path}`);
     }
-    const projectRoot = canonicalProjectRoot(lead.directory || opts.directory || childDir);
+    const projectRoot = canonicalProjectRoot(leadDir || childDir);
     const result = await machine.spawnSession({
       directory: childDir,
       agent: "claude",
@@ -629,7 +630,14 @@ async function featureMerge(childPartial, opts = {}) {
         notifyLead,
         childId,
         `<crew-freeze>Your lead is merging branch ${branch} into ${base}. Stop editing files now; do not commit until told.</crew-freeze>`,
-        "crew: freeze for merge"
+        "crew: freeze for merge",
+        // #1619: URGENT. This is a pre-emption notice, and the state it must interrupt —
+        // a child mid-work — is by definition NOT idle, so at 'normal' urgency
+        // classifyInbound QUEUES it until the child stops on its own. waitForChildIdle
+        // below is supposed to observe the child halting BECAUSE of this message; a queued
+        // message causes no halt, so the wait could only ever time out, and mergeBack can
+        // then reach `git worktree remove --force` on a tree the child is still writing.
+        "urgent"
       );
     } catch {
     }
@@ -649,7 +657,10 @@ async function featureMerge(childPartial, opts = {}) {
 Merge was not applied: ${r.detail}
 Resolve and run \`svamp feature done\` again.
 </crew-rework>`,
-            "crew: rework needed"
+            "crew: rework needed",
+            // #1619: URGENT — the comment above says 're-wake the child', which at
+            // 'normal' urgency is exactly what did not happen.
+            "urgent"
           );
         } catch {
         }
@@ -665,7 +676,12 @@ Resolve and run \`svamp feature done\` again.
 Merge could not be applied (${r.stage}): ${r.detail}
 Stop editing and hold \u2014 do not keep working. Once the blocker is resolved, the lead can retry \`svamp feature merge\`.
 </crew-blocked>`,
-            "crew: merge blocked"
+            "crew: merge blocked",
+            // #1619: URGENT. #0353's whole point is to STOP a child that is 'silently
+            // LOOPING against an un-merged branch, burning tokens toward the cost
+            // ceiling'. A looping child is never idle, so a queued STOP notice arrived
+            // only once it was no longer needed.
+            "urgent"
           );
         } catch {
         }

package/dist/{detectIsolation-CzoDCEnh.mjs → detectIsolation-CrV8IFDv.mjs}

@@ -1,5 +1,5 @@
 import { execFile } from 'node:child_process';
-import { mkdir, rm, readFile, chmod, access, mkdtemp } from 'node:fs/promises';
+import { mkdir, rm, readFile, mkdtemp, access, chmod, rename } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
@@ -65,6 +65,16 @@ function getNonoAssetName(version) {
   }
   return null;
 }
+async function probeNonoRuns(binaryPath) {
+  try {
+    const { stdout } = await execFileAsync(binaryPath, ["--version"], { timeout: 5e3 });
+    return { ok: true, version: stdout.trim().split("\n")[0] };
+  } catch (e) {
+    const stderr = typeof e?.stderr === "string" ? e.stderr.trim() : "";
+    const first = stderr.split("\n").find((l) => l.trim()) || e?.message || "unknown error";
+    return { ok: false, reason: first.trim() };
+  }
+}
 async function installNono() {
   const platform = process.platform;
   if (platform !== "darwin" && platform !== "linux") {
@@ -116,23 +126,33 @@ async function installNono() {
       return false;
     }
     console.log(`[isolation] nono ${version} checksum verified (${actual.slice(0, 12)}\u2026)`);
-    await execFileAsync("tar", [
-      "xzf",
-      tarball,
-      "-C",
-      SVAMP_BIN_DIR
-    ], { timeout: 15e3 });
-    await rm(tarball, { force: true }).catch(() => {
-    });
     const nonoPath = join(SVAMP_BIN_DIR, "nono");
-    await chmod(nonoPath, 493);
+    const stageDir = await mkdtemp(join(SVAMP_BIN_DIR, ".nono-stage-"));
     try {
-      await access(nonoPath);
-      console.log(`[isolation] nono ${version} installed at ${nonoPath}`);
+      await execFileAsync("tar", ["xzf", tarball, "-C", stageDir], { timeout: 15e3 });
+      await rm(tarball, { force: true }).catch(() => {
+      });
+      const staged = join(stageDir, "nono");
+      try {
+        await access(staged);
+      } catch {
+        console.warn("[isolation] Download completed but nono binary not found in the archive");
+        return false;
+      }
+      await chmod(staged, 493);
+      const probe = await probeNonoRuns(staged);
+      if (!probe.ok) {
+        console.error(
+          `[isolation] nono ${version} downloaded and checksum-verified, but it CANNOT RUN on this host: ${probe.reason}. Refusing to install \u2014 the previous binary (if any) is untouched. This host needs a nono build compatible with its libc; sessions will fall back to docker/podman, where --allow-write and --allow-domain are NOT enforced (#0878).`
+        );
+        return false;
+      }
+      await rename(staged, nonoPath);
+      console.log(`[isolation] nono ${version} installed at ${nonoPath} (verified runnable: ${probe.version || "ok"})`);
       return true;
-    } catch {
-      console.warn("[isolation] Download completed but nono binary not found");
-      return false;
+    } finally {
+      await rm(stageDir, { recursive: true, force: true }).catch(() => {
+      });
     }
   } catch (e) {
     console.warn(`[isolation] Failed to install nono: ${e.message}`);
@@ -316,4 +336,4 @@ async function detectIsolationCapabilities() {
   return { available, preferred, details };
 }
 
-export { detectIsolationCapabilities, installNono, isolationDisabledByEnv, verifyWithHardTimeout };
+export { detectIsolationCapabilities, installNono, isolationDisabledByEnv, probeNonoRuns, verifyWithHardTimeout };

package/dist/{fleet-DM_Q7w69.mjs → fleet-Ca-UjJNL.mjs}

@@ -37,6 +37,26 @@ function readDaemonState() {
 function getSelfMachineId() {
   return readDaemonState()?.machineId || null;
 }
+function rowDetail(result) {
+  const one = (t) => (t || "").trim().replace(/\s+/g, " ");
+  const err = one(result.stderr).slice(-200);
+  if (result.exitCode === 124 || /timed out and was killed/i.test(err)) {
+    return `TIMED OUT (may have partially completed) \u2014 ${err || "no stderr"}`;
+  }
+  const last = one((result.stdout || "").trim().split("\n").slice(-1)[0]);
+  return last || err || "";
+}
+const INSTALL_TIMEOUT_MS = 10 * 60 * 1e3;
+const SAFE_SKILL_NAME = /^[a-z0-9][a-z0-9._-]*$/i;
+const SAFE_VERSION = /^[0-9][0-9a-zA-Z.+-]*$/;
+function assertSafeFleetArg(value, kind, pattern) {
+  if (typeof value !== "string" || !pattern.test(value)) {
+    throw new Error(
+      `refusing to fan out: ${kind} ${JSON.stringify(value)} is not a plain ${kind} (expected ${pattern.source}). This string would be interpolated into a shell command run on every machine.`
+    );
+  }
+  return value;
+}
 function partitionSelf(machines, selfId) {
   if (!selfId) return { targets: machines, skipped: [] };
   return {
@@ -234,8 +254,9 @@ async function fleetUpgradeClaude(opts) {
 `);
   try {
     printHeader(["MACHINE ID", "LABEL", "STATE", "DETAIL"], [20, 24, 6, 60]);
+    assertSafeFleetArg(version, "version", SAFE_VERSION);
     const cmd = `claude install ${version} 2>&1 || claude update 2>&1`;
-    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0));
+    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0, INSTALL_TIMEOUT_MS));
     let failures = 0;
     for (const r of rows) {
       if (!r.ok) {
@@ -244,7 +265,7 @@ async function fleetUpgradeClaude(opts) {
         continue;
       }
       const ok = r.result.exitCode === 0;
-      const detail = (r.result.stdout?.trim().split("\n").slice(-1)[0] || r.result.stderr?.trim().slice(-200) || "").replace(/\s+/g, " ");
+      const detail = rowDetail(r.result);
       printResultRow(r.machine, ok ? "OK" : "FAIL", detail);
       if (!ok) failures += 1;
     }
@@ -271,8 +292,9 @@ async function fleetUpgradeCodex(opts) {
 `);
   try {
     printHeader(["MACHINE ID", "LABEL", "STATE", "DETAIL"], [20, 24, 6, 60]);
+    assertSafeFleetArg(version, "version", SAFE_VERSION);
     const cmd = `bash -lc '${NPM_PREFIX_RESOLVER}; npm install -g $PREFIX_ARG @openai/codex@${version} 2>&1 | tail -5'`;
-    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0));
+    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0, INSTALL_TIMEOUT_MS));
     let failures = 0;
     for (const r of rows) {
       if (!r.ok) {
@@ -281,7 +303,7 @@ async function fleetUpgradeCodex(opts) {
         continue;
       }
       const ok = r.result.exitCode === 0;
-      const detail = (r.result.stdout?.trim().split("\n").slice(-1)[0] || r.result.stderr?.trim().slice(-200) || "").replace(/\s+/g, " ");
+      const detail = rowDetail(r.result);
       printResultRow(r.machine, ok ? "OK" : "FAIL", detail);
       if (!ok) failures += 1;
     }
@@ -318,7 +340,7 @@ async function fleetUpgradeNono(opts) {
   try {
     printHeader(["MACHINE ID", "LABEL", "STATE", "DETAIL"], [20, 24, 6, 60]);
     const cmd = `svamp daemon install-nono 2>&1 | tail -5`;
-    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0));
+    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0, INSTALL_TIMEOUT_MS));
     let failures = 0;
     for (const r of rows) {
       if (!r.ok) {
@@ -327,7 +349,7 @@ async function fleetUpgradeNono(opts) {
         continue;
       }
       const ok = r.result.exitCode === 0;
-      const detail = (r.result.stdout?.trim().split("\n").slice(-1)[0] || r.result.stderr?.trim().slice(-200) || "").replace(/\s+/g, " ");
+      const detail = rowDetail(r.result);
       printResultRow(r.machine, ok ? "OK" : "FAIL", detail);
       if (!ok) failures += 1;
     }
@@ -347,6 +369,7 @@ async function fleetUpgradeKimi(opts) {
     await server.disconnect();
     return;
   }
+  assertSafeFleetArg(version, "version", SAFE_VERSION);
   console.log(`Reconciling Kimi to ${version} on ${machines.length} machine(s)...
 `);
   console.log(`Note: Kimi is a global npm package (${KIMI_NPM_PACKAGE}); machines that never use it can ignore this.`);
@@ -355,7 +378,7 @@ async function fleetUpgradeKimi(opts) {
   try {
     printHeader(["MACHINE ID", "LABEL", "STATE", "DETAIL"], [20, 24, 6, 60]);
     const cmd = `bash -lc '${NPM_PREFIX_RESOLVER}; npm install -g $PREFIX_ARG ${KIMI_NPM_PACKAGE}@${version} 2>&1 | tail -5'`;
-    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0));
+    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0, INSTALL_TIMEOUT_MS));
     let failures = 0;
     for (const r of rows) {
       if (!r.ok) {
@@ -364,7 +387,7 @@ async function fleetUpgradeKimi(opts) {
         continue;
       }
       const ok = r.result.exitCode === 0;
-      const detail = (r.result.stdout?.trim().split("\n").slice(-1)[0] || r.result.stderr?.trim().slice(-200) || "").replace(/\s+/g, " ");
+      const detail = rowDetail(r.result);
       printResultRow(r.machine, ok ? "OK" : "FAIL", detail);
       if (!ok) failures += 1;
     }
@@ -395,8 +418,9 @@ async function fleetUpgradeSvamp(opts) {
   try {
     printHeader(["MACHINE ID", "LABEL", "STATE", "DETAIL"], [20, 24, 6, 60]);
     for (const m of skipped) printResultRow(m, "SKIP", 'self \u2014 restart separately with "svamp daemon restart"');
+    assertSafeFleetArg(version, "version", SAFE_VERSION);
     const cmd = `bash -lc '${NPM_PREFIX_RESOLVER}; npm install -g $PREFIX_ARG svamp-cli@${version} 2>&1 | tail -5 && ${restartCmd} 2>&1 | tail -5'`;
-    const rows = await fanOut(targets, async (m) => await m.rpc.bash(cmd, void 0));
+    const rows = await fanOut(targets, async (m) => await m.rpc.bash(cmd, void 0, INSTALL_TIMEOUT_MS));
     let failures = 0;
     for (const r of rows) {
       if (!r.ok) {
@@ -405,7 +429,7 @@ async function fleetUpgradeSvamp(opts) {
         continue;
       }
       const ok = r.result.exitCode === 0;
-      const detail = (r.result.stdout?.trim().split("\n").slice(-1)[0] || r.result.stderr?.trim().slice(-200) || "").replace(/\s+/g, " ");
+      const detail = rowDetail(r.result);
       printResultRow(r.machine, ok ? "OK" : "FAIL", detail);
       if (!ok) failures += 1;
     }
@@ -445,7 +469,7 @@ async function fleetDaemonRestart(opts) {
     console.log(`Restarting daemons on ${machines.length} machine(s) \u2014 ${mode}...
 `);
     printHeader(["MACHINE ID", "LABEL", "STATE", "DETAIL"], [20, 24, 6, 60]);
-    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0));
+    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0, INSTALL_TIMEOUT_MS));
     let failures = 0;
     for (const r of rows) {
       if (!r.ok) {
@@ -454,7 +478,7 @@ async function fleetDaemonRestart(opts) {
         continue;
       }
       const ok = r.result.exitCode === 0;
-      const detail = (r.result.stdout?.trim().split("\n").slice(-1)[0] || r.result.stderr?.trim().slice(-200) || "").replace(/\s+/g, " ");
+      const detail = rowDetail(r.result);
       printResultRow(r.machine, ok ? "OK" : "FAIL", detail);
       if (!ok) failures += 1;
     }
@@ -480,8 +504,9 @@ async function fleetPushSkill(name) {
 `);
   try {
     printHeader(["MACHINE ID", "LABEL", "STATE", "DETAIL"], [20, 24, 6, 60]);
+    assertSafeFleetArg(name, "skill name", SAFE_SKILL_NAME);
     const cmd = `svamp skills install ${name} --force 2>&1`;
-    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0));
+    const rows = await fanOut(machines, async (m) => await m.rpc.bash(cmd, void 0, INSTALL_TIMEOUT_MS));
     let failures = 0;
     for (const r of rows) {
       if (!r.ok) {
@@ -490,7 +515,7 @@ async function fleetPushSkill(name) {
         continue;
       }
       const ok = r.result.exitCode === 0;
-      const detail = (r.result.stdout?.trim().split("\n").slice(-1)[0] || r.result.stderr?.trim().slice(-200) || "").replace(/\s+/g, " ");
+      const detail = rowDetail(r.result);
       printResultRow(r.machine, ok ? "OK" : "FAIL", detail);
       if (!ok) failures += 1;
     }
@@ -502,4 +527,4 @@ ${rows.length - failures}/${rows.length} updated.`);
   }
 }
 
-export { fleetDaemonRestart, fleetDaemonRestartCommand, fleetExec, fleetPushSkill, fleetStatus, fleetUpgradeClaude, fleetUpgradeCodex, fleetUpgradeKimi, fleetUpgradeNono, fleetUpgradeSvamp, parseVersionOutput, partitionSelf };
+export { assertSafeFleetArg, fleetDaemonRestart, fleetDaemonRestartCommand, fleetExec, fleetPushSkill, fleetStatus, fleetUpgradeClaude, fleetUpgradeCodex, fleetUpgradeKimi, fleetUpgradeNono, fleetUpgradeSvamp, parseVersionOutput, partitionSelf, rowDetail };

package/dist/friendlyName-B-OEwt0t.mjs

@@ -0,0 +1,341 @@
+import { randomBytes } from 'node:crypto';
+
+const ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+const LOWER_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+function shortId(length = 10, alphabet = ALPHABET) {
+  const maxUnbiased = Math.floor(256 / alphabet.length) * alphabet.length;
+  let out = "";
+  while (out.length < length) {
+    const buf = randomBytes(length - out.length);
+    for (let i = 0; i < buf.length && out.length < length; i++) {
+      const b = buf[i];
+      if (b < maxUnbiased) out += alphabet[b % alphabet.length];
+    }
+  }
+  return out;
+}
+
+const ADJECTIVES = [
+  "able",
+  "amber",
+  "amused",
+  "ancient",
+  "arctic",
+  "autumn",
+  "azure",
+  "blithe",
+  "bold",
+  "brave",
+  "breezy",
+  "bright",
+  "brisk",
+  "calm",
+  "candid",
+  "cheery",
+  "chill",
+  "clever",
+  "cobalt",
+  "cosmic",
+  "cozy",
+  "crimson",
+  "crisp",
+  "curious",
+  "dapper",
+  "daring",
+  "dawn",
+  "deft",
+  "dewy",
+  "eager",
+  "early",
+  "easy",
+  "electric",
+  "fancy",
+  "feisty",
+  "fleet",
+  "fond",
+  "frosty",
+  "gallant",
+  "gentle",
+  "giddy",
+  "glad",
+  "gleaming",
+  "golden",
+  "graceful",
+  "grand",
+  "hardy",
+  "hazel",
+  "hearty",
+  "honest",
+  "humble",
+  "jolly",
+  "jovial",
+  "keen",
+  "kind",
+  "lively",
+  "loyal",
+  "lucky",
+  "lunar",
+  "mellow",
+  "merry",
+  "mighty",
+  "mint",
+  "misty",
+  "nimble",
+  "noble",
+  "opal",
+  "patient",
+  "peppy",
+  "placid",
+  "plucky",
+  "polar",
+  "prim",
+  "proud",
+  "quick",
+  "quiet",
+  "quirky",
+  "radiant",
+  "rapid",
+  "ready",
+  "regal",
+  "rosy",
+  "royal",
+  "rugged",
+  "sage",
+  "sandy",
+  "scarlet",
+  "serene",
+  "sharp",
+  "shiny",
+  "silent",
+  "silver",
+  "sleek",
+  "smooth",
+  "snappy",
+  "snowy",
+  "solar",
+  "spry",
+  "stellar",
+  "sturdy",
+  "sunny",
+  "swift",
+  "tender",
+  "tidal",
+  "tidy",
+  "tranquil",
+  "trusty",
+  "upbeat",
+  "valiant",
+  "vivid",
+  "warm",
+  "whimsical",
+  "wise",
+  "witty",
+  "zesty",
+  "zippy"
+];
+const ANIMALS = [
+  "ant",
+  "badger",
+  "bat",
+  "bear",
+  "beaver",
+  "bee",
+  "bison",
+  "boar",
+  "bobcat",
+  "buffalo",
+  "camel",
+  "caribou",
+  "cat",
+  "cheetah",
+  "cobra",
+  "condor",
+  "cougar",
+  "coyote",
+  "crab",
+  "crane",
+  "cricket",
+  "crow",
+  "deer",
+  "dingo",
+  "dolphin",
+  "donkey",
+  "dove",
+  "dragon",
+  "duck",
+  "eagle",
+  "eel",
+  "egret",
+  "elk",
+  "falcon",
+  "ferret",
+  "finch",
+  "fox",
+  "frog",
+  "gecko",
+  "gibbon",
+  "goat",
+  "goose",
+  "gopher",
+  "hare",
+  "hawk",
+  "hedgehog",
+  "heron",
+  "hippo",
+  "horse",
+  "ibex",
+  "ibis",
+  "iguana",
+  "jackal",
+  "jaguar",
+  "jay",
+  "kestrel",
+  "koala",
+  "krill",
+  "lark",
+  "lemur",
+  "leopard",
+  "lion",
+  "llama",
+  "lynx",
+  "macaw",
+  "magpie",
+  "mantis",
+  "marmot",
+  "marten",
+  "meerkat",
+  "mink",
+  "mole",
+  "moose",
+  "moth",
+  "mouse",
+  "newt",
+  "ocelot",
+  "octopus",
+  "orca",
+  "osprey",
+  "otter",
+  "owl",
+  "ox",
+  "panda",
+  "panther",
+  "parrot",
+  "pelican",
+  "penguin",
+  "pheasant",
+  "pigeon",
+  "puffin",
+  "puma",
+  "quail",
+  "rabbit",
+  "raccoon",
+  "ram",
+  "raven",
+  "robin",
+  "salmon",
+  "seal",
+  "shark",
+  "sheep",
+  "shrew",
+  "skunk",
+  "sloth",
+  "snail",
+  "sparrow",
+  "spider",
+  "squid",
+  "stag",
+  "stoat",
+  "stork",
+  "swan",
+  "tapir",
+  "tiger",
+  "toad",
+  "trout",
+  "turtle",
+  "viper",
+  "vole",
+  "walrus",
+  "weasel",
+  "whale",
+  "wolf",
+  "wombat",
+  "wren",
+  "yak",
+  "zebra"
+];
+function pick(arr) {
+  const n = arr.length;
+  const max = Math.floor(256 / n) * n;
+  let b;
+  do {
+    b = randomBytes(1)[0];
+  } while (b >= max);
+  return arr[b % n];
+}
+function generateFriendlyName(taken = []) {
+  const used = taken instanceof Set ? taken : new Set(taken);
+  for (let i = 0; i < 1e3; i++) {
+    const name = `${pick(ADJECTIVES)}-${pick(ANIMALS)}`;
+    if (!used.has(name)) return name;
+  }
+  const base = `${pick(ADJECTIVES)}-${pick(ANIMALS)}`;
+  let n = 2;
+  while (used.has(`${base}-${n}`)) n++;
+  return `${base}-${n}`;
+}
+function sanitizeSegment(s) {
+  return String(s || "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function friendlyNameFromId(id) {
+  const m = /^(.+)-[a-zA-Z0-9]{6,10}$/.exec(String(id || ""));
+  return m ? m[1] : void 0;
+}
+function composeSessionId(friendlyName, takenIds = [], len = 6) {
+  const taken = takenIds instanceof Set ? takenIds : new Set(takenIds);
+  const A = LOWER_ALPHABET.length;
+  const nthSuffix = (i, width2) => {
+    let s = "";
+    for (let k = 0; k < width2; k++) {
+      s = LOWER_ALPHABET[i % A] + s;
+      i = Math.floor(i / A);
+    }
+    return s;
+  };
+  let width = Math.max(1, len);
+  for (; ; ) {
+    const space = Math.pow(A, width);
+    for (let i = 0; i < 64; i++) {
+      const candidate = `${friendlyName}-${shortId(width, LOWER_ALPHABET)}`;
+      if (!taken.has(candidate)) return candidate;
+    }
+    if (space <= 1e6) {
+      for (let i = 0; i < space; i++) {
+        const candidate = `${friendlyName}-${nthSuffix(i, width)}`;
+        if (!taken.has(candidate)) return candidate;
+      }
+    }
+    width++;
+  }
+}
+function formatHandle(projectName, friendlyName) {
+  if (!friendlyName) return void 0;
+  const proj = sanitizeSegment(projectName || "");
+  return proj ? `${proj}:${friendlyName}` : friendlyName;
+}
+function parseHandle(input) {
+  const str = String(input || "").trim().replace(/^@/, "");
+  if (!str) return null;
+  const i = str.indexOf(":");
+  if (i === -1) return { name: str.toLowerCase() };
+  return { project: sanitizeSegment(str.slice(0, i)), name: str.slice(i + 1).toLowerCase() };
+}
+function handleMatchesMetadata(parsed, metadata) {
+  const fn = String(metadata?.friendlyName || "").toLowerCase();
+  if (!fn || fn !== parsed.name) return false;
+  if (parsed.project) {
+    return sanitizeSegment(metadata?.projectName || "") === parsed.project;
+  }
+  return true;
+}
+
+export { friendlyNameFromId as a, composeSessionId as c, formatHandle as f, generateFriendlyName as g, handleMatchesMetadata as h, parseHandle as p, shortId as s };