@codeyam-editor/codeyam-editor 0.1.1 → 0.1.2

package/npm/container.js

@@ -8,12 +8,31 @@ const path = require("path");
  * inline monitoring UI at http://localhost:14199.
  */
 
-const { ensureServer, rootDir, killChildProcess } = require("./utils");
+const {
+  ensureServer,
+  rootDir,
+  killChildProcess,
+  readMergedEditorConfig,
+  resolveLauncherPort,
+} = require("./utils");
 const { open } = require("./open");
 
-const PORT = 14199;
-
+/**
+ * npm wrapper entry point for the container binary: ensures the Rust
+ * editor server is running and opens the container monitoring UI in
+ * a browser.
+ */
 async function main() {
+  // Same resolution order as the editor launcher: env var
+  // (CODEYAM_EDITOR_PORT) → merged editor.json + editor.local.json
+  // (proxy.controlPort) → hard fallback (14199).
+  const merged = readMergedEditorConfig(rootDir);
+  const PORT = resolveLauncherPort(
+    process.env.CODEYAM_EDITOR_PORT,
+    merged.proxy && merged.proxy.controlPort,
+    14199,
+  );
+
   const serverChild = await ensureServer(PORT);
   const url = `http://localhost:${PORT}`;
   console.error(`Container UI: ${url}`);

package/npm/editor-dev.js

@@ -14,17 +14,48 @@
  *   Rust binary, then forwards args to it.
  *     codeyam-editor-dev editor step 1
  *     codeyam-editor-dev editor advance
+ *
+ * The wrapper is symlinked twice by scripts/bootstrap.sh:
+ *   codeyam-editor-dev → this file (preserves the -dev branding;
+ *     scaffolded content emits "codeyam-editor-dev").
+ *   codeyam-editor     → this file (shadows the canonical name on PATH
+ *     so hooks and skills that emit `codeyam-editor` still get the
+ *     auto-rebuild behavior on local dev; scaffolded content emits the
+ *     canonical "codeyam-editor").
+ * The invocation name is read from `process.argv[1]` to decide which
+ * branding the Rust binary should use via `CODEYAM_CLI`.
  */
 
-const { execSync, spawn } = require("child_process");
+const { execSync, spawn, spawnSync } = require("child_process");
 const path = require("path");
-const fs = require("fs");
-const { ensureServer, restartServer, waitForPort, ensureBinary, uiDistDir, rootDir, killChildProcess } = require("./utils");
+const {
+  ensureServer,
+  restartServer,
+  waitForPort,
+  ensureBinary,
+  isSelfHostTarget,
+  rootDir,
+  killChildProcess,
+  readMergedEditorConfig,
+  resolveLauncherPort,
+  staleBinaryBanner,
+  enforceFreshBinary,
+} = require("./utils");
 const { open } = require("./open");
+const { classifyProject } = require("./preflight-guidance");
+const { isEmptyProjectDir } = require("./empty-project-dir");
 
-// Tell the Rust binary to emit "codeyam-editor-dev" in all instructions,
-// permissions, and installed files instead of "codeyam-editor".
-process.env.CODEYAM_CLI = "codeyam-editor-dev";
+// When invoked through the `codeyam-editor-dev` symlink, tell the Rust
+// binary to emit "codeyam-editor-dev" in all scaffolded commands,
+// permissions, and installed files. When invoked through the
+// `codeyam-editor` symlink, leave CODEYAM_CLI unset so the binary
+// emits the canonical "codeyam-editor" — matching the cloud install
+// path and the new hook/skill convention. The runtime cost of the
+// rebuild-on-passthrough behavior is identical for both names.
+const invokedAs = path.basename(process.argv[1] || "");
+if (invokedAs === "codeyam-editor-dev") {
+  process.env.CODEYAM_CLI = "codeyam-editor-dev";
+}
 
 const args = process.argv.slice(2);
 const KNOWN_SUBCOMMANDS = ["start", "init", "editor"];
@@ -42,78 +73,297 @@ function hasSubcommand(argv = args) {
   return false;
 }
 
-/** Build the Rust binary from the editor repo. */
+/**
+ * Build the Rust binary from the editor repo. Returns true on success,
+ * false if `cargo build` failed. This function only reports the outcome —
+ * the caller decides whether a failed build is fatal (see staleBinaryBanner).
+ */
 function buildBinary() {
   console.error("Building Rust binary...");
   try {
     execSync("cargo build", { stdio: "inherit", cwd: rootDir });
+    return true;
   } catch {
-    console.error("Failed to build Rust binary. Continuing with existing build (if any)...");
+    return false;
   }
 }
 
-module.exports = { hasSubcommand, buildBinary };
+/**
+ * Decide whether the dev wrapper should rebuild the Rust binary (and the UI,
+ * for the launcher path) before forwarding to it. Pure: takes injected cwd /
+ * repoRoot / env so the four-way decision is testable without spawning cargo
+ * or reading process.env.
+ *
+ * The wrapper rebuilds in two cases:
+ *   - The target IS the editor repo itself (developing the editor on its
+ *     own checkout). This is the canonical self-host case.
+ *   - `CODEYAM_DEV_REBUILD=1` is explicitly set (the documented opt-in for
+ *     "editing the editor source while running it against an external client
+ *     project", named in editor-dev.js's earlier history).
+ *
+ * Otherwise — the common case where a developer uses the editor as a tool
+ * against their own app — the wrapper skips the rebuild entirely. The
+ * existing binary runs unchanged, and the server-side stale-binary watcher
+ * (also gated on self-host) never SIGUSR1's. The combined effect is what the
+ * plan calls out: an external-project session is never disrupted by a bare
+ * commit, a fleet rebase, or any other event that would have relinked the
+ * binary without changing what runs.
+ */
+function shouldRebuildOnPassthrough({ cwd, repoRoot, env }) {
+  if (env.CODEYAM_DEV_REBUILD === "1") return true;
+  return isSelfHostTarget(cwd, repoRoot);
+}
+
+/**
+ * Returns true when the merged project config has a non-empty start
+ * command — either at `apps[0].startCommand` (per-app, preferred) or at
+ * the top-level `startCommand` (legacy default). Mirrors the Rust
+ * `resolve_start_command` precedence in
+ * `crates/codeyam-editor/src/commands/start.rs`.
+ *
+ * When neither slot has a non-empty string, the editor server runs in
+ * "editor UI only" mode and the launcher must skip the dev-server port
+ * wait — otherwise the user stares at "Waiting for dev server on port
+ * N..." for the full 15s timeout.
+ */
+function hasStartCommand(mergedConfig) {
+  if (mergedConfig == null || typeof mergedConfig !== "object") return false;
+  const apps = Array.isArray(mergedConfig.apps) ? mergedConfig.apps : null;
+  if (apps && apps.length > 0) {
+    const cmd = apps[0] && apps[0].startCommand;
+    if (typeof cmd === "string" && cmd.trim() !== "") return true;
+  }
+  const topLevel = mergedConfig.startCommand;
+  return typeof topLevel === "string" && topLevel.trim() !== "";
+}
+
+/**
+ * Decide what the launcher should do given a `classifyProject` result.
+ * Pure — no fs, no spawn, no process.exit — so `launcherMain`'s branching
+ * is unit-testable without building a binary or spawning a server (the same
+ * policy/classification split as `classifyPortHolder` in utils.js).
+ *
+ *   modern → { action: "proceed" }                 launch as-is
+ *   none   → { action: "init" }                     greenfield: init, then launch
+ *   legacy → { action: "bail", guidance, code: 2 }  print guidance and exit
+ *
+ * Greenfield auto-inits because the dev launcher is a one-shot "build
+ * everything, run the editor against this project" tool — running it in a
+ * fresh dir should just work. Legacy bails instead: `cmd_init`'s legacy
+ * branch deliberately skips `editor.json` creation so `/codeyam-onboard`
+ * can migrate from the preserved classification, so auto-running init would
+ * strand them. The Rust-side `start_preflight` stays the safety net for
+ * direct `codeyam-editor start` calls; this launcher composes init + start.
+ */
+function planPreflightAction(classification) {
+  if (classification.kind === "legacy") {
+    return { action: "bail", guidance: classification.guidance, code: 2 };
+  }
+  if (classification.kind === "none") {
+    return { action: "init" };
+  }
+  return { action: "proceed" };
+}
+
+/**
+ * Pick the launcher's post-launch tail banner — printed right next to the
+ * `Editor UI: http://…` line where the user is actually looking, after the
+ * editor server is up. Pure (no fs, no spawn) so the three-arm decision is
+ * unit-testable without spawning a binary, mirroring `planPreflightAction`.
+ *
+ * Skill assumption: /codeyam-editor scaffolds a project from scratch;
+ * /codeyam-onboard migrates an existing source tree. Empty greenfield
+ * (no non-hidden entries before init) must route to the scaffold path;
+ * existing greenfield routes to the migration path. Mirrors the same
+ * split in `cmd_init` (init.rs:10-24) — keep both in sync. Do NOT
+ * "simplify" by collapsing the branches; the skill each path names is the
+ * whole point.
+ *
+ *   action !== "init"          → null   (modern: proceed, no banner;
+ *                                         legacy already bailed earlier)
+ *   action "init", wasEmpty    → /codeyam-editor scaffold-from-scratch
+ *   action "init", !wasEmpty   → /codeyam-onboard migrate-existing
+ */
+function postLaunchInitBanner({ preflightAction, wasEmpty }) {
+  if (preflightAction !== "init") return null;
+  if (wasEmpty) {
+    return (
+      "\nInitialized .codeyam/ in this directory. Open Claude Code here and " +
+      "run `/codeyam-editor` to scaffold a new project from scratch."
+    );
+  }
+  return (
+    "\nInitialized .codeyam/ in this directory. To populate scenarios, " +
+    "open Claude Code here and run `/codeyam-onboard`."
+  );
+}
+
+module.exports = {
+  hasSubcommand,
+  buildBinary,
+  shouldRebuildOnPassthrough,
+  staleBinaryBanner,
+  hasStartCommand,
+  planPreflightAction,
+  postLaunchInitBanner,
+};
 
 if (require.main === module) {
   // --- Passthrough mode: build binary, then forward to it ---
   if (hasSubcommand()) {
-    buildBinary();
+    // Only rebuild when the target IS the editor repo itself, or when the
+    // developer has explicitly opted into the "edit editor against external
+    // project" workflow via CODEYAM_DEV_REBUILD=1. On any other project the
+    // editor binary is a fixed tool and a `cargo build` here ripples into a
+    // stale-binary SIGUSR1 re-exec that resets the user's session for no
+    // reason. `ensureBinary()` still builds once if no binary exists at all.
+    if (
+      shouldRebuildOnPassthrough({
+        cwd: process.cwd(),
+        repoRoot: rootDir,
+        env: process.env,
+      })
+    ) {
+      enforceFreshBinary(buildBinary(), { action: "run editor commands" });
+    }
     const binary = ensureBinary();
     const child = spawn(binary, args, {
       stdio: "inherit",
       cwd: process.cwd(),
-      env: { ...process.env, CODEYAM_EDITOR_UI_DIR: uiDistDir() },
+      env: process.env,
     });
     child.on("exit", (code) => {
       process.exit(code ?? 1);
     });
   } else {
     // --- Launcher mode: build everything, start server, open browser ---
-    const SERVER_PORT = 14199;
     const shouldRestart = args.includes("--restart");
 
-    const readProjectPort = () => {
-      try {
-        const configPath = path.join(process.cwd(), ".codeyam", "editor.json");
-        const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-        return config.port || 3000;
-      } catch {
-        return 3000;
-      }
-    };
-
     const launcherMain = async () => {
       const projectDir = process.cwd();
       console.error(`Editor repo: ${rootDir}`);
       console.error(`Target project: ${projectDir}`);
 
-      buildBinary();
+      // Greenfield projects are auto-initialized here so the dev launcher
+      // stays a one-shot "build everything, run the editor against this
+      // project" tool. Legacy projects bail with guidance; modern projects
+      // skip init. See `planPreflightAction` for the rationale on each
+      // branch. Subcommand pass-through (handled above) is unaffected — the
+      // binary classifies its own subcommands.
+      const preflight = planPreflightAction(classifyProject(projectDir));
+      // Capture emptiness BEFORE init runs — the spawn below creates
+      // .codeyam/ (and install_editor_files writes .claude/ etc.), which
+      // would make every project look non-empty by the time the
+      // post-launch banner prints. Same constraint as the Rust comment in
+      // `init_greenfield_branch` (init.rs:82-85). Computed as a sibling
+      // local (not folded into `preflight`) because emptiness is
+      // orthogonal to the preflight kind.
+      const wasEmpty = isEmptyProjectDir(projectDir);
+      if (preflight.action === "bail") {
+        console.error(preflight.guidance);
+        process.exit(preflight.code);
+      }
+      if (preflight.action === "init") {
+        // Run init from projectDir before the config reads below so the
+        // freshly-written .codeyam/editor.json feeds port resolution.
+        // ensureBinary builds the binary first if this is a fresh checkout.
+        console.error(`Initializing codeyam-editor in ${projectDir}...`);
+        const initBinary = ensureBinary();
+        const initResult = spawnSync(initBinary, ["init"], {
+          cwd: projectDir,
+          stdio: "inherit",
+          env: process.env,
+        });
+        if (initResult.status !== 0) {
+          console.error(
+            `codeyam-editor init exited ${initResult.status ?? "by signal"}; aborting launch.`,
+          );
+          process.exit(1);
+        }
+      }
+
+      // Editor server's control port is owned by the editor repo's
+      // merged config (rootDir), not the target project's. The target
+      // project's own `editor.local.json` only contributes to the
+      // app/dev-server port below.
+      const editorMerged = readMergedEditorConfig(rootDir);
+      const SERVER_PORT = resolveLauncherPort(
+        process.env.CODEYAM_EDITOR_PORT,
+        editorMerged.proxy && editorMerged.proxy.controlPort,
+        14199,
+      );
+
+      // Target project's dev-server port comes from its own
+      // editor.json + editor.local.json (developers iterating on the
+      // editor against a real client project rely on the override
+      // file here too).
+      const projectMerged = readMergedEditorConfig(projectDir);
+      const appPort = resolveLauncherPort(undefined, projectMerged.port, 3000);
 
-      // Build the UI from the editor repo
-      console.error("Building UI...");
-      try {
-        execSync("npx vite build", { stdio: "inherit", cwd: path.join(rootDir, "ui") });
-      } catch {
-        console.error("Failed to build UI. Continuing with existing build (if any)...");
+      // Same gate as the passthrough path: only rebuild the Rust binary +
+      // UI when the launcher target IS the editor repo itself, or when
+      // CODEYAM_DEV_REBUILD=1 is explicitly set. Launching the editor
+      // against an external project must not relink the binary — the
+      // server-side stale-binary watcher would otherwise SIGUSR1-restart
+      // the freshly-launched server immediately. `ensureBinary()` still
+      // builds once if no binary exists.
+      const shouldRebuildLaunch = shouldRebuildOnPassthrough({
+        cwd: projectDir,
+        repoRoot: rootDir,
+        env: process.env,
+      });
+      if (shouldRebuildLaunch) {
+        enforceFreshBinary(buildBinary(), {
+          action: "run editor commands",
+          continueVerb: "launching with",
+        });
+
+        // Build the UI from the editor repo
+        console.error("Building UI...");
+        try {
+          execSync("npx vite build", { stdio: "inherit", cwd: path.join(rootDir, "ui") });
+        } catch {
+          console.error("Failed to build UI. Continuing with existing build (if any)...");
+        }
       }
 
       const serverChild = shouldRestart
         ? await restartServer(SERVER_PORT)
         : await ensureServer(SERVER_PORT);
 
-      const appPort = readProjectPort();
-      const viteInternalPort = appPort + 1;
-      console.error(`Waiting for dev server on port ${viteInternalPort}...`);
-      const viteReady = await waitForPort(viteInternalPort, 15000, 300);
-      if (!viteReady) {
-        console.error(`Warning: Dev server not ready on port ${viteInternalPort}. Live Preview may not work initially.`);
+      // Re-read the (possibly just-initialized) project config to decide
+      // whether to wait on a dev server at all. On a project where init
+      // couldn't detect a framework (or a user-configured "editor UI
+      // only" setup), `startCommand` is empty — the editor server itself
+      // prints "No startCommand configured. Running editor UI only." and
+      // never spawns a dev server, so waiting 15s for `appPort + 1` is a
+      // pure UX hang. The launcher silently skips the wait; the server's
+      // own log line is the canonical signal to the user.
+      const postInitMerged = readMergedEditorConfig(projectDir);
+      const hasCommand = hasStartCommand(postInitMerged);
+      if (hasCommand) {
+        const viteInternalPort = appPort + 1;
+        console.error(`Waiting for dev server on port ${viteInternalPort}...`);
+        const viteReady = await waitForPort(viteInternalPort, 15000, 300);
+        if (!viteReady) {
+          console.error(`Warning: Dev server not ready on port ${viteInternalPort}. Live Preview may not work initially.`);
+        }
       }
 
       const url = `http://localhost:${SERVER_PORT}`;
       console.error(`Editor UI: ${url}`);
-      console.error(`Live Preview: http://localhost:${appPort}`);
+      if (hasCommand) {
+        console.error(`Live Preview: http://localhost:${appPort}`);
+      }
       console.error(`Project: ${projectDir}`);
       open(url);
+      const banner = postLaunchInitBanner({
+        preflightAction: preflight.action,
+        wasEmpty,
+      });
+      if (banner) {
+        console.error(banner);
+      }
       const keepAlive = setInterval(() => {}, 60_000);
 
       process.on("SIGINT", () => {

package/npm/editor.js

@@ -16,14 +16,23 @@ const { execSync } = require("child_process");
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
-const { ensureServer, stopServer, isPortInUse, waitForPort, rootDir, killChildProcess } = require("./utils");
+const {
+  ensureServer,
+  stopServer,
+  waitForPort,
+  rootDir,
+  killChildProcess,
+  readMergedEditorConfig,
+  resolveLauncherPort,
+  resolveWrappedAppPort,
+  classifyPortHolder,
+  formatForeignListenerError,
+  formatCrossProjectError,
+  staleBinaryBanner,
+  enforceFreshBinary,
+} = require("./utils");
 const { open } = require("./open");
 
-const SERVER_PORT = parseInt(process.env.CODEYAM_EDITOR_PORT || "14199", 10);
-const VITE_PORT = parseInt(process.env.PORT || "5173", 10);
-// The reverse proxy sits on VITE_PORT; the actual Vite dev server runs on
-// VITE_PORT + 1. We need to wait for the real Vite server, not the proxy.
-const VITE_INTERNAL_PORT = VITE_PORT + 1;
 const shouldRestart = process.argv.includes("--restart");
 
 function buildBinary() {
@@ -32,7 +41,6 @@ function buildBinary() {
     execSync("cargo build", { stdio: "inherit", cwd: rootDir });
     return true;
   } catch {
-    console.error("Failed to build Rust binary. Continuing with existing build (if any)...");
     return false;
   }
 }
@@ -47,6 +55,33 @@ function cargoBinDir() {
   return path.join(os.homedir(), ".cargo", "bin");
 }
 
+// Place a hardlink at `dstPath` pointing at the same inode as `srcPath`,
+// replacing any existing file at `dstPath`. On EXDEV (cross-filesystem,
+// rare; target/ on a separate mount from the cargo bin dir) falls back
+// to an atomic copy-and-rename via `tmpPath` so we still succeed — at
+// the cost of distinct inodes, which means the dev binary's
+// `stale_cargo_bin_message` check will fire on every boot.
+//
+// Hardlink-by-default is what keeps the stale-binary advisory silent on
+// `npm run editor`: the freshly-installed binary at <cargo_bin> shares
+// an inode with target/debug/codeyam-editor, so the inode-identity
+// check returns "same underlying file" and nothing is printed.
+function linkOrCopyBinary(srcPath, dstPath, tmpPath) {
+  try {
+    fs.unlinkSync(dstPath);
+  } catch (e) {
+    if (e.code !== "ENOENT") throw e;
+  }
+  try {
+    fs.linkSync(srcPath, dstPath);
+  } catch (err) {
+    if (err.code !== "EXDEV") throw err;
+    fs.copyFileSync(srcPath, tmpPath);
+    fs.chmodSync(tmpPath, 0o755);
+    fs.renameSync(tmpPath, dstPath);
+  }
+}
+
 // Install target/debug/codeyam-editor to <cargo_bin>/codeyam-editor
 // atomically (write to tmp in same dir, then rename), and refresh the
 // codeyam-editor-pty-broker hardlink so it points at the new inode.
@@ -71,9 +106,7 @@ function installBinary() {
   console.error(`Installing fresh binary to ${dstPath}...`);
   try {
     fs.mkdirSync(binDir, { recursive: true });
-    fs.copyFileSync(srcPath, tmpPath);
-    fs.chmodSync(tmpPath, 0o755);
-    fs.renameSync(tmpPath, dstPath);
+    linkOrCopyBinary(srcPath, dstPath, tmpPath);
     try {
       fs.unlinkSync(linkPath);
     } catch (e) {
@@ -98,32 +131,44 @@ function sweepStaleArtifacts() {
   }
 }
 
+/**
+ * npm wrapper entry point for the editor binary: resolves ports from
+ * the merged editor config, ensures the Rust backend is running, and
+ * opens the editor UI.
+ */
 async function main() {
-  // Sync ports to editor.json so the Rust backend uses them
-  const editorJsonPath = path.join(rootDir, ".codeyam", "editor.json");
-  if (fs.existsSync(editorJsonPath)) {
-    const editorJson = JSON.parse(fs.readFileSync(editorJsonPath, "utf8"));
-    editorJson.port = VITE_PORT;
-    editorJson.startCommand = `cd ui && npx vite --port ${VITE_PORT}`;
-    
-    const uiApp = editorJson.apps?.find(a => a.dir === "ui");
-    if (uiApp) {
-      uiApp.port = VITE_PORT;
-      uiApp.startCommand = `npx vite --port ${VITE_PORT}`;
-    }
-    
-    if (editorJson.proxy) {
-      editorJson.proxy.controlPort = SERVER_PORT;
-      editorJson.proxy.httpPort = SERVER_PORT - 99;
-      editorJson.proxy.dbPort = SERVER_PORT - 98;
-    }
-    fs.writeFileSync(editorJsonPath, JSON.stringify(editorJson, null, 2));
-  }
+  // Read ports from the merged editor config (editor.json + per-developer
+  // editor.local.json). The Rust backend reads the same merged config on
+  // its own — we resolve here so the launcher's log lines, `waitForPort`
+  // calls, and `--port` arg agree with what the binary will actually
+  // bind. Env vars still win for scripted/CI invocations
+  // (CODEYAM_EDITOR_PORT, PORT), then the merged config, then a hard
+  // fallback for fresh checkouts with no override file.
+  const merged = readMergedEditorConfig(rootDir);
+  const SERVER_PORT = resolveLauncherPort(
+    process.env.CODEYAM_EDITOR_PORT,
+    merged.proxy && merged.proxy.controlPort,
+    14199,
+  );
+  // `resolveWrappedAppPort` mirrors `resolve_app_port` in
+  // `crates/codeyam-editor/src/commands/start.rs`: `env > apps[0].port >
+  // config.port`. Without this the launcher's log line and
+  // `waitForPort` probe targeted one port while the backend bound
+  // another, producing the misleading "Vite dev server not ready on
+  // port N" warning whenever apps[0] declared its own port.
+  const VITE_PORT = resolveWrappedAppPort(merged, process.env.PORT, 5173);
+  // The reverse proxy sits on VITE_PORT; the actual Vite dev server runs on
+  // VITE_PORT + 1. We need to wait for the real Vite server, not the proxy.
+  const VITE_INTERNAL_PORT = VITE_PORT + 1;
 
   // Rebuild the Rust binary so code changes are picked up on restart.
   // This script is only invoked from a source checkout (via `npm run editor`),
   // so Cargo.toml and the crates tree are always present.
   const buildOk = buildBinary();
+  // A failed rebuild means the server would boot on a stale binary that no
+  // longer matches the source. Refuse by default; CODEYAM_ALLOW_STALE=1
+  // forces the old behavior (continue with the last-good install).
+  enforceFreshBinary(buildOk, { action: "start the editor server" });
   // Refresh <cargo_bin>/codeyam-editor (and the pty-broker hardlink) so
   // the broker auto-spawn execs a binary that knows the `pty-broker
   // daemon` subcommand. Skip if the build failed — installing a stale
@@ -145,11 +190,27 @@ async function main() {
 
   // Start the Rust backend — it serves ui/dist/ and launches the Vite dev
   // server (configured via startCommand in editor.json) for Live Preview HMR.
-  // On --restart: stop the existing server first, sweep stale artifacts while
-  // target/ is idle (no process holding files open), then start fresh.
-  if (shouldRestart && (await isPortInUse(SERVER_PORT))) {
-    console.error(`Stopping existing server on port ${SERVER_PORT}...`);
-    await stopServer(SERVER_PORT);
+  // On --restart: identity-check first, then stop the existing server,
+  // sweep stale artifacts while target/ is idle, then start fresh.
+  //
+  // Stopping someone else's editor server on `--restart` is the worst
+  // possible outcome of a port collision — only stop the listener if
+  // the identity probe confirms it's this project's server.
+  if (shouldRestart) {
+    const holder = await classifyPortHolder(SERVER_PORT);
+    if (holder.kind === "foreign") {
+      console.error(formatForeignListenerError(SERVER_PORT));
+      process.exit(1);
+    }
+    if (holder.kind === "cross-project") {
+      console.error(formatCrossProjectError(SERVER_PORT, holder, "restart"));
+      process.exit(1);
+    }
+    if (holder.kind === "same-project") {
+      console.error(`Stopping existing server on port ${SERVER_PORT}...`);
+      await stopServer(SERVER_PORT);
+    }
+    // holder.kind === "free": nothing to stop, fall through to ensureServer.
   }
   if (shouldRestart) {
     sweepStaleArtifacts();
@@ -180,8 +241,10 @@ async function main() {
 
 module.exports = {
   buildBinary,
+  staleBinaryBanner,
   cargoBinDir,
   installBinary,
+  linkOrCopyBinary,
   main,
   sweepStaleArtifacts,
 };

package/npm/empty-project-dir.js

@@ -0,0 +1,33 @@
+"use strict";
+
+/**
+ * Launcher-side mirror of `is_empty_project_dir` in
+ * `crates/codeyam-editor/src/commands/init.rs`. The Rust side decides
+ * which `/codeyam-…` skill the init binary points at; this JS mirror
+ * decides the same for the launcher's post-launch tail banner. Keep
+ * both in sync — the test `empty-project-dir.test.js` and Rust's
+ * `is_empty_project_dir_ignores_hidden_entries` /
+ * `is_empty_project_dir_detects_visible_entry` pin the contract.
+ *
+ * A "fresh" project directory has no non-hidden entries — only things
+ * like `.git/`, `.gitignore`, or other dotfiles. Hidden entries don't
+ * count as project content, so a dir holding only `.git/` and
+ * `.gitignore` (the "I just ran `git init`" case) still reads as empty.
+ * A read error returns false, matching the Rust `Err(_) => false` branch:
+ * a missing / unreadable dir defaults to the existing-project path rather
+ * than falsely scaffolding over nothing.
+ */
+
+const fs = require("node:fs");
+
+function isEmptyProjectDir(projectDir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(projectDir);
+  } catch {
+    return false;
+  }
+  return entries.every((name) => name.startsWith("."));
+}
+
+module.exports = { isEmptyProjectDir };