cocosuperintelligence 1.7.0 → 1.7.2

package/README.md

@@ -9,8 +9,8 @@
 
 [![CI](https://img.shields.io/github/actions/workflow/status/coco-research/coco/ci.yml?branch=main&style=flat-square&label=CI)](https://github.com/coco-research/coco/actions/workflows/ci.yml)
 [![Release](https://img.shields.io/github/v/release/coco-research/coco?style=flat-square&color=1234FF)](https://github.com/coco-research/coco/releases)
-[![Skills](https://img.shields.io/badge/skills-228?style=flat-square&color=5F5F58&labelColor=0B0B0B)](skills/)
-[![Commands](https://img.shields.io/badge/commands-387?style=flat-square&color=5F5F58&labelColor=0B0B0B)](commands/)
+[![Skills](https://img.shields.io/badge/skills-228-5F5F58?style=flat-square&labelColor=0B0B0B)](skills/)
+[![Commands](https://img.shields.io/badge/commands-387-5F5F58?style=flat-square&labelColor=0B0B0B)](commands/)
 [![Personas](https://img.shields.io/badge/personas-495-5F5F58?style=flat-square&color=5F5F58&labelColor=0B0B0B)](systems/superintelligence/)
 
 Open-core: the core is [MIT](LICENSE), and Super Intelligence is [proprietary](systems/superintelligence/LICENSE). Files stay on your machine. No telemetry. A version check may contact GitHub once a day.
@@ -38,7 +38,7 @@ An illustration built from a real `/SI-Decide` run (Claude Sonnet 5.5, 30 Septem
 
 Prerequisites: git, bash, Node.js 14 or newer (for `npx`), and python3 (it generates the `/SI-*` commands).
 
-`npx cocosuperintelligence` installs the latest release. It clones the pinned release tag (currently `v1.7.0`, not floating `main`) into `./coco` of the current directory, then runs `install.sh`. Run it from your home folder, so the clone is `~/coco` and not a folder inside another project. On a fresh machine it took about 3 minutes, including the download. <!-- x-release-please-version -->
+`npx cocosuperintelligence` installs the latest release. It clones the pinned release tag (currently `v1.7.2`, not floating `main`) into `./coco` of the current directory, then runs `install.sh`. Run it from your home folder, so the clone is `~/coco` and not a folder inside another project. On a fresh machine it took about 3 minutes, including the download. <!-- x-release-please-version -->
 
 ```bash
 npx cocosuperintelligence
@@ -78,26 +78,20 @@ You type a question. The orchestrator scores 495 personas across 13 departments
 
 How the router scores teams: [`systems/superintelligence/README.md`](systems/superintelligence/README.md). What each editor actually receives: [`adapters/INDEX.md`](adapters/INDEX.md).
 
-## Status and roadmap
+## Status
 
-Released: v1.5.0 on npm. Today `npx` installs v1.5.0. That tag already contains the 13 Super Intelligence team skill files, but its installer does not install them as front doors. That fix, and several other installer fixes, are on main.
+Released on npm: `npx cocosuperintelligence` installs the latest release ([CHANGELOG](CHANGELOG.md)).
 
-The measured 190 skills / 387 commands / 34 agents ([`docs/delivered-counts.json`](docs/delivered-counts.json)) apply to main.
+Measured on main, a default Claude Code install delivers 190 of the 228 skills (the rest are the opt-in security pack and Cursor-only skills), 387 commands and 34 agents ([`docs/delivered-counts.json`](docs/delivered-counts.json)).
 
 Known gap: most GSD skills need the upstream GSD toolkit at `~/.claude/get-shit-done` (see [`systems/gsd/README.md`](systems/gsd/README.md)).
 
-Next three milestones:
-
-1. v1.6.0, so `npx` installs what main already has.
-2. Bundle the GSD runtime, so those skills work without a separate toolkit.
-3. Installer safety: an uninstall guard, and a clearer clone location.
-
 <details>
 <summary><strong>Other install paths, updates, uninstall</strong></summary>
 
 From a checkout you already have, `bash install.sh` auto-detects the editor. Narrow it with `--adapter cursor` or `--systems gsd,brain`. `--core-only` skips bundles. `reverse-skill` stays opt-in: `--systems reverse-skill`.
 
-The remote bootstrap clones the pinned release tag (currently `v1.5.0`, not floating `main`) to `~/.coco`, prints the commit, and waits for you to type `y` before it runs `install.sh`:
+The remote bootstrap clones the same pinned release tag as `npx` (not floating `main`) to `~/.coco`, prints the commit, and waits for you to type `y` before it runs `install.sh`:
 
 ```bash
 bash <(curl -fsSL https://raw.githubusercontent.com/coco-research/coco/main/bin/coco-bootstrap.sh)
@@ -201,8 +195,6 @@ Six bundles install by default. `--core-only` skips them. `--systems <list>` ins
 
 A default Claude Code install delivers **190 skills, 387 commands and 34 agents**, measured by running the installer. The repository holds 228 skills; the difference is the opt-in security pack and Cursor-only skills. The measured row is main.
 
-The v1.5.0 release `npx` installs today is older. See [Status and roadmap](#status-and-roadmap).
-
 <table align="center">
 <tr>
 <td align="center" width="20%"><h3>228</h3><sub>Skills</sub><br><small>76 Core + 152 Bundle · 190 install by default</small></td>
@@ -220,7 +212,7 @@ The v1.5.0 release `npx` installs today is older. See [Status and roadmap](#stat
 </div>
 
 <table>
-<tr><td><strong>Spec Version</strong></td><td>1.5.0</td></tr>
+<tr><td><strong>Spec Version</strong></td><td><a href="https://github.com/coco-research/coco/releases/latest">latest release</a></td></tr>
 <tr><td><strong>License</strong></td><td>Open-core — <a href="LICENSE">MIT</a> core; Super Intelligence is <a href="systems/superintelligence/LICENSE">proprietary</a></td></tr>
 <tr><td><strong>Total Skills</strong></td><td>228 in the repository (76 Core + 152 Bundle); 190 install by default on Claude Code</td></tr>
 <tr><td><strong>Slash Commands</strong></td><td>387 on a default install — 45 Core (shipped) + 342 Super Intelligence (325 per-team + 17 cross-team, generated at install)</td></tr>

package/bin/coco-bootstrap.sh

@@ -25,7 +25,7 @@ set -euo pipefail
 
 REPO_URL="https://github.com/coco-research/coco.git"
 # Keep in sync with package.json version. Clone the last tagged release, not floating main.
-PINNED_TAG="v1.7.0" # x-release-please-version
+PINNED_TAG="v1.7.2" # x-release-please-version
 INSTALL_DIR="${COCO_DIR:-$HOME/.coco}"
 YES="${COCO_BOOTSTRAP_YES:-}"
 PASS_THROUGH=()

package/bin/coco.js

@@ -131,30 +131,142 @@ function which(cmd) {
 }
 
 function run(cmd, args, opts = {}) {
-  const r = spawnSync(cmd, args, { stdio: 'inherit', ...opts });
+  // git ignores cwd/-C when GIT_DIR is set. Git calls get gitEnv(); SSH and proxies stay.
+  const r = spawnSync(cmd, args, { stdio: 'inherit', ...opts, ...(cmd === 'git' ? { env: gitEnv() } : {}) });
   if (r.status !== 0) {
     process.exit(r.status || 1);
   }
 }
 
+// Any common spelling of github.com/coco-research/coco: https/ssh/git URLs with optional
+// user[:token]@ and :port, or scp form with or without user@. GitHub names are case-insensitive.
+const ORIGIN_RE = /^(?:(?:https?|ssh|git):\/\/(?:[^@\/]+@)?github\.com(?::\d+)?\/|(?:[^@\/:]+@)?github\.com:)coco-research\/coco(?:\.git)?\/?$/i;
+
+// Hooks and scripts export GIT_DIR. git -C does not override it: config and
+// remote get-url then read that repo, while show-toplevel still prints -C.
+// Drop only vars that redirect which repo or config git uses. Keep
+// GIT_SSH_COMMAND, GIT_SSH, GIT_ASKPASS, GIT_TERMINAL_PROMPT, and proxies.
+const GIT_REDIRECT = new Set([
+  'GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR', 'GIT_INDEX_FILE',
+  'GIT_OBJECT_DIRECTORY', 'GIT_ALTERNATE_OBJECT_DIRECTORIES', 'GIT_NAMESPACE',
+  'GIT_CEILING_DIRECTORIES', 'GIT_DISCOVERY_ACROSS_FILESYSTEM', 'GIT_CONFIG',
+  'GIT_CONFIG_GLOBAL', 'GIT_CONFIG_SYSTEM', 'GIT_CONFIG_NOSYSTEM',
+  'GIT_CONFIG_PARAMETERS', 'GIT_CONFIG_COUNT',
+]);
+
+function gitEnv() {
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    if (GIT_REDIRECT.has(key) || /^GIT_CONFIG_(?:KEY|VALUE)_\d+$/.test(key)) delete env[key];
+  }
+  return env;
+}
+
+function gitIn(dir, args) {
+  // 1 MiB default maxBuffer raises ENOBUFS on a large status and must not look clean.
+  return spawnSync('git', ['-C', dir, ...args], {
+    encoding: 'utf8', env: gitEnv(), maxBuffer: 64 * 1024 * 1024,
+  });
+}
+
+function sameReal(a, b) {
+  try { return fs.realpathSync(a) === fs.realpathSync(b); } catch (_) { return false; }
+}
+
+function isEmptyDir(dir) {
+  try { return fs.statSync(dir).isDirectory() && fs.readdirSync(dir).length === 0; } catch (_) { return false; }
+}
+
+// Null when dir is a coco-research/coco clone. Git missing or an unreadable origin fails closed.
+function cloneRejection(dir) {
+  if (!fs.existsSync(dir)) return 'it does not exist';
+  let name = null;
+  try { name = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')).name; } catch (_) { name = null; }
+  if (name !== 'cocosuperintelligence') return 'package.json name is not "cocosuperintelligence"';
+  let gitSt = null;
+  try { gitSt = fs.statSync(path.join(dir, '.git')); } catch (_) { gitSt = null; }
+  if (!gitSt || (!gitSt.isDirectory() && !gitSt.isFile())) return 'it has no .git directory or file';
+  const top = gitIn(dir, ['rev-parse', '--show-toplevel']);
+  if (top.error && top.error.code === 'ENOENT') return 'its origin could not be verified; remove the directory by hand';
+  // A .git file of `gitdir: <other>/.git` still reports this directory as toplevel.
+  // Accept only this dir's own .git, or a linked worktree whose gitdir file points back here.
+  const gitDirR = gitIn(dir, ['rev-parse', '--absolute-git-dir']);
+  const gitDir = String(gitDirR.stdout || '').trim();
+  let owns = gitDirR.status === 0 && sameReal(gitDir, path.join(dir, '.git'));
+  if (!owns && gitDir) {
+    try {
+      const back = fs.readFileSync(path.join(gitDir, 'gitdir'), 'utf8').trim();
+      owns = sameReal(path.resolve(gitDir, back), path.join(dir, '.git'));
+    } catch (_) { owns = false; }
+  }
+  if (top.status !== 0 || !sameReal(String(top.stdout || '').trim(), dir) || !owns) {
+    return 'its git toplevel is not this directory';
+  }
+  // Raw stored value. `remote get-url` applies insteadOf, so an alias can look official.
+  const remote = gitIn(dir, ['config', '--local', '--get', 'remote.origin.url']);
+  if ((remote.error && remote.error.code === 'ENOENT') || remote.status !== 0) {
+    return 'its origin could not be verified; remove the directory by hand';
+  }
+  if (!ORIGIN_RE.test(String(remote.stdout || '').trim())) {
+    return 'its origin must be stored as a github.com/coco-research/coco URL';
+  }
+  return null;
+}
+
+// Names of local work, or null when a check errored or exited non-zero (fail closed).
+// untracked=false for update: ~/.coco holds untracked Coco state (knowledge/, sessions/, m0-token)
+// that a plain checkout keeps.
+function localWork(dir, untracked = true) {
+  const gitOut = (args) => {
+    const r = gitIn(dir, args);
+    if (r.error || r.status !== 0) return null;
+    return String(r.stdout || '').trim();
+  };
+  // CLI cache and the Codex adapter's generated si-commands/ are not local work.
+  const status = gitOut(['status', '--porcelain', `--untracked-files=${untracked ? 'all' : 'no'}`, '--', '.', ':(exclude).update-check.json', ':(exclude)si-commands']);
+  const stash = gitOut(['stash', 'list']);
+  // HEAD: the install is detached at the pin, so a commit there is on no branch.
+  // Release tags only: the pinned tag is not local work, but a local `git tag wip` is.
+  const ahead = gitOut(['rev-list', 'HEAD', '--branches', '--not', '--remotes', '--tags=v[0-9]*']);
+  if (status === null || stash === null || ahead === null) return null;
+  const found = [];
+  if (status) found.push('uncommitted changes');
+  if (stash) found.push('a stash');
+  if (ahead) found.push('unpushed commits');
+  return found;
+}
+
+function refuseClone(dir, why) {
+  console.error(`Not removing ${dir}: ${why}. Nothing was deleted.`);
+  process.exit(2);
+}
+
 function cloneOrUpdate(dir) {
-  if (fs.existsSync(dir) && fs.existsSync(path.join(dir, '.git'))) {
+  const empty = isEmptyDir(dir);
+  if (fs.existsSync(dir) && !empty) {
+    const why = cloneRejection(dir);
+    if (why) refuseClone(dir, why);
+  }
+  if (!empty && fs.existsSync(dir) && fs.existsSync(path.join(dir, '.git'))) {
     // Detached HEAD is the tagged install. A branch checkout (typical `git clone` of
     // main) must not be force-moved onto an older pin.
-    const head = spawnSync('git', ['symbolic-ref', '-q', 'HEAD'], { cwd: dir });
+    const head = spawnSync('git', ['symbolic-ref', '-q', 'HEAD'], { cwd: dir, env: gitEnv() });
     if (head.status !== 0) {
+      // The checkout below would strand local commits on the pinned install. Untracked state is
+      // fine: without --force, git refuses to overwrite an untracked file and nothing is lost.
+      const found = localWork(dir, false);
+      if (found == null || found.length) {
+        console.error(`Not updating ${dir}: ${found == null ? 'the local-work check could not run' : `it has ${found.join(' and ')}`}. Move that work elsewhere or remove the clone. Nothing was changed.`);
+        process.exit(2);
+      }
       console.log(`Coco already at ${dir} (detached). Updating to ${PINNED_TAG}...`);
       run('git', ['fetch', '--tags', '--force', '--depth', '1', 'origin', `refs/tags/${PINNED_TAG}:refs/tags/${PINNED_TAG}`], { cwd: dir });
-      run('git', ['checkout', '--force', PINNED_TAG], { cwd: dir });
+      run('git', ['checkout', PINNED_TAG], { cwd: dir });
     } else {
       console.log(`Coco already at ${dir}. Pulling latest...`);
       run('git', ['pull', '--ff-only'], { cwd: dir });
     }
   } else {
-    if (fs.existsSync(dir)) {
-      console.error(`Error: ${dir} exists but is not a git repo. Move it or pick a different location.`);
-      process.exit(1);
-    }
     console.log(`Cloning Coco ${PINNED_TAG} to ${dir}...`);
     run('git', ['clone', '--branch', PINNED_TAG, '--depth', '1', REPO, dir]);
   }
@@ -188,7 +300,7 @@ function cmdInstall(argv) {
 
 function cmdUpdate(argv) {
   const dir = argv[0] && !argv[0].startsWith('--') ? argv[0] : DEFAULT_DIR;
-  if (!fs.existsSync(path.join(dir, '.git'))) {
+  if (!isEmptyDir(dir) && !fs.existsSync(path.join(dir, '.git'))) {
     console.error(`Error: ${dir} is not a Coco clone. Run \`npx cocosuperintelligence install\` first.`);
     process.exit(1);
   }
@@ -197,10 +309,28 @@ function cmdUpdate(argv) {
 }
 
 function cmdUninstall(argv) {
-  const dir = path.resolve(argv[0] && !argv[0].startsWith('--') ? argv[0] : DEFAULT_DIR);
-  // Prefix match on the resolved clone path plus a trailing slash, so a clone
-  // named `coco` cannot also delete links into `coco-research` / `coco-connect`.
-  const prefix = dir.endsWith(path.sep) ? dir : dir + path.sep;
+  const force = argv.includes('--force');
+  const dirArg = argv.find((a) => !a.startsWith('--'));
+  const dir = path.resolve(dirArg || DEFAULT_DIR);
+  if (fs.existsSync(dir)) {
+    const why = cloneRejection(dir);
+    // Empty: no data to lose. tests/check-cli-uninstall-cleanup.sh uninstalls an empty dir.
+    let entries = 1;  // not a readable directory (a file, no permission): refuse, never crash
+    try { entries = fs.readdirSync(dir).length; } catch (_) {}
+    if (why && entries) refuseClone(dir, why);
+    if (!why && !force) {
+      const found = localWork(dir);
+      if (found == null) refuseClone(dir, 'the local-work check could not run; pass --force to remove it');
+      if (found.length) refuseClone(dir, `it has ${found.join(' and ')}; pass --force to remove it`);
+    }
+  }
+  // Prefix match plus a trailing slash, so a clone named `coco` cannot also delete links
+  // into `coco-research` / `coco-connect`. install.sh links through whichever path it ran
+  // from, so match both the path given and its real path (a symlinked clone dir).
+  let real = dir;
+  try { real = fs.realpathSync(dir); } catch (_) { /* absent: only the given path */ }
+  const match = [...new Set([dir, real])]
+    .flatMap((d, i) => [...(i ? ['-o'] : []), '-lname', `${d.endsWith(path.sep) ? d : d + path.sep}*`]);
   console.log(`Removing symlinks pointing into ${dir}...`);
   const homes = [
     path.join(os.homedir(), '.claude'),
@@ -210,11 +340,29 @@ function cmdUninstall(argv) {
   ];
   for (const home of homes) {
     if (!fs.existsSync(home)) continue;
-    run('find', [home, '-type', 'l', '-lname', `${prefix}*`, '-delete']);
+    // -H: a symlinked ~/.claude (dotfiles) is still searched.
+    run('find', ['-H', home, '-type', 'l', '(', ...match, ')', '-delete']);
   }
-  console.log(`Removing clone at ${dir}...`);
-  if (fs.existsSync(dir)) {
-    fs.rmSync(dir, { recursive: true, force: true });
+  // grok also writes generated files (SI commands, config block, hooks); its installer removes them.
+  // Best-effort: an older pinned clone may not know --uninstall; never abort the uninstall over it.
+  const grokInstaller = path.join(dir, 'adapters', 'grok', 'install.sh');
+  if (fs.existsSync(path.join(os.homedir(), '.grok')) && fs.existsSync(grokInstaller)) {
+    const r = spawnSync('bash', [grokInstaller, '--uninstall'], { stdio: 'inherit' });
+    if (r.status !== 0) {
+      console.log('Note: grok installer cleanup failed (possibly an older pin without --uninstall); continuing.');
+    }
+  }
+  let isLink = false;
+  try { isLink = fs.lstatSync(dir).isSymbolicLink(); } catch (_) { /* absent */ }
+  if (isLink) {
+    // A symlinked clone dir may point at a checkout the user keeps elsewhere: drop only the link.
+    fs.rmSync(dir, { force: true });
+    console.log(`Removed the link ${dir}; kept the clone it points to at ${real}. Delete that by hand if you want it gone.`);
+  } else {
+    console.log(`Removing clone at ${dir}...`);
+    if (fs.existsSync(dir)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
   }
   // The update notifier's cache is ours; drop it, and ~/.coco if that leaves it empty.
   fs.rmSync(UPDATE_CACHE, { force: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cocosuperintelligence",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "CoCo Super Intelligence — summon an advisory board of 495 world-class minds inside your AI coding session. A vendor-neutral orchestration layer for Claude Code, Cursor, and Codex: 228 skills (190 installed by default), 387 commands, 34 agents, and disk-persistent state. 100% local, no telemetry. Open-core: MIT core, proprietary Super Intelligence.",
   "bin": {
     "coco": "bin/coco.js"