great-cto 3.8.0 → 3.9.0

package/board/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "great_cto",
   "id": "great_cto",
   "description": "Engineering process for solo founders and teams up to 50 engineers. Agents do architecture, code review, QA, and security. You make two decisions per feature.",
-  "version": "3.8.0",
+  "version": "3.9.0",
   "author": {
     "name": "Great CTO",
     "url": "https://github.com/avelikiy/great_cto"

package/board/packages/board/lib/projects.mjs

@@ -416,6 +416,31 @@ function resolveProjectInfo(slugOrPath) {
   const matches = reg.projects.filter(p => p.slug === slugOrPath);
   const found = pickBestBySlug(matches);
   if (found) return { cwd: found.path, resolved: 'slug' };
+
+  // The identifier the board SHOWS and the identifier it RESOLVES were two
+  // different things.
+  //
+  // `listProjects()` derives a display slug at :184 —
+  // `project` / `name` / basename(dir) — while resolution matched only
+  // `p.slug` as stored in the registry. A project listed as `<private-project>`
+  // (basename of its directory) had a different slug on disk, so asking for the
+  // name the UI itself printed resolved to nothing and fell back to the server's
+  // own project: one project's session logs served under another's name. The
+  // fallback header said so, which is why this was a wrong answer rather than a
+  // silent one — but a caller that asks by the name it was given should not have
+  // to read a header to learn it was ignored.
+  //
+  // So the derived identifier is accepted too, and only after the stored one
+  // fails. Basename matching is last because it is the weakest claim: two
+  // directories can share a name, and pickBestBySlug already knows how to
+  // choose between candidates.
+  const byDerived = reg.projects.filter((p) => {
+    if (!p?.path) return false;
+    return path.basename(p.path) === slugOrPath;
+  });
+  const derived = pickBestBySlug(byDerived);
+  if (derived) return { cwd: derived.path, resolved: 'slug' };
+
   return { cwd: process.cwd(), resolved: 'fallback', requested: slugOrPath };
 }
 

package/dist/installer.js

@@ -1,9 +1,11 @@
 // Install the great_cto plugin into ~/.claude/plugins/cache/local/great_cto/<version>/.
 // Uses git clone. Falls back to tarball fetch if git is unavailable.
 import { spawnSync, execFileSync } from "node:child_process";
+import { cpSync } from "node:fs";
 import { existsSync, mkdirSync, rmSync, readFileSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { log, success, warn, dim } from "./ui.js";
 const REPO_URL = "https://github.com/avelikiy/great_cto.git";
 export function hasGit() {
@@ -113,14 +115,81 @@ export function install(opts = {}) {
             throw new Error(`git clone failed: ${stderr}`);
         }
     }
-    // Sanity check: did we get a plugin?
-    const manifest = join(pluginDir, ".claude-plugin", "plugin.json");
-    if (!existsSync(manifest)) {
-        throw new Error(`Install appeared to succeed but ${manifest} is missing. Repo layout may have changed.`);
+    // A clone carries sources; the plugin runs on the build. Supply it from this
+    // CLI's own dist before checking whether the result can run.
+    const supplied = supplyBuiltDist(pluginDir);
+    if (supplied != null)
+        log(dim(`  supplied ${supplied} built file(s) into packages/cli/dist/`));
+    // Sanity check: can it RUN, not merely "did files arrive".
+    const missing = missingRuntimeParts(pluginDir);
+    if (missing.length) {
+        throw new Error(`Install appeared to succeed but the plugin cannot run — missing:\n` +
+            missing.map((m) => `  - ${m}`).join("\n") +
+            `\nThis is an install bug, not a configuration problem. Please report it with this list.`);
     }
     success(`plugin installed at ${pluginDir}`);
     return { installed: true, pluginDir, version, alreadyInstalled: false };
 }
+/**
+ * The plugin needs BUILT JavaScript, and a git clone does not contain any.
+ *
+ * `packages/cli/dist/` is a build artefact. Five of its thirty-two files are in
+ * git by accident; the rest, including `archetypes.js`, are not. So a cloned
+ * plugin gets 5 of 32, and `scripts/lib/gate-plan.mjs` — which the board's
+ * project reader imports — dies on
+ *
+ *     ERR_MODULE_NOT_FOUND … packages/cli/dist/archetypes.js
+ *
+ * The board therefore did not start for anyone installing this the documented
+ * way. It started for the author, whose plugin cache is populated by
+ * `install-local.sh` from a working tree with a full local build, and it started
+ * from the npm tarball, which ships all 32. It failed on exactly one path: the
+ * one a new user takes.
+ *
+ * The build is not fetched or rebuilt — it is already here. This CLI IS the
+ * published package, so the version being installed and the version doing the
+ * installing are the same artefacts. Copying them across is both the cheapest
+ * source and the only one that cannot drift.
+ *
+ * @returns how many files were supplied, or null when this CLI has no dist of
+ *   its own to give (running from source in the monorepo, where the clone is
+ *   not what gets used anyway).
+ */
+function supplyBuiltDist(pluginDir) {
+    const here = dirname(fileURLToPath(import.meta.url)); // …/dist
+    const target = join(pluginDir, "packages", "cli", "dist");
+    try {
+        if (!existsSync(join(here, "archetypes.js")))
+            return null;
+        mkdirSync(target, { recursive: true });
+        cpSync(here, target, { recursive: true });
+        return readdirSync(target).length;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Can the plugin actually run, or did we merely receive files?
+ *
+ * The check this replaces asked whether `.claude-plugin/plugin.json` exists —
+ * "did we get a plugin?" — which a clone always satisfies while the board is
+ * still unable to start. A sanity check that a broken install passes is not a
+ * sanity check.
+ *
+ * @returns a list of what is missing; empty means runnable.
+ */
+export function missingRuntimeParts(pluginDir) {
+    const required = [
+        [".claude-plugin/plugin.json", "the plugin manifest"],
+        ["packages/board/server.mjs", "the board server"],
+        ["packages/cli/dist/archetypes.js", "the built archetype table the board imports"],
+        ["scripts/lib/gate-plan.mjs", "the gate planner"],
+    ];
+    return required
+        .filter(([rel]) => !existsSync(join(pluginDir, rel)))
+        .map(([rel, what]) => `${rel} (${what})`);
+}
 function readPluginVersion(pluginDir) {
     try {
         const manifest = join(pluginDir, ".claude-plugin", "plugin.json");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "great-cto",
-  "version": "3.8.0",
+  "version": "3.9.0",
   "description": "One command install for the great_cto Claude Code plugin. Auto-detects your stack, picks the right archetype, bootstraps PROJECT.md.",
   "keywords": [
     "claude-code",