@roulabs/mx 1.2.2 → 1.10.1

package/bin/mx.js

@@ -2,7 +2,7 @@
 
 // src/main.ts
 import { readFileSync as readFileSync2 } from "fs";
-import * as path7 from "path";
+import * as path9 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../../packages/core/src/errors.ts
@@ -133,6 +133,11 @@ function writeWork(root, work) {
 function findWorktree(work, repo) {
   return (work.worktrees ?? []).find((w) => w.repo === repo) ?? null;
 }
+function countSessions(root, workName) {
+  const dir = path3.join(workDir(root, workName), "sessions");
+  if (!exists(dir)) return 0;
+  return fs4.readdirSync(dir).filter((n) => n.endsWith(".md")).length;
+}
 function inferContext(root) {
   const cwd = realpath(process.cwd());
   const segmentsUnder = (base) => {
@@ -190,6 +195,7 @@ function updateRuntime(root, templatesDir2) {
 
 // ../../packages/core/src/repos.ts
 import * as fs5 from "fs";
+import * as path4 from "path";
 
 // ../../packages/core/src/git.ts
 import { execFileSync } from "child_process";
@@ -279,6 +285,93 @@ function repoInfo(root, name) {
     worktreesInWorks: usedBy
   };
 }
+function originDefaultBranch(rp) {
+  const out = gitQuiet(["-C", rp, "symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+  if (!out) return null;
+  const m = out.match(/^origin\/(.+)$/);
+  return m ? m[1] : null;
+}
+function currentBranchOrNull(rp) {
+  const out = gitQuiet(["-C", rp, "symbolic-ref", "--short", "-q", "HEAD"]);
+  return out || null;
+}
+function statusCounts(rp) {
+  const out = gitQuiet(["-C", rp, "status", "--porcelain"]);
+  if (!out) return [0, 0];
+  let uncommitted = 0;
+  let untracked = 0;
+  for (const line of out.split("\n")) {
+    if (line.startsWith("??")) untracked++;
+    else if (line.length > 0) uncommitted++;
+  }
+  return [uncommitted, untracked];
+}
+function aheadBehind(rp, branch) {
+  if (!branch) return [null, null];
+  const upstream = `refs/remotes/origin/${branch}`;
+  const upstreamExists = gitQuiet(["-C", rp, "rev-parse", "--verify", upstream]);
+  if (!upstreamExists) return [null, null];
+  const out = gitQuiet(["-C", rp, "rev-list", "--left-right", "--count", `HEAD...${upstream}`]);
+  if (!out) return [null, null];
+  const [aheadStr, behindStr] = out.split(/\s+/);
+  return [Number(aheadStr), Number(behindStr)];
+}
+function lastFetched(rp) {
+  const fh = path4.join(rp, ".git", "FETCH_HEAD");
+  if (!exists(fh)) return null;
+  return fs5.statSync(fh).mtime.toISOString();
+}
+function repoHealth(root, name) {
+  const rp = repoPath(root, name);
+  if (!isGitRepo(rp)) throw new MxError(`no such repo: ${name}`, "NO_REPO");
+  const defaultBranch = originDefaultBranch(rp);
+  const current = currentBranchOrNull(rp);
+  const isOnDefault = current !== null && defaultBranch !== null && current === defaultBranch;
+  const [uncommittedChanges, untrackedFiles] = statusCounts(rp);
+  const [aheadOfOrigin, behindOfOrigin] = aheadBehind(rp, current);
+  const lastFetchedAt = lastFetched(rp);
+  const worktreesInWorks = listWorkNames(root).filter(
+    (w) => findWorktree(readWork(root, w), name)
+  );
+  const issues = [];
+  if (current === null) {
+    issues.push("HEAD is detached");
+  } else if (defaultBranch && !isOnDefault) {
+    issues.push(`on ${current} (default: ${defaultBranch})`);
+  }
+  if (uncommittedChanges > 0) {
+    issues.push(
+      `${uncommittedChanges} uncommitted change${uncommittedChanges === 1 ? "" : "s"}`
+    );
+  }
+  if (untrackedFiles > 0) {
+    issues.push(`${untrackedFiles} untracked file${untrackedFiles === 1 ? "" : "s"}`);
+  }
+  if (behindOfOrigin !== null && behindOfOrigin > 0) {
+    issues.push(`${behindOfOrigin} commit${behindOfOrigin === 1 ? "" : "s"} behind origin/${current}`);
+  }
+  if (aheadOfOrigin !== null && aheadOfOrigin > 0) {
+    issues.push(`${aheadOfOrigin} commit${aheadOfOrigin === 1 ? "" : "s"} ahead of origin/${current}`);
+  }
+  return {
+    name,
+    path: rp,
+    defaultBranch,
+    currentBranch: current,
+    isOnDefault,
+    uncommittedChanges,
+    untrackedFiles,
+    aheadOfOrigin,
+    behindOfOrigin,
+    lastFetchedAt,
+    worktreesInWorks,
+    healthy: issues.length === 0,
+    issues
+  };
+}
+function listRepoHealth(root) {
+  return listRepoNames(root).map((name) => repoHealth(root, name));
+}
 function repoRemove(root, name) {
   const rp = repoPath(root, name);
   if (!isGitRepo(rp)) throw new MxError(`no such repo: ${name}`, "NO_REPO");
@@ -295,7 +388,7 @@ function repoRemove(root, name) {
 
 // ../../packages/core/src/works.ts
 import * as fs6 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 function addFolderToWorkspace(root, name, repo) {
   const file = workspaceFile(root, name);
   const ws = exists(file) ? readJson(file) : { folders: [], settings: {} };
@@ -328,19 +421,13 @@ function workNew(root, name, description = "") {
   return { ...work, path: dir };
 }
 function listWorksInfo(root, opts = {}) {
-  return listWorkNames(root).map((name) => {
-    const w = readWork(root, name);
-    return {
-      name,
-      description: w.description ?? "",
-      worktrees: (w.worktrees ?? []).length,
-      isArchived: w.isArchived === true,
-      archived_at: w.archived_at ?? null
-    };
-  }).filter((s) => {
-    if (opts.onlyArchived) return s.isArchived;
+  return listWorkNames(root).map((name) => ({
+    ...readWork(root, name),
+    sessions: countSessions(root, name)
+  })).filter((w) => {
+    if (opts.onlyArchived) return w.isArchived === true;
     if (opts.includeArchived) return true;
-    return !s.isArchived;
+    return w.isArchived !== true;
   });
 }
 function workInfo(root, name) {
@@ -365,7 +452,7 @@ function worktreeAdd(root, name, repo, opts = {}) {
     throw new MxError(`work "${name}" already has worktree for ${repo}`, "EXISTS");
   }
   const branch = opts.branch || name;
-  const dest = path4.join(workDir(root, name), repo);
+  const dest = path5.join(workDir(root, name), repo);
   if (branchExists(rp, branch)) {
     git(["-C", rp, "worktree", "add", dest, branch]);
   } else {
@@ -392,7 +479,7 @@ function worktreeRemove(root, name, repo) {
   const work = readWork(root, name);
   const wt = findWorktree(work, repo);
   if (!wt) throw new MxError(`work "${name}" has no worktree for ${repo}`, "NO_WORKTREE");
-  const dest = path4.join(workDir(root, name), repo);
+  const dest = path5.join(workDir(root, name), repo);
   if (exists(dest) && isDirty(dest)) {
     throw new MxError(`worktree ${repo} has uncommitted changes \u2014 commit or discard them first`, "DIRTY");
   }
@@ -412,7 +499,7 @@ function workDestroy(root, name, opts = {}) {
   const work = readWork(root, name);
   const dirty = [];
   for (const wt of work.worktrees ?? []) {
-    const dest = path4.join(workDir(root, name), wt.repo);
+    const dest = path5.join(workDir(root, name), wt.repo);
     if (exists(dest) && isDirty(dest)) dirty.push(wt.repo);
   }
   if (dirty.length) {
@@ -423,7 +510,7 @@ function workDestroy(root, name, opts = {}) {
   }
   const removed = [];
   for (const wt of work.worktrees ?? []) {
-    const dest = path4.join(workDir(root, name), wt.repo);
+    const dest = path5.join(workDir(root, name), wt.repo);
     if (exists(dest)) git(["-C", repoPath(root, wt.repo), "worktree", "remove", dest]);
     removed.push(wt.repo);
   }
@@ -437,7 +524,7 @@ function archiveWork(root, name) {
   }
   const dirty = [];
   for (const wt of work.worktrees ?? []) {
-    const dest = path4.join(workDir(root, name), wt.repo);
+    const dest = path5.join(workDir(root, name), wt.repo);
     if (exists(dest) && isDirty(dest)) dirty.push(wt.repo);
   }
   if (dirty.length) {
@@ -448,7 +535,7 @@ function archiveWork(root, name) {
   }
   const removed = [];
   for (const wt of work.worktrees ?? []) {
-    const dest = path4.join(workDir(root, name), wt.repo);
+    const dest = path5.join(workDir(root, name), wt.repo);
     if (exists(dest)) git(["-C", repoPath(root, wt.repo), "worktree", "remove", dest]);
     removed.push(wt.repo);
   }
@@ -487,7 +574,7 @@ function unarchiveWork(root, name, overrides = {}) {
   }
   const restored = [];
   for (const d of desired) {
-    const dest = path4.join(workDir(root, name), d.repo);
+    const dest = path5.join(workDir(root, name), d.repo);
     git(["-C", repoPath(root, d.repo), "worktree", "add", dest, d.branch]);
     addFolderToWorkspace(root, name, d.repo);
     restored.push({ repo: d.repo, branch: d.branch, path: dest, ports: d.ports });
@@ -567,10 +654,28 @@ function portList(root, name) {
 }
 
 // ../../packages/core/src/status.ts
-function statusRuntime(root) {
-  const repos = listReposInfo(root);
-  const works = listWorkNames(root).map((name) => readWork(root, name));
-  return { runtime: root, repos, works };
+import * as path6 from "path";
+function countContextEntries(root) {
+  const indexPath = path6.join(root, "context", "INDEX.json");
+  if (!exists(indexPath)) return 0;
+  try {
+    const data = readJson(indexPath);
+    return Array.isArray(data) ? data.length : 0;
+  } catch {
+    return 0;
+  }
+}
+function statusRuntime(root, opts = {}) {
+  const all = listWorksInfo(root, { includeArchived: true });
+  const archivedWorksCount = all.filter((w) => w.isArchived === true).length;
+  const works = opts.onlyArchived ? all.filter((w) => w.isArchived === true) : opts.includeArchived ? all : all.filter((w) => w.isArchived !== true);
+  return {
+    runtime: root,
+    context: { entries: countContextEntries(root) },
+    repos: listReposInfo(root),
+    works,
+    archivedWorksCount
+  };
 }
 
 // src/args.ts
@@ -589,6 +694,7 @@ function parseArgs(argv) {
     help: false,
     version: false,
     force: false,
+    yes: false,
     all: false,
     archived: false
   };
@@ -602,6 +708,8 @@ function parseArgs(argv) {
       flags.version = true;
     } else if (a === "--force") {
       flags.force = true;
+    } else if (a === "--yes" || a === "-y") {
+      flags.yes = true;
     } else if (a === "--all") {
       flags.all = true;
     } else if (a === "--archived") {
@@ -621,6 +729,35 @@ function parseArgs(argv) {
 }
 
 // src/output.ts
+import { spawnSync } from "child_process";
+var USE_STYLE = process.stdout.isTTY && !process.env.NO_COLOR;
+function wrap(s, code) {
+  return USE_STYLE ? `\x1B[${code}m${s}\x1B[0m` : s;
+}
+function dim(s) {
+  return wrap(s, 2);
+}
+function bold(s) {
+  return wrap(s, 1);
+}
+function check() {
+  return "\u2713";
+}
+function warn() {
+  return "\u26A0";
+}
+function confirmYesNo(prompt) {
+  if (!process.stdin.isTTY) return false;
+  process.stdout.write(prompt);
+  const result = spawnSync(
+    "/bin/sh",
+    ["-c", `IFS= read -r REPLY && printf '%s' "$REPLY"`],
+    { stdio: ["inherit", "pipe", "inherit"], encoding: "utf8" }
+  );
+  if (result.status !== 0 || result.signal) return false;
+  const answer = (result.stdout ?? "").trim().toLowerCase();
+  return answer === "y" || answer === "yes";
+}
 var porcelain = false;
 function setPorcelain(value) {
   porcelain = value;
@@ -640,7 +777,9 @@ function fail(err) {
   if (porcelain) {
     process.stdout.write(JSON.stringify({ error: message, code }, null, 2) + "\n");
   } else {
-    process.stderr.write(`mx: ${message}
+    const useStyle = process.stderr.isTTY && !process.env.NO_COLOR;
+    const prefix = useStyle ? `\x1B[1mmx:\x1B[0m` : "mx:";
+    process.stderr.write(`${prefix} ${message}
 `);
   }
   process.exit(1);
@@ -651,8 +790,8 @@ var HELP = `mx \u2014 control panel for the mx runtime
 
 Global:
   mx init [path]                         scaffold/adopt a runtime (default ~/mx)
-  mx status [--porcelain]                show runtime, repos, works, ports
-  mx update                              re-stamp runtime CLAUDE.md from templates
+  mx status [--all] [--porcelain]        show runtime, repos, works, ports (active only by default; --all to include archived; aliases: mx s, mx st)
+  mx update                              re-sync runtime from current templates + backfill structural scaffolding
   mx help | version
 
 Repos (pristine clones):
@@ -660,11 +799,13 @@ Repos (pristine clones):
   mx repo ls [--porcelain]
   mx repo -n <name> fetch                git fetch (+ ff current branch)
   mx repo -n <name> info [--porcelain]
+  mx repo health [--porcelain]           pure-local health summary for every pristine clone
+  mx repo -n <name> health [--porcelain] detailed health for one pristine clone
   mx repo -n <name> rm                   refuses if any work uses it
 
 Works (features):
   mx work new <name> [--description <t>]                creates folder + empty work.json + sessions/
-  mx work ls [--all|--archived] [--porcelain]           default: active only
+  mx work ls [--all|--archived] [--porcelain]           default: active only; --all includes archived; --archived shows archived only
   mx work -n <name> info [--porcelain]
   mx work -n <name> path                                print the work folder path (cd "$(mx work -n <name> path)")
   mx work -n <name> describe <text>
@@ -674,7 +815,7 @@ Works (features):
   mx work -n <name> port set <repo> <service> [<port>]  auto-picks a free port if omitted
   mx work -n <name> port unset <repo> <service>
   mx work -n <name> port ls [--porcelain]
-  mx work -n <name> archive                             removes worktrees; keeps folder + work.json + sessions; recoverable
+  mx work -n <name> archive [--yes|-y]                  removes worktrees; keeps folder + work.json + sessions; prompts for confirmation (use --yes to skip)
   mx work -n <name> unarchive [<repo>=<branch>...]      re-creates worktrees from work.json; override per-repo branch if recorded one is missing
   mx work -n <name> destroy --force                     PERMANENT: deletes the work folder including session summaries (branches kept). Prefer archive.
 
@@ -686,33 +827,33 @@ Runtime discovery: --runtime <path>  ->  $MX_RUNTIME  ->  default ~/mx.
 `;
 
 // src/commands/global.ts
-import * as path6 from "path";
+import * as path8 from "path";
 
 // src/paths.ts
-import * as path5 from "path";
+import * as path7 from "path";
 import { fileURLToPath } from "url";
 function templatesDir() {
   if (process.env.MX_TEMPLATES_DIR) return process.env.MX_TEMPLATES_DIR;
-  const here = path5.dirname(fileURLToPath(import.meta.url));
-  return path5.join(here, "..", "templates");
+  const here = path7.dirname(fileURLToPath(import.meta.url));
+  return path7.join(here, "..", "templates");
 }
 
 // src/commands/global.ts
 function runtimeEnvHint(runtime) {
-  const envRuntime = process.env.MX_RUNTIME ? path6.resolve(process.env.MX_RUNTIME) : null;
+  const envRuntime = process.env.MX_RUNTIME ? path8.resolve(process.env.MX_RUNTIME) : null;
   if (envRuntime === runtime) {
-    return ["", `$MX_RUNTIME already points here \u2014 you're set.`];
+    return ["", `${dim("$MX_RUNTIME already points here \u2014 you're set.")}`];
   }
   if (runtime === defaultRuntime() && !envRuntime) {
-    return ["", `This is the default mx runtime (~/mx) \u2014 no MX_RUNTIME setup needed.`];
+    return ["", `${dim("This is the default mx runtime (~/mx) \u2014 no MX_RUNTIME setup needed.")}`];
   }
   return [
     "",
-    `Point mx at this runtime by adding to your shell config (~/.zshrc, ~/.bashrc):`,
+    `Point mx at this runtime by adding to your shell config ${dim("(~/.zshrc, ~/.bashrc)")}:`,
     "",
-    `  export MX_RUNTIME="${runtime}"`,
+    `  ${bold(`export MX_RUNTIME="${runtime}"`)}`,
     "",
-    `Without it, future \`mx\` commands fall back to the default ~/mx.`
+    dim("Without it, future `mx` commands fall back to the default ~/mx.")
   ];
 }
 function runGlobal(positionals, flags) {
@@ -721,40 +862,24 @@ function runGlobal(positionals, flags) {
       const target = positionals[1] || discoverRuntime({ runtime: flags.runtime });
       const res = initRuntime(target, templatesDir());
       emit(() => {
-        console.log(`Runtime ready at ${res.runtime}`);
-        for (const c of res.created) console.log(`  + ${c}`);
+        console.log(`${check()} Runtime ready at ${bold(res.runtime)}`);
+        for (const c of res.created) console.log(`  ${dim(`+ ${c}`)}`);
         for (const line of runtimeEnvHint(res.runtime)) console.log(line);
       }, res);
       return;
     }
     case "status": {
       const root = requireRuntime({ runtime: flags.runtime });
-      const data = statusRuntime(root);
-      emit(() => {
-        console.log(`runtime: ${data.runtime}
-`);
-        console.log(`repos (${data.repos.length}):`);
-        for (const r of data.repos) {
-          console.log(`  ${r.name}  [${r.branch}]  ${r.remote ?? "(no remote)"}`);
-        }
-        console.log(`
-works (${data.works.length}):`);
-        for (const w of data.works) {
-          console.log(`  ${w.name}${w.description ? `  \u2014 ${w.description}` : ""}`);
-          for (const wt of w.worktrees) {
-            const ports = Object.entries(wt.ports).map(([s, p]) => `${s}:${p}`).join(", ");
-            console.log(`    ${wt.repo}  [${wt.branch}]${ports ? `  (${ports})` : ""}`);
-          }
-        }
-      }, data);
+      const data = statusRuntime(root, { includeArchived: flags.all });
+      emit(() => renderStatus(data), data);
       return;
     }
     case "update": {
       const root = requireRuntime({ runtime: flags.runtime });
       const res = updateRuntime(root, templatesDir());
       emit(() => {
-        console.log(`Updated runtime at ${res.runtime}`);
-        for (const p of res.updated) console.log(`  + ${p}`);
+        console.log(`${check()} Updated runtime at ${bold(res.runtime)}`);
+        for (const p of res.updated) console.log(`  ${dim(`+ ${p}`)}`);
       }, res);
       return;
     }
@@ -762,6 +887,63 @@ works (${data.works.length}):`);
       throw new MxError(`unknown command: ${positionals[0]}`, "BAD_ARGS");
   }
 }
+function renderStatus(data) {
+  console.log();
+  console.log(`  ${bold("mx")} ${dim("\xB7")} ${data.runtime}`);
+  console.log();
+  console.log(`  ${bold("context")}  ${dim(`(${data.context.entries})`)}`);
+  console.log();
+  console.log(`  ${bold("repos")}`);
+  if (data.repos.length === 0) {
+    console.log(`    ${dim("none yet \u2014 `mx repo add <git-url>`")}`);
+  } else {
+    const nameW = Math.max(...data.repos.map((r) => r.name.length));
+    const branchW = Math.max(...data.repos.map((r) => r.branch.length));
+    for (const r of data.repos) {
+      const name = r.name.padEnd(nameW);
+      const branch = dim(r.branch.padEnd(branchW));
+      const remote = dim(r.remote ?? "(no remote)");
+      console.log(`    \u2022 ${name}  ${branch}  ${remote}`);
+    }
+  }
+  console.log();
+  const visibleArchived = data.works.filter((w) => w.isArchived === true);
+  const visibleActive = data.works.filter((w) => w.isArchived !== true);
+  const hiddenArchived = data.archivedWorksCount - visibleArchived.length;
+  const worksCount = data.archivedWorksCount > 0 ? dim(`(${visibleActive.length} active, ${data.archivedWorksCount} archived${hiddenArchived > 0 ? ` \u2014 pass --all to show` : ""})`) : dim(`(${data.works.length})`);
+  console.log(`  ${bold("works")}  ${worksCount}`);
+  if (data.works.length === 0) {
+    const empty = hiddenArchived > 0 ? `${hiddenArchived} archived hidden \u2014 pass --all to show` : "none yet \u2014 `mx work new <name>`";
+    console.log(`    ${dim(empty)}`);
+    console.log();
+    return;
+  }
+  const ordered = [...visibleActive, ...visibleArchived];
+  const wtRepoW = Math.max(
+    0,
+    ...ordered.flatMap((w) => (w.worktrees ?? []).map((wt) => wt.repo.length))
+  );
+  for (let i = 0; i < ordered.length; i++) {
+    if (i > 0) console.log();
+    const w = ordered[i];
+    const wts = w.worktrees ?? [];
+    const chip = w.isArchived === true ? `  ${dim(`[archived ${(w.archived_at ?? "").slice(0, 10)}]`)}` : "";
+    const styledName = w.isArchived === true ? dim(w.name) : bold(w.name);
+    console.log(`    \u2022 ${styledName}${chip}`);
+    if (wts.length === 0) {
+      console.log(`        ${dim("(no worktrees)")}`);
+      continue;
+    }
+    for (const t of wts) {
+      const repo = dim(t.repo.padEnd(wtRepoW));
+      const branch = dim(`[${t.branch}]`);
+      const ports = Object.entries(t.ports ?? {}).map(([s, p]) => dim(`${s}:${p}`)).join("  ");
+      const portsCol = ports ? `  ${ports}` : "";
+      console.log(`        ${repo}  ${branch}${portsCol}`);
+    }
+  }
+  console.log();
+}
 
 // src/commands/repo.ts
 function need(v, msg) {
@@ -776,13 +958,24 @@ function dispatchRepo(positionals, flags) {
     case "add": {
       const url = need(positionals[2], "usage: mx repo add <git-url> [--name <n>]");
       const res = repoAdd(root, url, flags.name);
-      emit(() => console.log(`cloned ${res.name} -> ${res.path}`), res);
+      emit(() => console.log(`${check()} cloned ${bold(res.name)} ${dim(`\u2192 ${res.path}`)}`), res);
       return;
     }
     case "ls": {
       const repos = listReposInfo(root);
       emit(() => {
-        for (const r of repos) console.log(`${r.name}  [${r.branch}]  ${r.remote ?? "(no remote)"}`);
+        if (repos.length === 0) {
+          console.log(dim("no repos yet \u2014 `mx repo add <git-url>`"));
+          return;
+        }
+        const nameW = Math.max(...repos.map((r) => r.name.length));
+        const branchW = Math.max(...repos.map((r) => r.branch.length));
+        for (const r of repos) {
+          const name = r.name.padEnd(nameW);
+          const branch = dim(r.branch.padEnd(branchW));
+          const remote = dim(r.remote ?? "(no remote)");
+          console.log(`\u2022 ${name}  ${branch}  ${remote}`);
+        }
       }, repos);
       return;
     }
@@ -794,7 +987,7 @@ function dispatchRepo(positionals, flags) {
       const res = repoFetch(root, name);
       emit(
         () => console.log(
-          `fetched ${res.name} \u2014 ${res.remoteBranches.length} branch(es) on origin, now on ${res.branch}`
+          `${check()} fetched ${bold(res.name)} ${dim(`\u2014 ${res.remoteBranches.length} branch(es) on origin, now on ${res.branch}`)}`
         ),
         res
       );
@@ -807,15 +1000,12 @@ function dispatchRepo(positionals, flags) {
       );
       const res = repoInfo(root, name);
       emit(() => {
-        console.log(
-          `${res.name}
-  path:   ${res.path}
-  branch: ${res.branch}
-  remote: ${res.remote ?? "(none)"}`
-        );
-        console.log(
-          `  used by works: ${res.worktreesInWorks.length ? res.worktreesInWorks.join(", ") : "(none)"}`
-        );
+        console.log(bold(res.name));
+        console.log(`  ${dim("path  ")}  ${dim(res.path)}`);
+        console.log(`  ${dim("branch")}  ${dim(res.branch)}`);
+        console.log(`  ${dim("remote")}  ${dim(res.remote ?? "(none)")}`);
+        const usedBy = res.worktreesInWorks.length ? res.worktreesInWorks.join(", ") : "(none)";
+        console.log(`  ${dim("used  ")}  ${dim(usedBy)}`);
       }, res);
       return;
     }
@@ -825,13 +1015,108 @@ function dispatchRepo(positionals, flags) {
         "which repo? pass -n <name> or run inside a repo (mx repo -n <name> rm)"
       );
       const res = repoRemove(root, name);
-      emit(() => console.log(`removed repo ${res.name}`), res);
+      emit(() => console.log(`${check()} removed repo ${bold(res.name)}`), res);
+      return;
+    }
+    case "health": {
+      const name = flags.name || ctxRepo;
+      if (name) {
+        const h = repoHealth(root, name);
+        emit(() => renderHealthDetail(h), h);
+      } else {
+        const list = listRepoHealth(root);
+        emit(() => renderHealthList(list), list);
+      }
       return;
     }
     default:
       throw new MxError(`unknown repo command: ${action ?? "(none)"}`, "BAD_ARGS");
   }
 }
+function relativeTime(iso) {
+  if (!iso) return "never";
+  const then = Date.parse(iso);
+  const seconds = Math.max(0, Math.floor((Date.now() - then) / 1e3));
+  if (seconds < 60) return `${seconds} second${seconds === 1 ? "" : "s"} ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 30) return `${days} day${days === 1 ? "" : "s"} ago`;
+  const months = Math.floor(days / 30);
+  if (months < 12) return `${months} month${months === 1 ? "" : "s"} ago`;
+  const years = Math.floor(months / 12);
+  return `${years} year${years === 1 ? "" : "s"} ago`;
+}
+function renderHealthList(list) {
+  if (list.length === 0) {
+    console.log(dim("no repos yet \u2014 `mx repo add <git-url>`"));
+    return;
+  }
+  const nameW = Math.max(...list.map((h) => h.name.length));
+  for (const h of list) {
+    const marker = h.healthy ? check() : warn();
+    const name = h.name.padEnd(nameW);
+    const detail = h.healthy ? "" : `  ${dim(h.issues.join("; "))}`;
+    console.log(`${marker} ${name}${detail}`);
+  }
+}
+function renderHealthDetail(h) {
+  const rows = [];
+  const addRow = (label, value, ok, hint) => {
+    const marker = ok === void 0 ? void 0 : ok ? check() : warn();
+    rows.push({ label, value, marker, hint });
+  };
+  addRow("default branch", h.defaultBranch ?? "(unknown)");
+  const currentBranchText = h.currentBranch ?? "(detached HEAD)";
+  const branchOk = h.currentBranch !== null && h.isOnDefault;
+  addRow(
+    "current branch",
+    currentBranchText,
+    branchOk,
+    branchOk ? void 0 : h.currentBranch === null ? "HEAD is detached" : `should be ${h.defaultBranch ?? "(default)"}`
+  );
+  addRow(
+    "uncommitted",
+    `${h.uncommittedChanges} change${h.uncommittedChanges === 1 ? "" : "s"}`,
+    h.uncommittedChanges === 0,
+    h.uncommittedChanges === 0 ? void 0 : "commit or discard"
+  );
+  addRow(
+    "untracked",
+    `${h.untrackedFiles} file${h.untrackedFiles === 1 ? "" : "s"}`,
+    h.untrackedFiles === 0
+  );
+  addRow(
+    "ahead of origin",
+    h.aheadOfOrigin === null ? "(no upstream)" : `${h.aheadOfOrigin} commit${h.aheadOfOrigin === 1 ? "" : "s"}`,
+    h.aheadOfOrigin === null ? void 0 : h.aheadOfOrigin === 0
+  );
+  addRow(
+    "behind of origin",
+    h.behindOfOrigin === null ? "(no upstream)" : `${h.behindOfOrigin} commit${h.behindOfOrigin === 1 ? "" : "s"}`,
+    h.behindOfOrigin === null ? void 0 : h.behindOfOrigin === 0,
+    (h.behindOfOrigin ?? 0) > 0 ? `run \`mx repo -n ${h.name} fetch\`` : void 0
+  );
+  addRow("last fetched", relativeTime(h.lastFetchedAt));
+  const usedByCount = h.worktreesInWorks.length;
+  rows.push({
+    label: "worktrees in works",
+    value: String(usedByCount),
+    hint: usedByCount ? `used by: ${h.worktreesInWorks.join(", ")}` : void 0
+  });
+  const labelW = Math.max(...rows.map((r) => r.label.length));
+  const valueW = Math.max(...rows.map((r) => r.value.length));
+  console.log(bold(h.name));
+  for (const r of rows) {
+    const label = dim(r.label.padEnd(labelW));
+    const value = r.value.padEnd(valueW);
+    const marker = r.marker ? `  ${r.marker}` : "   ";
+    const hint = r.hint ? `  ${dim(r.hint)}` : "";
+    console.log(`  ${label}  ${value}${marker}${hint}`);
+  }
+}
 
 // src/commands/work.ts
 function need2(v, msg) {
@@ -845,8 +1130,8 @@ function dispatchWork(positionals, flags) {
     const name2 = need2(positionals[2], "usage: mx work new <name> [--description <text>]");
     const res = workNew(root2, name2, flags.description ?? "");
     emit(() => {
-      console.log(`created work ${res.name}`);
-      console.log(`  ${res.path}`);
+      console.log(`${check()} created work ${bold(res.name)}`);
+      console.log(`  ${dim(res.path)}`);
     }, res);
     return;
   }
@@ -857,11 +1142,36 @@ function dispatchWork(positionals, flags) {
       onlyArchived: flags.archived
     });
     emit(() => {
-      for (const w of works) {
-        const chip = w.isArchived ? `[archived ${(w.archived_at ?? "").slice(0, 10)}]  ` : "";
-        const desc = w.description ? `  \u2014 ${w.description}` : "";
-        const wts = `(${w.worktrees} worktree${w.worktrees === 1 ? "" : "s"})`;
-        console.log(`${chip}${w.name}  ${wts}${desc}`);
+      const ordered = [
+        ...works.filter((w) => w.isArchived !== true),
+        ...works.filter((w) => w.isArchived === true)
+      ];
+      if (ordered.length === 0) {
+        console.log(dim("no works yet \u2014 `mx work new <name>`"));
+        return;
+      }
+      for (let i = 0; i < ordered.length; i++) {
+        if (i > 0) console.log();
+        const w = ordered[i];
+        const wts = w.worktrees ?? [];
+        const chip = w.isArchived === true ? `  ${dim(`[archived ${(w.archived_at ?? "").slice(0, 10)}]`)}` : "";
+        const styledName = w.isArchived === true ? dim(w.name) : bold(w.name);
+        console.log(`\u2022 ${styledName}${chip}`);
+        if (w.description) {
+          console.log(`  ${dim(`\u2014 ${w.description}`)}`);
+        }
+        if (wts.length === 0) {
+          console.log(`  ${dim("(no worktrees)")}`);
+        } else {
+          const repoW = Math.max(...wts.map((t) => t.repo.length));
+          for (const t of wts) {
+            const repo = dim(t.repo.padEnd(repoW));
+            const branch = dim(`[${t.branch}]`);
+            const ports = Object.entries(t.ports ?? {}).map(([s, p]) => `${dim(`${s}:${p}`)}`).join("  ");
+            const portsCol = ports ? `  ${ports}` : "";
+            console.log(`  ${repo}  ${branch}${portsCol}`);
+          }
+        }
       }
     }, works);
     return;
@@ -874,7 +1184,19 @@ function dispatchWork(positionals, flags) {
   switch (action) {
     case "info": {
       const work = workInfo(root, name);
-      emit(() => console.log(JSON.stringify(work, null, 2)), work);
+      emit(() => {
+        const archivedChip = work.isArchived === true ? `  ${dim(`[archived ${(work.archived_at ?? "").slice(0, 10)}]`)}` : "";
+        const styledName = work.isArchived === true ? dim(work.name) : bold(work.name);
+        console.log(`${styledName}${archivedChip}`);
+        if (work.description) console.log(`  ${dim("description")}  ${dim(work.description)}`);
+        const wts = work.worktrees ?? [];
+        console.log(`  ${dim("worktrees  ")}  ${dim(`${wts.length}`)}`);
+        for (const wt of wts) {
+          const ports = Object.entries(wt.ports ?? {}).map(([s, p]) => `${dim(`${s}:`)}${dim(String(p))}`).join("  ");
+          const portsCol = ports ? `  ${ports}` : "";
+          console.log(`      ${dim(wt.repo)}  ${dim(`[${wt.branch}]`)}${portsCol}`);
+        }
+      }, work);
       return;
     }
     case "path": {
@@ -885,7 +1207,7 @@ function dispatchWork(positionals, flags) {
     case "describe": {
       const text = need2(positionals[2], "usage: mx work -n <name> describe <text>");
       const work = workDescribe(root, name, text);
-      emit(() => console.log(`updated description of ${name}`), work);
+      emit(() => console.log(`${check()} updated description of ${bold(name)}`), work);
       return;
     }
     case "worktree":
@@ -895,33 +1217,50 @@ function dispatchWork(positionals, flags) {
     case "destroy": {
       if (flags.force && !flags.porcelain) {
         process.stderr.write(
-          `\u26A0  permanently removing work "${name}" \u2014 folder and any session summaries will be deleted (branches kept). This cannot be undone.
+          `${warn()} ${dim(`permanently removing work "${name}" \u2014 folder and any session summaries will be deleted (branches kept). This cannot be undone.`)}
 `
         );
       }
       const res = workDestroy(root, name, { force: flags.force });
-      emit(
-        () => console.log(
-          `destroyed work ${name} (worktrees removed: ${res.removedWorktrees.join(", ") || "none"}; branches kept)`
-        ),
-        res
-      );
+      emit(() => {
+        const removed = res.removedWorktrees.join(", ") || "none";
+        console.log(`${check()} destroyed work ${bold(name)}`);
+        console.log(`  ${dim(`worktrees removed: ${removed}; branches kept`)}`);
+      }, res);
       return;
     }
     case "archive": {
-      if (!flags.porcelain) {
+      if (!flags.yes) {
+        if (flags.porcelain || !process.stdin.isTTY) {
+          throw new MxError(
+            `archive requires confirmation \u2014 pass --yes when running non-interactively or with --porcelain`,
+            "NEED_CONFIRMATION"
+          );
+        }
+        process.stderr.write(`${warn()} About to archive work ${bold(name)}.
+`);
+        process.stderr.write(
+          `${dim(`  Worktrees will be removed; folder, work.json, branches, and sessions/ are preserved.`)}
+`
+        );
         process.stderr.write(
-          `Reminder: write any pending session summary into works/${name}/sessions/ before archiving.
+          `${dim(`  Make sure any pending session summary is written into works/${name}/sessions/ first.`)}
 `
         );
+        process.stderr.write("\n");
+        if (!confirmYesNo("Proceed? (y/N) ")) {
+          process.stderr.write(`${dim("Aborted.")}
+`);
+          return;
+        }
       }
       const res = archiveWork(root, name);
-      emit(
-        () => console.log(
-          `archived work ${name} at ${res.archived_at} (worktrees removed: ${res.removedWorktrees.join(", ") || "none"}; branches kept)`
-        ),
-        res
-      );
+      emit(() => {
+        const removed = res.removedWorktrees.join(", ") || "none";
+        console.log(`${check()} archived work ${bold(name)}`);
+        console.log(`  ${dim(`at ${res.archived_at}`)}`);
+        console.log(`  ${dim(`worktrees removed: ${removed}; branches kept`)}`);
+      }, res);
       return;
     }
     case "unarchive": {
@@ -938,8 +1277,10 @@ function dispatchWork(positionals, flags) {
       }
       const res = unarchiveWork(root, name, overrides);
       emit(() => {
-        console.log(`unarchived work ${name}`);
-        for (const r of res.restored) console.log(`  ${r.repo}  [${r.branch}]  -> ${r.path}`);
+        console.log(`${check()} unarchived work ${bold(name)}`);
+        for (const r of res.restored) {
+          console.log(`  ${r.repo}  ${dim(`[${r.branch}]`)}  ${dim(`\u2192 ${r.path}`)}`);
+        }
       }, res);
       return;
     }
@@ -956,15 +1297,28 @@ function workWorktree(root, name, positionals, flags) {
         "usage: mx work -n <name> worktree add <repo> [--branch <b>] [--base <ref>]"
       );
       const res = worktreeAdd(root, name, repo, { branch: flags.branch, base: flags.base });
-      emit(() => console.log(`added worktree ${res.repo} [${res.branch}] -> ${res.path}`), res);
+      emit(
+        () => console.log(
+          `${check()} added worktree ${bold(res.repo)} ${dim(`[${res.branch}]`)} ${dim(`\u2192 ${res.path}`)}`
+        ),
+        res
+      );
       return;
     }
     case "ls": {
       const list = worktreeList(root, name);
       emit(() => {
+        if (list.length === 0) {
+          console.log(dim("no worktrees yet \u2014 `mx work -n <name> worktree add <repo>`"));
+          return;
+        }
+        const repoW = Math.max(...list.map((wt) => wt.repo.length));
         for (const wt of list) {
-          const ports = Object.entries(wt.ports ?? {}).map(([s, p]) => `${s}:${p}`).join(", ");
-          console.log(`${wt.repo}  [${wt.branch}]${ports ? `  (${ports})` : ""}`);
+          const repo = dim(wt.repo.padEnd(repoW));
+          const branch = dim(`[${wt.branch}]`);
+          const ports = Object.entries(wt.ports ?? {}).map(([s, p]) => `${dim(`${s}:`)}${dim(String(p))}`).join("  ");
+          const portsCol = ports ? `  ${ports}` : "";
+          console.log(`${repo}  ${branch}${portsCol}`);
         }
       }, list);
       return;
@@ -972,7 +1326,12 @@ function workWorktree(root, name, positionals, flags) {
     case "rm": {
       const repo = need2(positionals[3], "usage: mx work -n <name> worktree rm <repo>");
       const res = worktreeRemove(root, name, repo);
-      emit(() => console.log(`removed worktree ${res.repo} from ${name} (branch ${res.branch} kept)`), res);
+      emit(
+        () => console.log(
+          `${check()} removed worktree ${bold(res.repo)} ${dim(`from ${name} (branch ${res.branch} kept)`)}`
+        ),
+        res
+      );
       return;
     }
     default:
@@ -993,7 +1352,12 @@ function workPort(root, name, positionals) {
         if (!Number.isInteger(port)) throw new MxError(`invalid port: ${portArg}`, "BAD_ARGS");
       }
       const res = portSet(root, name, repo, service, port);
-      emit(() => console.log(`${res.repo}.${res.service} -> ${res.port}`), res);
+      emit(
+        () => console.log(
+          `${check()} ${res.repo}${dim(".")}${res.service} ${dim("\u2192")} ${dim(String(res.port))}`
+        ),
+        res
+      );
       return;
     }
     case "unset": {
@@ -1001,17 +1365,34 @@ function workPort(root, name, positionals) {
       const repo = need2(positionals[3], usage);
       const service = need2(positionals[4], usage);
       const res = portUnset(root, name, repo, service);
-      emit(() => console.log(`unset ${res.repo}.${res.service} (was ${res.released})`), res);
+      emit(
+        () => console.log(
+          `${check()} unset ${res.repo}${dim(".")}${res.service} ${dim(`(was ${res.released})`)}`
+        ),
+        res
+      );
       return;
     }
     case "ls": {
       const map = portList(root, name);
       emit(() => {
+        const entries = [];
         for (const [repo, ports] of Object.entries(map)) {
           for (const [service, port] of Object.entries(ports)) {
-            console.log(`${repo}.${service} -> ${port}`);
+            entries.push({ repo, service, port });
           }
         }
+        if (entries.length === 0) {
+          console.log(dim("no ports allocated yet \u2014 `mx work -n <name> port set <repo> <service>`"));
+          return;
+        }
+        const lhsW = Math.max(...entries.map((e) => `${e.repo}.${e.service}`.length));
+        for (const e of entries) {
+          const lhs = `${e.repo}${dim(".")}${e.service}`;
+          const plain = `${e.repo}.${e.service}`;
+          const pad = " ".repeat(lhsW - plain.length);
+          console.log(`${lhs}${pad}  ${dim("\u2192")}  ${dim(String(e.port))}`);
+        }
       }, map);
       return;
     }
@@ -1022,13 +1403,14 @@ function workPort(root, name, positionals) {
 
 // src/main.ts
 var VERSION = (() => {
-  const here = path7.dirname(fileURLToPath2(import.meta.url));
-  const pkg = JSON.parse(readFileSync2(path7.join(here, "..", "package.json"), "utf8"));
+  const here = path9.dirname(fileURLToPath2(import.meta.url));
+  const pkg = JSON.parse(readFileSync2(path9.join(here, "..", "package.json"), "utf8"));
   return pkg.version;
 })();
 function main() {
   const { positionals, flags } = parseArgs(process.argv.slice(2));
   setPorcelain(flags.porcelain);
+  if (positionals[0] === "s" || positionals[0] === "st") positionals[0] = "status";
   try {
     if (flags.version || positionals[0] === "version") {
       emit(() => console.log(`mx ${VERSION}`), { version: VERSION });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@roulabs/mx",
-  "version": "1.2.2",
+  "version": "1.10.1",
   "description": "mx — run several features in parallel across shared repos using git worktrees",
   "type": "module",
   "bin": {