claudish 13.0.0 → 13.0.2

package/bin/env-files.cjs

@@ -0,0 +1,104 @@
+// Which environment names Bun's env-file autoload sets in a directory — asked of Bun.
+//
+// Bun loads `.env`, `.env.local`, `.env.<NODE_ENV>` and `.env.<NODE_ENV>.local` (plus
+// any `--env-file`) into `process.env` before a script runs, and marks nothing as
+// coming from a file. Every claudish launch path turns that off with `--no-env-file`.
+// When a process was started without it anyway (`bun <path>/claudish.cjs`,
+// `bun <path>/index.ts`), claudish cannot recover the real environment, but it can
+// learn which NAMES the files set, and drop those. Bun is asked rather than imitated:
+// its file list and its parser differ from dotenv's and change between releases, and a
+// re-implementation of either is how an earlier check was bypassed.
+//
+// The probe runs Bun in the same directory with an empty environment and prints the
+// names it ends up with. It runs once with NODE_ENV unset and once with the current
+// value, because NODE_ENV picks the file list and a `.env` may itself have set it.
+// `--config=<null device>` keeps the directory's `bunfig.toml` out, so the probe runs
+// no `preload` from the checkout; a bunfig can only turn the autoload off, which makes
+// this answer a superset of what was loaded, the safe direction.
+//
+// Shared on purpose: the npm launcher requires it, and so does `src/launch-env.ts`
+// (lazily, from the package's `bin/`), so there is one implementation.
+
+const { spawnSync } = require("node:child_process");
+const { devNull } = require("node:os");
+
+const PROBE_TIMEOUT_MS = 15_000;
+const PRINT_NAMES = "JSON.stringify(Object.keys(process.env))";
+
+/** Bun's flag that turns its env-file autoload off. */
+const NO_ENV_FILE_FLAG = "--no-env-file";
+
+/** The `--env-file` arguments in Bun's own argv, so the probe loads the same files. */
+function envFileArgs(execArgv) {
+  const out = [];
+  for (let i = 0; i < execArgv.length; i++) {
+    const arg = execArgv[i];
+    if (arg.startsWith("--env-file=")) out.push(arg);
+    else if (arg === "--env-file" && i + 1 < execArgv.length) out.push(arg, execArgv[++i]);
+  }
+  return out;
+}
+
+/** The minimal environment a probe needs to start on this platform. */
+function probeBaseEnv(platform, env) {
+  if (platform !== "win32") return {};
+  const base = {};
+  for (const key of ["SystemRoot", "SYSTEMROOT"]) if (env[key]) base[key] = env[key];
+  return base;
+}
+
+/** One probe run: the names Bun's process has under `runEnv`, or null on any failure. */
+function probeNames(bunPath, args, cwd, runEnv) {
+  const r = spawnSync(bunPath, args, {
+    cwd,
+    env: runEnv,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: PROBE_TIMEOUT_MS,
+    windowsHide: true,
+  });
+  if (r.status !== 0 || typeof r.stdout !== "string") return null;
+  try {
+    const parsed = JSON.parse(r.stdout.trim().split("\n").pop() || "");
+    return Array.isArray(parsed) ? parsed.filter((name) => typeof name === "string") : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The names Bun's env-file loading sets in `cwd` for a Bun started with `execArgv`.
+ * Returns null when Bun could not answer: the caller must then fail closed.
+ */
+function envFileKeys({ bunPath, execArgv, cwd, env, platform = process.platform }) {
+  const base = probeBaseEnv(platform, env);
+  const runs = [base];
+  if (env.NODE_ENV !== undefined) runs.push({ ...base, NODE_ENV: env.NODE_ENV });
+  const args = [...envFileArgs(execArgv), `--config=${devNull}`, "--print", PRINT_NAMES];
+  const names = new Set();
+  for (const runEnv of runs) {
+    const found = probeNames(bunPath, args, cwd, runEnv);
+    if (found === null) return null;
+    for (const name of found) if (!Object.hasOwn(runEnv, name)) names.add(name);
+  }
+  return [...names];
+}
+
+/** The one stderr line for names dropped because Bun's env-file autoload was on. */
+function droppedByAutoloadNotice(names) {
+  const them = names.length === 1 ? "it" : "them";
+  return `[claudish] ignoring ${names.join(", ")}: Bun loaded this directory's env files before claudish started, so a repository may have set ${them}. claudish reads provider API keys and model settings from .env itself. Run the installed claudish command, or start Bun with ${NO_ENV_FILE_FLAG}.`;
+}
+
+/** The one stderr line when Bun could not say which names its env files set. */
+function probeFailedNotice() {
+  return `[claudish] Bun loaded this directory's env files before claudish started, and claudish could not tell which values came from them, so it will not start. Run the installed claudish command, or start Bun with ${NO_ENV_FILE_FLAG}.`;
+}
+
+module.exports = {
+  NO_ENV_FILE_FLAG,
+  envFileArgs,
+  envFileKeys,
+  droppedByAutoloadNotice,
+  probeFailedNotice,
+};

package/dist/index.js

@@ -575,7 +575,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "13.0.0";
+var VERSION = "13.0.2";
 
 // src/logger.ts
 import { appendFile, existsSync as existsSync2, mkdirSync, readdirSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
@@ -29842,9 +29842,9 @@ async function flushStats() {
     }
   } catch {}
 }
-function showMonthlyBanner() {
+function showMonthlyBanner(env = process.env) {
   try {
-    if (isStatsDisabledByEnv())
+    if (isStatsDisabledByEnv() || isPaneChild(env))
       return;
     const profileConfig = loadConfig();
     const consent = profileConfig.stats;
@@ -29976,6 +29976,7 @@ Usage: claudish stats on|off|status|reset
 }
 var STATS_ENDPOINT = "https://claudish.com/v1/stats", FLUSH_INTERVAL_MS2, MONTHLY_INTERVAL_MS, SEND_TIMEOUT_MS = 5000, statsEnabled = false, initialized2 = false, claudishVersion2 = "", installMethod2 = "unknown", envAttributes;
 var init_stats = __esm(() => {
+  init_child_env();
   init_profile_config();
   init_model_parser();
   init_stats_buffer();
@@ -68612,44 +68613,76 @@ import { basename as basename2, dirname as dirname14, join as join41 } from "pat
 function collapse(s) {
   return s.trim().replace(/\s+/g, " ");
 }
-function parsePsTable(text) {
+function etimeSeconds(etime) {
+  const [days, clock] = etime.includes("-") ? etime.split("-") : ["0", etime];
+  const parts = (clock ?? "").split(":").map(Number);
+  while (parts.length < 3)
+    parts.unshift(0);
+  const [h = 0, m = 0, s = 0] = parts;
+  return Number(days) * 86400 + h * 3600 + m * 60 + s;
+}
+function parsePsTable(text, spawnedAtMs) {
   const rows = [];
   for (const line of text.split(`
 `)) {
     const m = line.match(PS_ROW);
     if (!m)
       continue;
-    rows.push({
+    const row = {
       pid: Number(m[1]),
       ppid: Number(m[2]),
       pgid: Number(m[3]),
-      lstart: collapse(m[4] ?? ""),
-      command: (m[5] ?? "").trim()
-    });
+      lstart: collapse(m[5] ?? ""),
+      command: (m[6] ?? "").trim()
+    };
+    if (m[4] && spawnedAtMs !== undefined)
+      row.startMs = spawnedAtMs - etimeSeconds(m[4]) * 1000;
+    rows.push(row);
   }
   return rows;
 }
+function startedAt(row, startMs) {
+  return row.startMs === undefined || Math.abs(row.startMs - startMs) < START_TOLERANCE_MS;
+}
+function pidMayBeAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code !== "ESRCH";
+  }
+}
+function processTableTrusted(rows) {
+  return rows.some((r) => r.pid === process.pid);
+}
+function tableOf(stdout, spawnedAtMs) {
+  if (stdout === null)
+    return null;
+  const rows = parsePsTable(stdout, spawnedAtMs);
+  return processTableTrusted(rows) ? rows : null;
+}
 function readProcessTable() {
+  const spawnedAt = Date.now();
+  let stdout;
   try {
-    return parsePsTable(execFileSync2("ps", PS_ARGS, {
-      env: PS_ENV,
-      encoding: "utf8",
-      maxBuffer: 64 * 1024 * 1024,
+    stdout = psSpawn.execFileSync("ps", PS_ARGS, {
+      ...PS_OPTIONS,
       stdio: ["ignore", "pipe", "ignore"]
-    }));
+    });
   } catch {
-    return [];
+    stdout = null;
   }
-}
-function processTableTrusted(table) {
-  return table.some((r) => r.pid === process.pid);
+  return tableOf(stdout, spawnedAt);
 }
 function readProcessTableAsync() {
   return new Promise((resolve) => {
+    const spawnedAt = Date.now();
     try {
-      execFile2("ps", PS_ARGS, { env: PS_ENV, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 }, (err, stdout) => resolve(err ? [] : parsePsTable(String(stdout))));
+      psSpawn.execFile("ps", PS_ARGS, PS_OPTIONS, (err, stdout) => resolve(tableOf(err ? null : String(stdout), spawnedAt)));
     } catch {
-      resolve([]);
+      resolve(tableOf(null, spawnedAt));
     }
   });
 }
@@ -68666,12 +68699,12 @@ function isPaneMagmuxCommand(command, paneId) {
   return command.includes(magmuxNeedle(paneId));
 }
 function isPaneMagmux(pid, paneId, table) {
-  const rows = table ?? readProcessTable();
+  const rows = table ?? readProcessTable() ?? [];
   const row = rows.find((r) => r.pid === pid);
   return !!row && isPaneMagmuxCommand(row.command, paneId);
 }
 function findPaneMagmux(paneId, table) {
-  return (table ?? readProcessTable()).filter((r) => isPaneMagmuxCommand(r.command, paneId));
+  return (table ?? readProcessTable() ?? []).filter((r) => isPaneMagmuxCommand(r.command, paneId));
 }
 function paneIdentityMatches(command, pane) {
   return command.includes(sessionNeedle(pane.sessionUuid)) || command.includes(launcherNeedle(pane.ctlDir));
@@ -68824,11 +68857,12 @@ function watcherArgv(a) {
 function isPaneWatcherCommand(command, paneId) {
   return command.includes(` ${WATCHER_ARGV0} ${paneId} `);
 }
-var PS_ARGS, PS_ROW, PS_ENV, LAUNCH_DIR_RE, PANE_ID_RE, WATCHER_FUNCTIONS = `
+var PS_ARGS, PS_ROW, START_TOLERANCE_MS = 2000, PS_ENV, PS_OPTIONS, psSpawn, LAUNCH_DIR_RE, PANE_ID_RE, WATCHER_FUNCTIONS = `
 set -f
 export LC_ALL=C
 PANE=$1 UUID=$2 CTL=$3 SOCKP=$4 REC=$5 TURN=$6 ROOT=$7
 pstable() { ps -ax -ww -o pid=,pgid=,lstart=,command=; }
+ps_ok() { ps -o pid= -p $$ >/dev/null 2>&1; }
 mag=""
 mag_ok() {
   case "$mag" in (''|*[!0-9]*) return 1;; esac
@@ -68877,6 +68911,9 @@ launch_dir_ok() {
 `, WATCHER_MAIN = `
 while IFS= read -r l; do [ "$l" = done ] && exit 0; done
 # EOF without "done": the owner is gone (SIGKILL included: the kernel closed its end).
+# No readable table (a sandbox refuses the setuid ps): nothing can be verified, so nothing
+# is signalled or removed; the files stay for a sweep that can read the table.
+ps_ok || exit 1
 find_mag
 find_pg
 for s in TERM KILL; do
@@ -68894,9 +68931,11 @@ launch_dir_ok "$TURN" && rm -rf -- "$TURN"
 exit 0
 `, WATCHER_SCRIPT, WATCHER_ARGV0 = "claudish-pane-watcher";
 var init_process_identity = __esm(() => {
-  PS_ARGS = ["-ax", "-ww", "-o", "pid=,ppid=,pgid=,lstart=,command="];
-  PS_ROW = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+\s+\S+\s+\d+\s+\d\d:\d\d:\d\d\s+\d{4})\s?(.*)$/;
+  PS_ARGS = ["-ax", "-ww", "-o", "pid=,ppid=,pgid=,etime=,lstart=,command="];
+  PS_ROW = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(?:((?:\d+-)?(?:\d+:)?\d+:\d+)\s+)?(\S+\s+\S+\s+\d+\s+\d\d:\d\d:\d\d\s+\d{4})\s?(.*)$/;
   PS_ENV = { PATH: "/bin:/usr/bin:/usr/sbin:/sbin", LC_ALL: "C" };
+  PS_OPTIONS = { env: PS_ENV, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 };
+  psSpawn = { execFile: execFile2, execFileSync: execFileSync2 };
   LAUNCH_DIR_RE = /^launch-[A-Za-z0-9]{6}$/;
   PANE_ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
   WATCHER_SCRIPT = `${WATCHER_FUNCTIONS}${WATCHER_MAIN}`;
@@ -69570,7 +69609,10 @@ var init_magmux_client = __esm(() => {
 
 // src/pane/pane-registry.ts
 import {
+  constants,
+  accessSync,
   existsSync as existsSync31,
+  lstatSync as lstatSync3,
   readFileSync as readFileSync29,
   readdirSync as readdirSync4,
   renameSync as renameSync4,
@@ -69582,14 +69624,21 @@ import { join as join43 } from "path";
 function ownerStartOfSelf() {
   if (ownStart)
     return ownStart;
-  const row = readProcessTable().find((r) => r.pid === process.pid);
+  const row = readProcessTable()?.find((r) => r.pid === process.pid);
   if (row)
     ownStart = row.lstart;
   return row?.lstart ?? "";
 }
-function ownerAlive(rec, table) {
-  const row = table.find((r) => r.pid === rec.ownerPid);
-  return !!row && row.lstart === rec.ownerStart;
+function ownerAlive(owner, table) {
+  if (!table)
+    return pidMayBeAlive(owner.ownerPid);
+  const row = table.find((r) => r.pid === owner.ownerPid);
+  if (!row)
+    return false;
+  if (owner.ownerStart)
+    return row.lstart === owner.ownerStart;
+  const minted = ownerOfPaneId(owner.paneId);
+  return !minted || startedAt(row, minted.startMs);
 }
 function recordsDir(root) {
   return join43(root, "panes");
@@ -69722,7 +69771,9 @@ async function tick() {
     return;
   ticking = true;
   try {
-    refreshGroups(await readProcessTableAsync());
+    const table = await readProcessTableAsync();
+    if (table)
+      refreshGroups(table);
     for (const p of live.values())
       if (p.reapFailed)
         await p.retryReap();
@@ -69824,9 +69875,9 @@ function sweepTargets(rec, root, table) {
   return { mag: m.mag, group, unverified: m.unverified || groupImpostor };
 }
 async function killVerified(rec, root) {
-  const t = sweepTargets(rec, root, readProcessTable());
+  const t = sweepTargets(rec, root, readProcessTable() ?? []);
   for (const sig of ["SIGTERM", "SIGKILL"]) {
-    const table = readProcessTable();
+    const table = readProcessTable() ?? [];
     if (t.group && groupCheck(table, t.group))
       signal(-t.group.pgid, sig);
     for (const pid of liveEscaped(table, t.group))
@@ -69839,12 +69890,15 @@ async function killVerified(rec, root) {
 }
 async function sweepRecord(rec, root, out) {
   const table = readProcessTable();
-  if (!processTableTrusted(table)) {
-    out.kept.push(rec.paneId);
+  if (ownerAlive(rec, table)) {
+    if (!table)
+      out.kept.push(rec.paneId);
     return;
   }
-  if (ownerAlive(rec, table))
+  if (!table) {
+    await sweepUnidentifiable(rec, root, out);
     return;
+  }
   const watcher = rec.watcherPid ? table.find((r) => r.pid === rec.watcherPid) : undefined;
   if (watcher && isPaneWatcherCommand(watcher.command, rec.paneId)) {
     out.kept.push(rec.paneId);
@@ -69855,11 +69909,7 @@ async function sweepRecord(rec, root, out) {
   if (anyVerified)
     await killVerified(rec, root);
   const after = readProcessTable();
-  if (!processTableTrusted(after)) {
-    out.kept.push(rec.paneId);
-    return;
-  }
-  const stillAlive = t0.group && groupCheck(after, t0.group) || liveEscaped(after, t0.group).length > 0 || t0.mag !== null && isPaneMagmux(t0.mag, rec.paneId, after);
+  const stillAlive = !after || t0.group && groupCheck(after, t0.group) || liveEscaped(after, t0.group).length > 0 || t0.mag !== null && isPaneMagmux(t0.mag, rec.paneId, after);
   if (stillAlive) {
     out.kept.push(rec.paneId);
     return;
@@ -69872,40 +69922,96 @@ async function sweepRecord(rec, root, out) {
   else
     out.cleaned.push(rec.paneId);
 }
+async function probeSocket(sockPath, magmuxMayLive) {
+  const dial = dialSocket(sockPath);
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), SOCKET_PROBE_TIMEOUT_MS);
+  });
+  try {
+    const won = await Promise.race([dial, timeout]);
+    if (won !== "timeout")
+      return { state: "answers", client: won };
+    dial.then((c) => c.close(), () => {
+      return;
+    });
+    return { state: "inconclusive", code: "ETIMEDOUT" };
+  } catch (e) {
+    const code = dialErrno(e.errno ?? "unknown", sockPath);
+    const stale = code === "ENOENT" || code === "ECONNREFUSED" && !magmuxMayLive;
+    return stale ? { state: "stale", code } : { state: "inconclusive", code };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function dialErrno(reported, sockPath) {
+  if (reported !== "ENOENT")
+    return reported;
+  let isSocket;
+  try {
+    isSocket = lstatSync3(sockPath).isSocket();
+  } catch (e) {
+    return e.code ?? "unknown";
+  }
+  if (!isSocket)
+    return "ENOTSOCK";
+  try {
+    accessSync(sockPath, constants.W_OK);
+  } catch {
+    return "EACCES";
+  }
+  return "ECONNREFUSED";
+}
+async function sweepUnidentifiable(rec, root, out) {
+  if (rec.watcherPid && pidMayBeAlive(rec.watcherPid)) {
+    out.kept.push(rec.paneId);
+    return;
+  }
+  const magmuxMayLive = rec.magmuxPid === null || pidMayBeAlive(rec.magmuxPid);
+  const probe = await probeSocket(sockPathOf(root, rec.paneId), magmuxMayLive);
+  if (probe.state !== "stale") {
+    if (probe.state === "answers")
+      probe.client.close();
+    out.kept.push(rec.paneId);
+    return;
+  }
+  removePaneFiles(root, rec);
+  out.cleaned.push(rec.paneId);
+}
 function ownerOfPaneId(id) {
   const m = id.match(/^c(\d+)-([0-9a-z]+)-/);
   if (!m)
     return null;
   return { pid: Number(m[1]), startMs: Number.parseInt(m[2] ?? "", 36) };
 }
-function ownerOfIdAlive(id, table) {
+function ownerOfSocketId(id) {
   const o = ownerOfPaneId(id);
-  if (!o)
-    return true;
-  const row = table.find((r) => r.pid === o.pid);
-  if (!row)
-    return false;
-  const started = Date.parse(row.lstart);
-  return !Number.isFinite(started) || Math.abs(started - o.startMs) < 2000;
+  return o ? { paneId: id, ownerPid: o.pid, ownerStart: "" } : null;
 }
 async function sweepRecordlessSocket(root, name, out) {
   const id = name.slice("magmux-".length, -".sock".length);
   const table = readProcessTable();
-  if (!processTableTrusted(table)) {
-    out.kept.push(id);
-    return;
-  }
-  if (ownerOfIdAlive(id, table))
+  const owner = ownerOfSocketId(id);
+  if (!owner || ownerAlive(owner, table))
     return;
   const sockPath = join43(root, name);
-  let client = null;
-  try {
-    client = await MagmuxClient.dial(sockPath);
-  } catch {
+  const magmuxMayLive = !table || table.some((r) => isPaneMagmuxCommand(r.command, id));
+  const probe = await probeSocket(sockPath, magmuxMayLive);
+  if (probe.state === "stale") {
     rmSync6(sockPath, { force: true });
     out.cleaned.push(id);
     return;
   }
+  if (probe.state === "inconclusive") {
+    out.kept.push(id);
+    return;
+  }
+  const client = probe.client;
+  if (!table) {
+    client.close();
+    out.kept.push(id);
+    return;
+  }
   const list = await client.request({
     type: "list"
   });
@@ -69948,7 +70054,7 @@ async function sweepOrphanPanes(root = sockRootFor()) {
   }
   return out;
 }
-var MAX_LIVE_PANES = 48, PaneLimitError, ownStart = null, live, reserved = 0, ticker = null, ticking = false, hookOpts, hooksInstalled = false, stdinHooked = false, shuttingDown = false, SIGNALS, sweptRoots;
+var MAX_LIVE_PANES = 48, PaneLimitError, ownStart = null, live, reserved = 0, ticker = null, ticking = false, hookOpts, hooksInstalled = false, stdinHooked = false, shuttingDown = false, SIGNALS, SOCKET_PROBE_TIMEOUT_MS = 2000, dialSocket = (p) => MagmuxClient.dial(p), sweptRoots;
 var init_pane_registry = __esm(() => {
   init_magmux_client();
   init_pane_launch();
@@ -72225,7 +72331,10 @@ class PaneSessionImpl {
   setPanePid(pid) {
     this.panePidValue = pid;
     updateRecord(this.root, this.paneId, { panePid: pid });
-    readProcessTableAsync().then((t) => refreshGroupOf(this, t));
+    readProcessTableAsync().then((t) => {
+      if (t)
+        refreshGroupOf(this, t);
+    });
   }
   onFrame(f) {
     if (f.pane !== undefined && f.pane !== 0)
@@ -74161,6 +74270,8 @@ ${screenTailOf(this.screen)}`
   }
   async captureGroupBeforeReap() {
     const table = await readProcessTableAsync();
+    if (!table)
+      return;
     if (!this.panePidValue && this.magmux?.pid) {
       const lead = table.find((r) => r.ppid === this.magmux?.pid && r.pgid === r.pid);
       if (lead) {
@@ -74175,12 +74286,16 @@ ${screenTailOf(this.screen)}`
     if (!this.group)
       return false;
     const table = await readProcessTableAsync();
+    if (!table)
+      return true;
     return groupCheck(table, this.group) || liveEscaped(table, this.group).length > 0;
   }
   async backstopTargets() {
     if (!this.group)
       return [];
     const table = await readProcessTableAsync();
+    if (!table)
+      return [];
     return [
       ...groupCheck(table, this.group) ? [-this.group.pgid] : [],
       ...liveEscaped(table, this.group)
@@ -74980,7 +75095,7 @@ var init_session_discovery = __esm(() => {
 import { randomBytes as randomBytes8, randomUUID as randomUUID6 } from "crypto";
 import {
   existsSync as existsSync33,
-  lstatSync as lstatSync3,
+  lstatSync as lstatSync4,
   mkdirSync as mkdirSync21,
   readFileSync as readFileSync32,
   readdirSync as readdirSync8,
@@ -75383,7 +75498,7 @@ function validateSessionPath(sessionPath) {
   const tail = [];
   for (;; ) {
     try {
-      lstatSync3(existing);
+      lstatSync4(existing);
       break;
     } catch {
       const parent = dirname16(existing);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "13.0.0",
+  "version": "13.0.2",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,6 +49,7 @@
   },
   "files": [
     "dist/",
+    "bin/",
     "AI_AGENT_GUIDE.md",
     "skills/"
   ],
@@ -68,10 +69,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "13.0.0",
-    "@claudish/magmux-darwin-x64": "13.0.0",
-    "@claudish/magmux-linux-arm64": "13.0.0",
-    "@claudish/magmux-linux-x64": "13.0.0"
+    "@claudish/magmux-darwin-arm64": "13.0.2",
+    "@claudish/magmux-darwin-x64": "13.0.2",
+    "@claudish/magmux-linux-arm64": "13.0.2",
+    "@claudish/magmux-linux-x64": "13.0.2"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",