@roulabs/mx 1.2.1 → 1.7.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 path8 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) => {
@@ -167,11 +172,23 @@ function initRuntime(target0, templatesDir2) {
   removeStaleRuntimeReadme(target);
   return { runtime: target, created };
 }
+function ensureWorkScaffolding(root, workName) {
+  const created = [];
+  const sessions = path3.join(workDir(root, workName), "sessions");
+  if (!exists(sessions)) {
+    fs4.mkdirSync(sessions, { recursive: true });
+    created.push(sessions);
+  }
+  return created;
+}
 function updateRuntime(root, templatesDir2) {
-  const dest = stampClaudeMd(root, templatesDir2);
-  const updated = [dest];
+  const updated = [];
+  updated.push(stampClaudeMd(root, templatesDir2));
   const ctxIndex = stampContextIndex(root, templatesDir2);
   if (ctxIndex) updated.push(ctxIndex);
+  for (const workName of listWorkNames(root)) {
+    updated.push(...ensureWorkScaffolding(root, workName));
+  }
   removeStaleRuntimeReadme(root);
   return { runtime: root, updated };
 }
@@ -309,26 +326,20 @@ function workNew(root, name, description = "") {
   const dir = workDir(root, name);
   if (exists(dir)) throw new MxError(`work already exists: ${name}`, "EXISTS");
   fs6.mkdirSync(dir, { recursive: true });
-  fs6.mkdirSync(path4.join(dir, "sessions"), { recursive: true });
   const work = { name, description, worktrees: [] };
   writeWork(root, work);
   writeJson(workspaceFile(root, name), { folders: [], settings: {} });
+  ensureWorkScaffolding(root, name);
   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) {
@@ -555,10 +566,24 @@ function portList(root, name) {
 }
 
 // ../../packages/core/src/status.ts
+import * as path5 from "path";
+function countContextEntries(root) {
+  const indexPath = path5.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) {
-  const repos = listReposInfo(root);
-  const works = listWorkNames(root).map((name) => readWork(root, name));
-  return { runtime: root, repos, works };
+  return {
+    runtime: root,
+    context: { entries: countContextEntries(root) },
+    repos: listReposInfo(root),
+    works: listWorksInfo(root, { includeArchived: true })
+  };
 }
 
 // src/args.ts
@@ -577,7 +602,6 @@ function parseArgs(argv) {
     help: false,
     version: false,
     force: false,
-    all: false,
     archived: false
   };
   for (let i = 0; i < argv.length; i++) {
@@ -590,8 +614,6 @@ function parseArgs(argv) {
       flags.version = true;
     } else if (a === "--force") {
       flags.force = true;
-    } else if (a === "--all") {
-      flags.all = true;
     } else if (a === "--archived") {
       flags.archived = true;
     } else if (a.startsWith("--") && a.includes("=")) {
@@ -609,6 +631,22 @@ function parseArgs(argv) {
 }
 
 // src/output.ts
+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";
+}
 var porcelain = false;
 function setPorcelain(value) {
   porcelain = value;
@@ -628,7 +666,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);
@@ -639,8 +679,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 [--porcelain]                show runtime, repos, works, ports  (aliases: mx s, mx st)
+  mx update                              re-sync runtime from current templates + backfill structural scaffolding
   mx help | version
 
 Repos (pristine clones):
@@ -652,7 +692,7 @@ Repos (pristine clones):
 
 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 [--archived] [--porcelain]                 default: all works (archived marked); --archived filters to 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,33 +714,33 @@ Runtime discovery: --runtime <path>  ->  $MX_RUNTIME  ->  default ~/mx.
 `;
 
 // src/commands/global.ts
-import * as path6 from "path";
+import * as path7 from "path";
 
 // src/paths.ts
-import * as path5 from "path";
+import * as path6 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 = path6.dirname(fileURLToPath(import.meta.url));
+  return path6.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 ? path7.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) {
@@ -709,8 +749,8 @@ 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;
@@ -718,31 +758,15 @@ function runGlobal(positionals, flags) {
     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);
+      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;
     }
@@ -750,6 +774,61 @@ 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 active = data.works.filter((w) => w.isArchived !== true);
+  const archived = data.works.filter((w) => w.isArchived === true);
+  const worksCount = archived.length > 0 ? dim(`(${active.length} active, ${archived.length} archived)`) : dim(`(${data.works.length})`);
+  console.log(`  ${bold("works")}  ${worksCount}`);
+  if (data.works.length === 0) {
+    console.log(`    ${dim("none yet \u2014 `mx work new <name>`")}`);
+    console.log();
+    return;
+  }
+  const ordered = [...active, ...archived];
+  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) {
@@ -764,13 +843,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;
     }
@@ -782,7 +872,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
       );
@@ -795,15 +885,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;
     }
@@ -813,7 +900,7 @@ 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;
     }
     default:
@@ -833,23 +920,48 @@ 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;
   }
   if (action === "ls") {
     const root2 = requireRuntime({ runtime: flags.runtime });
     const works = listWorksInfo(root2, {
-      includeArchived: flags.all,
+      includeArchived: true,
       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;
@@ -862,7 +974,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": {
@@ -873,7 +997,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":
@@ -883,33 +1007,32 @@ 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) {
         process.stderr.write(
-          `Reminder: write any pending session summary into works/${name}/sessions/ before archiving.
+          `${warn()} ${dim(`Reminder: write any pending session summary into works/${name}/sessions/ before archiving.`)}
 `
         );
       }
       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": {
@@ -926,8 +1049,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;
     }
@@ -944,15 +1069,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;
@@ -960,7 +1098,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:
@@ -981,7 +1124,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": {
@@ -989,17 +1137,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;
     }
@@ -1010,13 +1175,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 = path8.dirname(fileURLToPath2(import.meta.url));
+  const pkg = JSON.parse(readFileSync2(path8.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.1",
+  "version": "1.7.1",
   "description": "mx — run several features in parallel across shared repos using git worktrees",
   "type": "module",
   "bin": {