@lifeaitools/clauth 2.1.1 → 2.10.0

package/cli/index.js

@@ -153,7 +153,6 @@ import { runServe, MCP_TOOLS } from './commands/serve.js';
 import { deregisterPlugin, listPlugins, registerPlugin, syncPluginsFromRepos, SYNC_REPO_NAMES, SYNC_SKIP_STATES } from './supervisor-registry.js';
 import { runOps } from './commands/ops.js';
 import { runOpsInstall } from './commands/ops-install.js';
-import { runCodevelop } from './commands/codevelop.js';
 import { runNpm, runPublish } from './commands/npm.js';
 import { runLogin } from './commands/login.js';
 
@@ -216,44 +215,6 @@ program
     await runUninstall(opts);
   });
 
-program
-  .command("codevelop")
-  .description("Install and launch Claude/Codex co-development terminal sessions")
-  .argument("[action]", "install-terminal | start | join | say | read | watch | who | ask | reply | inbox | listen | request-partner | launch-peer | check-partner | sync | help", "help")
-  .option("--repo <path>", "Repo root", "C:\\Dev\\regen-root")
-  .option("--port <port>", "Isolated clauth port", "53137")
-  .option("--base-url <url>", "Override clauth base URL")
-  .option("--name <name>", "Session name")
-  .option("--session <idOrManifestPath>", "Co-develop session id or manifest path")
-  .option("--task <task>", "Initial partner request task")
-  .option("--context <path>", "Context, plan, or architecture file the partner should read first")
-  .option("--channel <name>", "Ad hoc channel name for join/say/read/watch")
-  .option("--message <text>", "Ad hoc message for say")
-  .option("--to <peer>", "Target peer for ask/reply, or optional direct ad hoc recipient for say")
-  .option("--from <peer>", "Sender peer for ask/reply")
-  .option("--turn <turn_id>", "Turn ID for reply")
-  .option("--role <role>", "Turn role, e.g. reviewer or builder")
-  .option("--skill <skill>", "Requested skill name, e.g. rdc:review")
-  .option("--verdict <verdict>", "Reply verdict: pass, fail, or blocked")
-  .option("--summary <summary>", "Reply summary")
-  .option("--evidence <items>", "Reply evidence; separate multiple items with semicolons")
-  .option("--files-changed <items>", "Reply changed files; separate multiple items with semicolons")
-  .option("--commits <items>", "Reply commits; separate multiple items with semicolons")
-  .option("--blockers <items>", "Reply blockers; separate multiple items with semicolons")
-  .option("--next <items>", "Reply next actions; separate multiple items with semicolons")
-  .option("--wait", "For ask: wait for a matching reply")
-  .option("--once", "For listen: exit after the first message event")
-  .option("--json", "For read: print raw JSON")
-  .option("--timeout-ms <ms>", "Wait timeout in milliseconds", "300000")
-  .option("--interval-ms <ms>", "Wait polling interval in milliseconds", "2000")
-  .option("--start-isolated-clauth", "Start isolated clauth if the selected port is not running")
-  .option("--peer <peer>", "Peer name for launch-peer/check-partner/sync, or ad hoc name such as codex-1")
-  .option("--dry-run", "Print and write session manifest without opening Windows Terminal")
-  .option("--no-open", "Create session/config but do not open Windows Terminal")
-  .option("--print-only", "For launch-peer: resolve command without starting the CLI")
-  .action(async (action, opts) => {
-    await runCodevelop({ ...opts, action });
-  });
 
 program
   .command("npm")
@@ -1106,56 +1067,6 @@ pluginCmd
     console.log(`  ✓ ${chalk.white(receipt.target?.plugin_id || '?')} ${state} — surfaces: ${(receipt.resulting_state?.surfaces || []).join(', ') || 'none'}${target ? ` — ${chalk.gray(target)}` : ''}`);
   });
 
-// ──────────────────────────────────────────────
-// clauth chitchat --session <id>
-// ──────────────────────────────────────────────
-program
-  .command("chitchat")
-  .description("Join a chitchat collab session — auto-starts /rdc:collab via claude -p")
-  .requiredOption("--session <id>", "Session ID from claude.ai")
-  .action(async (opts) => {
-    const id = opts.session;
-    // Verify session exists in the daemon
-    try {
-      const r = await fetch(`http://127.0.0.1:52437/chitchat/${id}`, { signal: AbortSignal.timeout(3000) });
-      if (!r.ok) {
-        console.error(`\n  ✗ Session ${id} not found (daemon returned ${r.status})\n`);
-        process.exit(1);
-      }
-    } catch (e) {
-      console.error(`\n  ✗ Daemon not reachable at http://127.0.0.1:52437 — is clauth running?\n`);
-      process.exit(1);
-    }
-    console.log(chalk.cyan(`\n  [collab] session ${id} — starting /rdc:collab...\n`));
-
-    // Find claude binary (same candidates as daemon)
-    const { execSync: es, spawn } = await import("child_process");
-    let claudeBin = null;
-    for (const c of [
-      process.env.CLAUDE_BIN,
-      path.join(process.env.APPDATA || '', 'npm', 'claude.cmd'),
-      path.join(process.env.APPDATA || '', 'npm', 'claude'),
-      'claude',
-    ].filter(Boolean)) {
-      try { es(`"${c}" --version`, { stdio: 'ignore', timeout: 3000 }); claudeBin = c; break; } catch {}
-    }
-    if (!claudeBin) {
-      console.error('  ✗ claude CLI not found — is @anthropic-ai/claude-code installed globally?');
-      process.exit(1);
-    }
-
-    // Auto-invoke /rdc:collab skill with streaming output to this terminal
-    const proc = spawn(claudeBin, [
-      '-p', `/rdc:collab --session ${id}`,
-      '--dangerously-skip-permissions',
-    ], {
-      stdio: 'inherit',
-      cwd: 'C:/Dev/regen-root',
-      shell: true,
-    });
-    proc.on('error', e => { console.error(`  ✗ spawn error: ${e.message}`); process.exit(1); });
-    proc.on('exit', code => process.exit(code ?? 0));
-  });
 
 // ──────────────────────────────────────────────
 // clauth --help override banner
@@ -1175,7 +1086,7 @@ program.addHelpText("beforeAll", chalk.cyan(`
 // ──────────────────────────────────────────────
 program
   .command("serve [action]")
-  .description("Manage localhost HTTP vault daemon and supervisor (start|stop|restart|ping|supervisor|install|uninstall)")
+  .description("Manage localhost HTTP vault daemon and supervisor (start|stop|restart|ping|test|supervisor|install|uninstall)")
   .option("--port <n>", "Port (default: 52437)")
   .option("-p, --pw <password>", "clauth password (optional — omit to start locked, unlock in browser)")
   .option("--services <list>", "Comma-separated service whitelist (default: all)")
@@ -1193,6 +1104,8 @@ Actions:
   restart     Stop + start
   ping        Check if the daemon is running
   foreground  Run in foreground (Ctrl+C to stop) — default if no action given
+  test        Run an isolated, passwordless test lane on the fixed port 52440 —
+              shorthand for: CLAUTH_SUPERVISOR_TEST_NO_TOKEN=1 serve foreground --isolated --port 52440
   mcp         Run as MCP stdio server for Claude Code (JSON-RPC over stdin/stdout)
   supervisor  Run localhost-only supervisor control plane on port 52439
   install     Store password securely + register auto-start service (cross-platform)
@@ -1215,7 +1128,8 @@ Examples:
   clauth serve mcp -p mypass             Start MCP server pre-unlocked
   clauth serve supervisor                Start supervisor API on http://127.0.0.1:52439
   clauth serve foreground --port 53137 --isolated
-                                          Start isolated passwordless server for route tests
+                                          Start isolated passwordless server for route tests (ad-hoc port)
+  clauth serve test                      Start the fixed test lane on http://127.0.0.1:52440
   clauth serve install                   Set up auto-start on login (DPAPI/Keychain/libsecret)
   clauth serve install --tunnel host     Auto-start with Cloudflare Tunnel
   clauth serve uninstall                 Remove auto-start

package/cli/lib/fs-git.test.js

@@ -0,0 +1,467 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+import {
+  runGitAsync,
+  runGitPushAuthed,
+  gitInProgressState,
+  repoStatus,
+  useBranch,
+  commit,
+  diff,
+  FS_GIT_PROTECTED_BRANCHES,
+} from "./fs-git.js";
+
+// Real git repos in temp dirs — this is plumbing logic that talks to the real
+// git binary, and a mock of git would just be re-asserting the mock. A bare
+// repo as "origin" gives a real, local push target with no network and no
+// token verification, so the success path is exercised for real, not stubbed.
+function git(cwd, args) {
+  return execFileSync("git", args, { cwd, encoding: "utf8" }).trim();
+}
+
+function initRepo(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  git(dir, ["init", "-q", "-b", "develop"]);
+  git(dir, ["config", "user.email", "test@clauth.local"]);
+  git(dir, ["config", "user.name", "clauth-test"]);
+  return dir;
+}
+
+function withRepo(fn) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "clauth-fsgit-test-"));
+  // realpathSync: on this box, os.tmpdir() resolves through the 8.3 short
+  // alias (DAVELA~1) while `git rev-parse --show-toplevel` always answers with
+  // the canonical long path (DaveLadouceur). commit()'s repo-root guard
+  // compares its caller-supplied `repoRoot` against that git-resolved value
+  // byte-for-byte, so a short-alias path fails the guard on a repo that is, in
+  // every real sense, the repo root. Canonicalizing here is the test fixture's
+  // job — passing a short-alias path is not the scenario "Invalid repo path"
+  // or "Base moved" are meant to cover.
+  const repo = fs.realpathSync.native(initRepo(path.join(root, "repo")));
+  return (async () => {
+    try { return await fn(repo, root); } finally { fs.rmSync(root, { recursive: true, force: true }); }
+  })();
+}
+
+function withRepoAndOrigin(fn) {
+  return withRepo(async (repo, root) => {
+    // A local bare repo stands in for "origin" — a real push target with
+    // no network and no token check, so success paths are exercised for real.
+    const bare = path.join(root, "origin.git");
+    git(root, ["init", "-q", "--bare", bare]);
+    fs.writeFileSync(path.join(repo, "README.md"), "# repo\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "initial"]);
+    git(repo, ["remote", "add", "origin", bare]);
+    git(repo, ["push", "-q", "-u", "origin", "develop"]);
+    return fn(repo, bare);
+  });
+}
+
+// ── runGitAsync ──────────────────────────────────────────────────────────────
+
+test("runGitAsync resolves with trimmed stdout on success", async () =>
+  withRepo(async (repo) => {
+    // A fresh init with zero commits leaves HEAD pointing at an unborn branch;
+    // `rev-parse --abbrev-ref HEAD` treats that as an unresolvable revision on
+    // this git version ("ambiguous argument HEAD"). One commit is the minimum
+    // needed for HEAD to resolve at all — every other test in this file already
+    // commits first for the same reason.
+    git(repo, ["commit", "--allow-empty", "-q", "-m", "first"]);
+    const out = await runGitAsync(repo, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    assert.equal(out, "develop");
+  }));
+
+test("runGitAsync rejects with stderr detail on a non-zero exit", async () =>
+  withRepo(async (repo) => {
+    await assert.rejects(
+      () => runGitAsync(repo, ["rev-parse", "--verify", "refs/heads/does-not-exist"]),
+      /failed/,
+    );
+  }));
+
+test("runGitAsync scrubs a secret substring from the error text", async () =>
+  withRepo(async (repo) => {
+    await assert.rejects(
+      () => runGitAsync(repo, ["show", "secretvalue123:nope"], { scrub: "secretvalue123", label: "git show" }),
+      (err) => {
+        assert.ok(!err.message.includes("secretvalue123"), `secret leaked into error: ${err.message}`);
+        assert.ok(err.message.includes("***"), "scrubbed text must be replaced with a marker, not silently dropped");
+        return true;
+      },
+    );
+  }));
+
+test("runGitAsync uses opts.label instead of the raw args in the error", async () =>
+  withRepo(async (repo) => {
+    await assert.rejects(
+      () => runGitAsync(repo, ["rev-parse", "--verify", "nope"], { label: "custom label here" }),
+      /^Error: custom label here failed/,
+    );
+  }));
+
+// ── runGitPushAuthed ─────────────────────────────────────────────────────────
+
+test("runGitPushAuthed pushes successfully to a real local remote and never persists the token", async () =>
+  withRepoAndOrigin(async (repo, bare) => {
+    fs.writeFileSync(path.join(repo, "new-file.txt"), "hello\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "second commit"]);
+    await runGitPushAuthed(repo, "fake-token-value", "origin", "HEAD:develop");
+    const remoteLog = git(bare, ["log", "-1", "--pretty=%s", "refs/heads/develop"]);
+    assert.equal(remoteLog, "second commit");
+    // The token must never land in git config or the remote URL.
+    const config = fs.readFileSync(path.join(repo, ".git", "config"), "utf8");
+    assert.ok(!config.includes("fake-token-value"), "token leaked into persisted git config");
+  }));
+
+test("runGitPushAuthed scrubs the base64 auth header from a failure message", async () =>
+  withRepo(async (repo) => {
+    // No remote named "origin" configured — push fails before network, but the
+    // scrub must still apply to whatever error text git produces.
+    await assert.rejects(
+      () => runGitPushAuthed(repo, "another-fake-token", "origin", "HEAD:develop"),
+      (err) => {
+        const basic = Buffer.from("x-access-token:another-fake-token").toString("base64");
+        assert.ok(!err.message.includes(basic), "base64 credential leaked into the error message");
+        return true;
+      },
+    );
+  }));
+
+// ── gitInProgressState ───────────────────────────────────────────────────────
+
+test("gitInProgressState reports false/false on a clean repo", async () =>
+  withRepo(async (repo) => {
+    const state = await gitInProgressState(repo);
+    assert.deepEqual(state, { merge: false, rebase: false });
+  }));
+
+test("gitInProgressState returns false/false (not a throw) outside any git repo", async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "clauth-fsgit-notrepo-"));
+  try {
+    const state = await gitInProgressState(dir);
+    assert.deepEqual(state, { merge: false, rebase: false });
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ── repoStatus ───────────────────────────────────────────────────────────────
+
+test("repoStatus reports a clean checked-out repo accurately", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const { result } = await repoStatus(repo);
+    assert.equal(result.branch, "develop");
+    assert.equal(result.clean, true);
+    assert.equal(result.dirty_count, 0);
+    assert.equal(result.subject, "first");
+    assert.equal(result.merge_in_progress, false);
+    assert.equal(result.rebase_in_progress, false);
+    assert.equal(path.normalize(result.repo_root).toLowerCase(), path.normalize(repo).toLowerCase());
+  }));
+
+test("repoStatus reports dirty and staged paths separately", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    fs.writeFileSync(path.join(repo, "a.txt"), "changed\n");
+    fs.writeFileSync(path.join(repo, "b.txt"), "new\n");
+    git(repo, ["add", "b.txt"]);
+    const { result } = await repoStatus(repo);
+    assert.equal(result.clean, false);
+    assert.equal(result.dirty_count, 2, "both the modified and the new file count as dirty");
+    assert.ok(result.staged_paths.includes("b.txt"));
+    assert.ok(!result.staged_paths.includes("a.txt"), "unstaged modification must not appear in staged_paths");
+  }));
+
+test("repoStatus reports ahead/behind null when there is no upstream", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const { result } = await repoStatus(repo);
+    assert.equal(result.upstream, null);
+    assert.equal(result.ahead, null);
+    assert.equal(result.behind, null);
+  }));
+
+// ── useBranch ────────────────────────────────────────────────────────────────
+
+test("useBranch creates a new branch from HEAD", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const { result } = await useBranch(repo, "feature/x", true);
+    assert.equal(result.status, "ok");
+    assert.equal(result.created, true);
+    assert.equal(git(repo, ["rev-parse", "--abbrev-ref", "HEAD"]), "feature/x");
+  }));
+
+test("useBranch refuses create=true on an already-existing branch", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    await useBranch(repo, "feature/x", true);
+    git(repo, ["switch", "develop"]);
+    const { error } = await useBranch(repo, "feature/x", true);
+    assert.match(error, /already exists/);
+  }));
+
+test("useBranch refuses create=false on a nonexistent branch", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const { error } = await useBranch(repo, "does-not-exist", false);
+    assert.match(error, /does not exist/);
+  }));
+
+test("useBranch requires a non-empty branch name", async () =>
+  withRepo(async (repo) => {
+    const { error } = await useBranch(repo, "   ", true);
+    assert.equal(error, "branch is required");
+  }));
+
+test("useBranch refuses to switch during an in-progress merge", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "base\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "base"]);
+    git(repo, ["switch", "-c", "feature/y"]);
+    fs.writeFileSync(path.join(repo, "a.txt"), "feature change\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "feature change"]);
+    git(repo, ["switch", "develop"]);
+    fs.writeFileSync(path.join(repo, "a.txt"), "develop change\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "develop change"]);
+    try { git(repo, ["merge", "feature/y"]); } catch { /* conflict expected */ }
+    const { error } = await useBranch(repo, "feature/y", false);
+    assert.match(error, /merge or rebase is in progress/);
+  }));
+
+// ── commit ───────────────────────────────────────────────────────────────────
+
+test("commit requires a message", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const { error } = await commit(repo, { message: "" });
+    assert.equal(error, "message is required");
+  }));
+
+test("commit refuses on detached HEAD", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const sha = git(repo, ["rev-parse", "HEAD"]);
+    git(repo, ["checkout", "-q", sha]);
+    const { error } = await commit(repo, { message: "x", push: false });
+    assert.match(error, /detached HEAD/);
+  }));
+
+test("commit reports nothing_to_commit when the working tree is clean", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const { result } = await commit(repo, { message: "no-op", push: false });
+    assert.equal(result.status, "nothing_to_commit");
+  }));
+
+test("commit dry-run reports what WOULD happen without mutating the tree", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    fs.writeFileSync(path.join(repo, "b.txt"), "new\n");
+    const { result } = await commit(repo, { message: "would commit b", push: true, dryRun: true });
+    assert.equal(result.status, "dry_run");
+    assert.deepEqual(result.would_commit, ["b.txt"]);
+    assert.equal(result.protected_branch, false);
+    // Nothing must actually be staged or committed by a dry run.
+    const status = git(repo, ["status", "--porcelain"]);
+    assert.match(status, /\?\? b\.txt/, "the file must still be untracked — dry run must not stage it");
+  }));
+
+test("commit dry-run flags a protected branch and reports would_push=false", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    git(repo, ["branch", "-m", "main"]);
+    fs.writeFileSync(path.join(repo, "b.txt"), "new\n");
+    const { result } = await commit(repo, { message: "x", push: true, dryRun: true });
+    assert.equal(result.protected_branch, true);
+    assert.equal(result.would_push, false);
+  }));
+
+test("commit saves locally and refuses to push a protected branch", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    git(repo, ["branch", "-m", "main"]);
+    fs.writeFileSync(path.join(repo, "b.txt"), "new\n");
+    const { result } = await commit(repo, { message: "protected", push: true, token: "irrelevant" });
+    assert.equal(result.status, "committed_local_not_pushed");
+    assert.equal(result.push_blocked, "protected_branch");
+    assert.equal(git(repo, ["log", "-1", "--pretty=%s"]), "protected", "the commit itself must still land locally");
+  }));
+
+test("commit saves locally when push is requested but no token is available", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    fs.writeFileSync(path.join(repo, "b.txt"), "new\n");
+    const { result } = await commit(repo, { message: "no token", push: true, tokenError: "vault locked" });
+    assert.equal(result.status, "committed_local_not_pushed");
+    assert.equal(result.push_blocked, "no_token");
+    assert.match(result.message, /vault locked/);
+  }));
+
+test("commit with push:false never attempts a push even with a token present", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    fs.writeFileSync(path.join(repo, "b.txt"), "new\n");
+    const { result } = await commit(repo, { message: "local only", push: false, token: "unused-token" });
+    assert.equal(result.status, "committed_local");
+    assert.equal(result.pushed, false);
+  }));
+
+test("commit stages only the given paths, not the whole tree", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    fs.writeFileSync(path.join(repo, "b.txt"), "new-b\n");
+    fs.writeFileSync(path.join(repo, "c.txt"), "new-c\n");
+    const { result } = await commit(repo, { message: "only b", push: false, paths: ["b.txt"] });
+    assert.deepEqual(result.files, ["b.txt"]);
+    const status = git(repo, ["status", "--porcelain"]);
+    assert.match(status, /\?\? c\.txt/, "c.txt must remain untracked — it was not in the requested scope");
+  }));
+
+test("commit rejects a path escaping the repo root", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const { error } = await commit(repo, { message: "x", push: false, paths: ["../../etc/passwd"] });
+    assert.match(error, /Invalid repo path/);
+  }));
+
+test("commit refuses when the optimistic-concurrency expectedHead has moved", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const staleSha = git(repo, ["rev-parse", "HEAD"]);
+    fs.writeFileSync(path.join(repo, "a.txt"), "moved\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "moved on"]);
+    fs.writeFileSync(path.join(repo, "b.txt"), "new\n");
+    const { error } = await commit(repo, { message: "x", push: false, expectedHead: staleSha });
+    assert.match(error, /Base moved/);
+  }));
+
+test("commit end-to-end: commits AND pushes to a real local remote", async () =>
+  withRepoAndOrigin(async (repo, bare) => {
+    fs.writeFileSync(path.join(repo, "new.txt"), "content\n");
+    const { result } = await commit(repo, { message: "ship it", push: true, token: "fake-token" });
+    assert.equal(result.status, "committed_and_pushed");
+    assert.equal(result.pushed, true);
+    assert.equal(git(bare, ["log", "-1", "--pretty=%s", "refs/heads/develop"]), "ship it");
+  }));
+
+test("FS_GIT_PROTECTED_BRANCHES covers the expected set and nothing else", () => {
+  assert.deepEqual([...FS_GIT_PROTECTED_BRANCHES].sort(), ["main", "master", "prod", "production"]);
+});
+
+// ── diff ─────────────────────────────────────────────────────────────────────
+
+test("diff reports working-tree changes against HEAD by default", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "line1\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    fs.writeFileSync(path.join(repo, "a.txt"), "line1\nline2\n");
+    const { result } = await diff(repo, {});
+    assert.equal(result.compared_to, "HEAD");
+    assert.equal(result.staged, false);
+    assert.match(result.patch, /\+line2/);
+  }));
+
+test("diff --staged compares the index, not the working tree", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "line1\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    fs.writeFileSync(path.join(repo, "a.txt"), "line1\nstaged-line\n");
+    git(repo, ["add", "-A"]);
+    fs.appendFileSync(path.join(repo, "a.txt"), "unstaged-line\n");
+    const { result } = await diff(repo, { staged: true });
+    assert.match(result.patch, /\+staged-line/);
+    assert.ok(!result.patch.includes("unstaged-line"), "staged diff must not include unstaged changes");
+  }));
+
+test("diff reports (no differences) on a clean tree instead of an empty string", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const { result } = await diff(repo, {});
+    assert.equal(result.patch, "(no differences)");
+    assert.equal(result.stat, "(no differences)");
+  }));
+
+test("diff rejects an unknown ref with a clean error instead of a raw git failure", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const { error } = await diff(repo, { ref: "origin/does-not-exist" });
+    assert.match(error, /Unknown ref/);
+  }));
+
+test("diff rejects a path escaping the repo root", async () =>
+  withRepo(async (repo) => {
+    fs.writeFileSync(path.join(repo, "a.txt"), "a\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    const { error } = await diff(repo, { paths: ["../outside.txt"] });
+    assert.match(error, /Invalid repo path/);
+  }));
+
+test("diff truncates a very large patch and flags truncated:true", async () =>
+  withRepo(async (repo) => {
+    // Plain `git diff` (working tree vs HEAD) never shows an UNTRACKED file —
+    // that is real git behavior, and it is what production diff() inherits by
+    // default. To exercise the >60000-char cap through that same default path,
+    // the file must already be tracked so the size shows up as a
+    // (small tracked line) -> (huge line) MODIFICATION, not a new file.
+    fs.writeFileSync(path.join(repo, "big.txt"), "small\n");
+    git(repo, ["add", "-A"]);
+    git(repo, ["commit", "-q", "-m", "first"]);
+    fs.writeFileSync(path.join(repo, "big.txt"), "x".repeat(61000) + "\n");
+    const { result } = await diff(repo, {});
+    assert.equal(result.truncated, true);
+    assert.ok(result.patch.endsWith("(diff truncated at 60KB)"));
+  }));

package/cli/mcp/providers/call-agent-provider.js

@@ -0,0 +1,30 @@
+// cli/mcp/providers/call-agent-provider.js
+// The call_agent MCP tool, as its own provider file registering against the
+// shared cli/mcp/tool-registry.js — completing the same file-level split as
+// terminal-provider.js, ops-provider.js, and clauth-core-provider.js.
+//
+// Deliberately different from those three: runCallAgent itself (Supabase
+// job persistence, the AgentCron scheduler, getAgentPool()) is genuinely
+// core, cross-cutting daemon infrastructure — it's also the shared
+// entrypoint for POST /call-agent, a REST route, not just this MCP tool.
+// Moving that logic wholesale would need a much deeper dependency audit
+// than the other three groups needed, so it stays in serve.js.
+//
+// This file therefore does NOT import runCallAgent from serve.js — that
+// would make serve.js (which imports this file for its registerTool side
+// effect) and this file mutually dependent, a real circular import and
+// exactly the coupling Dependency Inversion is supposed to prevent.
+// Instead it exports a registration function that takes runCallAgent as an
+// explicit parameter; serve.js calls it once, right after runCallAgent's
+// own definition, passing itself in. This file's only real dependency is
+// the shared tool-registry.js interface — runCallAgent is injected, not
+// imported.
+import { mcpResult, mcpError, registerTool } from "../tool-registry.js";
+
+export function registerCallAgentTool(runCallAgent) {
+  registerTool("call_agent", async (args, vault) => {
+    const result = await runCallAgent(args || {});
+    if (!result.ok) return mcpError(`${result.error}${result.message ? `: ${result.message}` : ""}`);
+    return mcpResult(JSON.stringify(result));
+  });
+}