Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript
24.5 KB
Raw Blame
/**
 * The harness-lane CLI surface (spawned through src/cli.ts — exercises the
 * peeled arg parsers, the flag registry, per-harness defaults, the stub
 * preflight refusal, receipts, and the post-peel dispatch smoke [ENG-E5]).
 *
 * Hermetic: HOME and GBRAIN_HOME pinned to tempdirs in every spawn — the
 * claude-code default dest derives from HOME (host-specs HOME-env-first
 * discipline) and bridge state lives under GBRAIN_HOME/.gbrain.
 */

import { describe, expect, test, afterEach } from 'bun:test';
import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
import { join, resolve } from 'path';
import { tmpdir } from 'os';
import { spawnSync } from 'child_process';
import { createHash } from 'node:crypto';

const REPO_ROOT = resolve(import.meta.dir, '..');
const CLI = join(REPO_ROOT, 'src', 'cli.ts');

const cleanups: string[] = [];
afterEach(() => {
  for (const d of cleanups.splice(0)) rmSync(d, { recursive: true, force: true });
});

function homes(): { home: string; gbrainHome: string } {
  const home = mkdtempSync(join(tmpdir(), 'gb-harness-cli-home-'));
  const gbrainHome = mkdtempSync(join(tmpdir(), 'gb-harness-cli-gb-'));
  cleanups.push(home, gbrainHome);
  return { home, gbrainHome };
}

function run(args: string[], env: Record<string, string>) {
  const r = spawnSync('bun', [CLI, 'skillpack', ...args], {
    encoding: 'utf8',
    cwd: REPO_ROOT,
    env: { ...process.env, ...env },
    timeout: 120_000,
  });
  return { code: r.status, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
}

describe('scaffold --harness claude-code', () => {
  test('defaults: coding-agent persona into HOME/.claude/skills; state under GBRAIN_HOME; idempotent re-run', () => {
    const { home, gbrainHome } = homes();
    const env = { HOME: home, GBRAIN_HOME: gbrainHome, CLAUDE_CONFIG_DIR: '' };

    const r1 = run(['scaffold', '--harness', 'claude-code', '--json'], env);
    expect(r1.code, r1.stderr).toBe(0);
    const receipt = JSON.parse(r1.stdout);
    expect(receipt.persona).toBe('coding-agent');
    expect(receipt.mode).toBe('full');
    expect(receipt.dest).toBe(join(home, '.claude', 'skills'));
    expect(receipt.summary.wroteNew).toBeGreaterThan(30);
    expect(receipt.summary.skippedExisting).toBe(0);
    expect(receipt.coexistence.plugin_lane_overlap.length).toBeGreaterThan(10);
    expect(existsSync(join(home, '.claude', 'skills', 'query', 'SKILL.md'))).toBe(true);
    expect(existsSync(join(home, '.claude', 'skills', 'conventions'))).toBe(true);
    // Lane exclusion holds end-to-end: no repo-dev skill in a harness dir.
    expect(existsSync(join(home, '.claude', 'skills', 'testing'))).toBe(false);
    // State landed under GBRAIN_HOME.
    const statePath = join(gbrainHome, '.gbrain', 'skillpack-bridge-state.json');
    expect(existsSync(statePath)).toBe(true);
    const state = JSON.parse(readFileSync(statePath, 'utf-8'));
    expect(state.entries[0].harness).toBe('claude-code');
    expect(state.entries[0].last_persona).toBe('coding-agent');

    const r2 = run(['scaffold', '--harness', 'claude-code', '--json'], env);
    const receipt2 = JSON.parse(r2.stdout);
    expect(receipt2.summary.wroteNew).toBe(0);
    expect(receipt2.summary.skippedExisting).toBe(receipt.summary.wroteNew);
  }, 180_000);

  test('--dry-run writes nothing', () => {
    const { home, gbrainHome } = homes();
    const r = run(['scaffold', '--harness', 'claude-code', '--dry-run', '--json'], {
      HOME: home,
      GBRAIN_HOME: gbrainHome,
      CLAUDE_CONFIG_DIR: '',
    });
    expect(r.code, r.stderr).toBe(0);
    expect(existsSync(join(home, '.claude', 'skills'))).toBe(false);
  }, 120_000);
});

describe('refusals (typed, actionable)', () => {
  test('codex/opencode without a dest exit 2 naming the observation-run gap', () => {
    const { home, gbrainHome } = homes();
    for (const h of ['codex', 'opencode']) {
      const r = run(['scaffold', '--harness', h], { HOME: home, GBRAIN_HOME: gbrainHome });
      expect(r.code).toBe(2);
      expect(r.stderr).toContain('no attested native skills dir');
      expect(r.stderr).toContain('observation run');
    }
  }, 120_000);

  test('unknown persona exits 2 listing the valid choices', () => {
    const { home, gbrainHome } = homes();
    const dest = mkdtempSync(join(tmpdir(), 'gb-harness-dest-'));
    cleanups.push(dest);
    const r = run(['scaffold', '--harness', 'claude-code', '--persona', 'nope', '--dest', dest], {
      HOME: home,
      GBRAIN_HOME: gbrainHome,
    });
    expect(r.code).toBe(2);
    expect(r.stderr).toContain('coding-agent');
  }, 120_000);

  test('--skill testing is refused with the recorded lane-exclusion reason [OV5]', () => {
    const { home, gbrainHome } = homes();
    const dest = mkdtempSync(join(tmpdir(), 'gb-harness-dest-'));
    cleanups.push(dest);
    const r = run(['scaffold', '--harness', 'claude-code', '--skill', 'testing', '--dest', dest], {
      HOME: home,
      GBRAIN_HOME: gbrainHome,
    });
    expect(r.code).toBe(2);
    expect(r.stderr).toContain('excluded from the plugin lane');
  }, 120_000);

  test('--stub with the publish gate off exits 2 with the exact enable command [D3B preflight]', () => {
    const { home, gbrainHome } = homes();
    const dest = mkdtempSync(join(tmpdir(), 'gb-harness-dest-'));
    cleanups.push(dest);
    const r = run(['scaffold', '--harness', 'claude-code', '--stub', '--skill', 'query', '--dest', dest], {
      HOME: home,
      GBRAIN_HOME: gbrainHome,
    });
    expect(r.code).toBe(2);
    expect(r.stderr).toContain('mcp.publish_skills');
    expect(r.stderr).toContain('gbrain config set mcp.publish_skills true');
    expect(existsSync(join(dest, 'query'))).toBe(false); // dead pointers never land
  }, 120_000);

  test('unknown --harness value exits 2 naming the valid set', () => {
    const { home, gbrainHome } = homes();
    const r = run(['scaffold', '--harness', 'pi'], { HOME: home, GBRAIN_HOME: gbrainHome });
    expect(r.code).toBe(2);
    expect(r.stderr).toContain('claude-code');
  }, 120_000);
});

describe('remove --harness', () => {
  test('removes only ledger-owned files and updates state', () => {
    const { home, gbrainHome } = homes();
    const dest = mkdtempSync(join(tmpdir(), 'gb-harness-dest-'));
    cleanups.push(dest);
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    const r1 = run(['scaffold', '--harness', 'claude-code', '--skill', 'query', '--skill', 'ingest', '--dest', dest, '--json'], env);
    expect(r1.code, r1.stderr).toBe(0);

    const r2 = run(['remove', '--harness', 'claude-code', '--dest', dest, '--skill', 'query', '--json'], env);
    expect(r2.code, r2.stderr).toBe(0);
    const receipt = JSON.parse(r2.stdout);
    expect(receipt.removedFiles.length).toBeGreaterThan(0);
    expect(receipt.notOwned).toEqual([]);
    expect(existsSync(join(dest, 'query', 'SKILL.md'))).toBe(false);
    expect(existsSync(join(dest, 'ingest', 'SKILL.md'))).toBe(true);
  }, 180_000);

  test('bare remove prints usage and exits 2', () => {
    const { home, gbrainHome } = homes();
    const r = run(['remove'], { HOME: home, GBRAIN_HOME: gbrainHome });
    expect(r.code).toBe(2);
  }, 120_000);
});

describe('post-peel dispatch smoke [ENG-E5]', () => {
  test('help surfaces route through the façade and mention the harness lane', () => {
    const { home, gbrainHome } = homes();
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    const top = run(['--help'], env);
    expect(top.code).toBe(0);
    expect(top.stdout).toContain('scaffold --harness');
    expect(top.stdout).toContain('remove --harness');
    const sc = run(['scaffold', '--help'], env);
    expect(sc.code).toBe(0);
    expect(sc.stdout).toContain('--workspace');
    const sch = run(['scaffold', '--harness', 'claude-code', '--help'], env);
    expect(sch.code).toBe(0);
    expect(sch.stdout).toContain('--persona');
    const ref = run(['reference', '--help'], env);
    expect(ref.code).toBe(0);
    expect(ref.stdout).toContain('--apply-clean-hunks');
  }, 180_000);

  test('the v0.33 removal contract is untouched: install/uninstall still exit 2', () => {
    const { home, gbrainHome } = homes();
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    const i = run(['install'], env);
    expect(i.code).toBe(2);
    expect(i.stderr).toContain('removed in v0.33');
    const u = run(['uninstall'], env);
    expect(u.code).toBe(2);
    expect(u.stderr).toContain('removed in v0.33');
  }, 120_000);
});

describe('scaffold --harness openclaw (workspace delegation)', () => {
  test('default installs the brain-first core only; --all installs the full bundle', () => {
    const { home, gbrainHome } = homes();
    const ws = mkdtempSync(join(tmpdir(), 'gb-harness-ws-'));
    const full = mkdtempSync(join(tmpdir(), 'gb-harness-ws-'));
    cleanups.push(ws, full);
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    const r = run(['scaffold', '--harness', 'openclaw', '--workspace', ws, '--json'], env);
    expect(r.code, r.stderr).toBe(0);
    expect(JSON.parse(r.stdout).persona).toBe('core');
    const skillDirs = (dir: string) => readdirSync(join(dir, 'skills'), { withFileTypes: true })
      .filter(e => e.isDirectory() && existsSync(join(dir, 'skills', e.name, 'SKILL.md'))).map(e => e.name).sort();
    expect(skillDirs(ws)).toEqual(['brain-ops', 'capture', 'data-loss-gate', 'query', 'resolve-before-asking']);
    expect(existsSync(join(ws, 'skills', 'conventions', 'brain-first.md'))).toBe(true);
    const all = run(['scaffold', '--harness', 'openclaw', '--workspace', full, '--all', '--json'], env);
    expect(all.code, all.stderr).toBe(0);
    expect(JSON.parse(all.stdout).persona).toBe('all');
    expect(skillDirs(full).length).toBeGreaterThan(50);
  }, 120_000);

  test('--skill picks filter the workspace scaffold; plugin-lane additions are reported skipped, not thrown', () => {
    const { home, gbrainHome } = homes();
    const ws = mkdtempSync(join(tmpdir(), 'gb-harness-ws-'));
    cleanups.push(ws);
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    // gbrain-upgrade is a plugin-lane ADDITION (absent from the openclaw
    // bundle): the openclaw path must skip-and-report it, never throw.
    const r = run(
      ['scaffold', '--harness', 'openclaw', '--workspace', ws, '--skill', 'query', '--skill', 'gbrain-upgrade', '--json'],
      env,
    );
    expect(r.code, r.stderr).toBe(0);
    const receipt = JSON.parse(r.stdout);
    expect(receipt.openclaw_skipped).toEqual(['gbrain-upgrade']);
    expect(existsSync(join(ws, 'skills', 'query', 'SKILL.md'))).toBe(true);
    expect(existsSync(join(ws, 'skills', 'gbrain-upgrade'))).toBe(false);
    expect(existsSync(join(ws, 'skills', 'conventions'))).toBe(true);
  }, 120_000);

  test('all-additions selection refuses with a clear error; --stub and --dest are refused', () => {
    const { home, gbrainHome } = homes();
    const ws = mkdtempSync(join(tmpdir(), 'gb-harness-ws-'));
    cleanups.push(ws);
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    const none = run(['scaffold', '--harness', 'openclaw', '--workspace', ws, '--skill', 'gbrain-upgrade'], env);
    expect(none.code).toBe(2);
    expect(none.stderr).toContain('plugin-lane additions');
    const stub = run(['scaffold', '--harness', 'openclaw', '--workspace', ws, '--stub'], env);
    expect(stub.code).toBe(2);
    expect(stub.stderr).toContain('not supported for openclaw');
    const dest = run(['scaffold', '--harness', 'openclaw', '--dest', ws], env);
    expect(dest.code).toBe(2);
    expect(dest.stderr).toContain('--workspace');
  }, 120_000);
});

describe('remaining CLI gaps (coverage audit)', () => {
  test('--scope project lands under <workspace>/.claude/skills', () => {
    const { home, gbrainHome } = homes();
    const ws = mkdtempSync(join(tmpdir(), 'gb-harness-proj-'));
    cleanups.push(ws);
    const r = run(
      ['scaffold', '--harness', 'claude-code', '--scope', 'project', '--workspace', ws, '--skill', 'query', '--json'],
      { HOME: home, GBRAIN_HOME: gbrainHome },
    );
    expect(r.code, r.stderr).toBe(0);
    expect(JSON.parse(r.stdout).dest).toBe(join(ws, '.claude', 'skills'));
    expect(existsSync(join(ws, '.claude', 'skills', 'query', 'SKILL.md'))).toBe(true);
  }, 120_000);

  test('remove --harness without --skill removes every owned slug', () => {
    const { home, gbrainHome } = homes();
    const dest = mkdtempSync(join(tmpdir(), 'gb-harness-dest-'));
    cleanups.push(dest);
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    expect(run(['scaffold', '--harness', 'claude-code', '--skill', 'query', '--skill', 'ingest', '--dest', dest], env).code).toBe(0);
    const r = run(['remove', '--harness', 'claude-code', '--dest', dest, '--json'], env);
    expect(r.code, r.stderr).toBe(0);
    expect(existsSync(join(dest, 'query', 'SKILL.md'))).toBe(false);
    expect(existsSync(join(dest, 'ingest', 'SKILL.md'))).toBe(false);
    // Shared conventions were never slug-owned; they survive a full remove.
    expect(existsSync(join(dest, 'conventions'))).toBe(true);
    // Ledger emptied → state entry gone → nothing owned on a re-run.
    const again = JSON.parse(run(['remove', '--harness', 'claude-code', '--dest', dest, '--json'], env).stdout);
    expect(again.removedFiles).toEqual([]);
  }, 180_000);

  test('skillpack status renders the installed-bridges section', () => {
    const { home, gbrainHome } = homes();
    const dest = mkdtempSync(join(tmpdir(), 'gb-harness-dest-'));
    const ws = mkdtempSync(join(tmpdir(), 'gb-harness-ws-'));
    cleanups.push(dest, ws);
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    expect(run(['scaffold', '--harness', 'claude-code', '--skill', 'query', '--dest', dest], env).code).toBe(0);
    const r = run(['status', '--workspace', ws, '--json'], env);
    expect(r.code, r.stderr).toBe(0);
    const receipt = JSON.parse(r.stdout);
    expect(receipt.bridges).toHaveLength(1);
    expect(receipt.bridges[0].harness).toBe('claude-code');
    expect(receipt.bridges[0].dest).toBe(dest);
    expect(receipt.bridges[0].identical).toBeGreaterThan(0);
  }, 120_000);

  test('stub preflight gate 2: an unservable slug is refused with the skills_dir hint', () => {
    const { home, gbrainHome } = homes();
    const dest = mkdtempSync(join(tmpdir(), 'gb-harness-dest-'));
    const emptyDir = mkdtempSync(join(tmpdir(), 'gb-harness-empty-'));
    cleanups.push(dest, emptyDir);
    // Publish gate ON via the file plane; skills dir pointed at an EMPTY dir
    // so every slug is unservable from the server's perspective.
    mkdirSync(join(gbrainHome, '.gbrain'), { recursive: true });
    writeFileSync(
      join(gbrainHome, '.gbrain', 'config.json'),
      JSON.stringify({ mcp: { publish_skills: true, skills_dir: emptyDir } }),
    );
    const r = run(['scaffold', '--harness', 'claude-code', '--stub', '--skill', 'query', '--dest', dest], {
      HOME: home,
      GBRAIN_HOME: gbrainHome,
    });
    expect(r.code).toBe(2);
    expect(r.stderr).toContain('cannot serve');
    expect(r.stderr).toContain('mcp.skills_dir');
    expect(existsSync(join(dest, 'query'))).toBe(false);
  }, 120_000);

  test('reference --harness: positional slug lens + apply guard requires a single skill', () => {
    const { home, gbrainHome } = homes();
    const dest = mkdtempSync(join(tmpdir(), 'gb-harness-dest-'));
    cleanups.push(dest);
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    expect(run(['scaffold', '--harness', 'claude-code', '--skill', 'query', '--dest', dest], env).code).toBe(0);
    const ref = run(['reference', '--harness', 'claude-code', '--dest', dest, 'query', '--json'], env);
    expect(ref.code, ref.stderr).toBe(0);
    const result = JSON.parse(ref.stdout);
    expect(result.summary.differs).toBe(0);
    const applyAll = run(['reference', '--harness', 'claude-code', '--dest', dest, '--apply-clean-hunks'], env);
    expect(applyAll.code).toBe(2);
    expect(applyAll.stderr).toContain('exactly ONE skill');
    const oc = run(['reference', '--harness', 'openclaw'], env);
    expect(oc.code).toBe(2);
  }, 180_000);
});

describe('review-driven CLI hardening', () => {
  test('active shared brain installs a live source-bound router only after follow approval and cleanly opts out', () => {
    const { home, gbrainHome } = homes();
    const dest = mkdtempSync(join(tmpdir(), 'gb-shared-harness-dest-')); cleanups.push(dest);
    const env = { HOME: home, GBRAIN_HOME: gbrainHome, GBRAIN_SOURCE: 'default', GBRAIN_BRAIN_ID: 'host' };
    const init = spawnSync('bun', [CLI, 'init', '--pglite', '--no-embedding', '--non-interactive'], {
      encoding: 'utf8', cwd: REPO_ROOT, env: { ...process.env, ...env }, timeout: 120_000,
    });
    expect(init.status, init.stderr).toBe(0);
    mkdirSync(join(dest, 'unrelated'));
    writeFileSync(join(dest, 'unrelated', 'SKILL.md'), 'Keep this unrelated native skill');
    const base = ['scaffold', '--harness', 'claude-code', '--dest', dest, '--json'];
    const pending = run([...base, '--stub'], env);
    expect(pending.code, pending.stderr).toBe(0);
    expect(JSON.parse(pending.stdout).reason).toBe('follow_approval_required');
    expect(existsSync(join(dest, 'query'))).toBe(false);
    const followed = run([...base, '--skills', 'follow'], env);
    expect(followed.code, followed.stderr).toBe(0);
    const receipt = JSON.parse(followed.stdout);
    expect(receipt.status).toBe('restart_required');
    expect(receipt.native).toBe('unverified');
    expect(receipt.source_id).toBe('default');
    expect(readFileSync(receipt.native_router_path, 'utf8')).toContain(receipt.launcher);
    expect(readFileSync(receipt.native_router_path, 'utf8')).toContain('sync-brain-skills');
    const invoke = (args: string[]) => spawnSync(receipt.launcher, args, {
      encoding: 'utf8', cwd: '/', env: { ...process.env, ...env, GBRAIN_SOURCE: 'wrong-source', GBRAIN_BRAIN_ID: 'wrong-brain' }, timeout: 120_000,
    });
    const sync = invoke(['sync-brain-skills', '--installation-id', receipt.installation_id,
      '--enrollment-epoch', String(receipt.enrollment_epoch), '--json']);
    expect(sync.status, sync.stderr).toBe(0);
    const view = JSON.parse(sync.stdout);
    expect(view.brain_id).toBe(receipt.brain_id);
    expect(view.complete).toBe(true);
    expect(view.skills.length).toBeGreaterThan(0);
    expect(view.skills.every((skill: { source_id: string }) => skill.source_id === 'default')).toBe(true);
    const selected = view.skills[0];
    const identity = ['--expected-brain-id', selected.brain_id, '--source-id', selected.source_id,
      '--source-incarnation', selected.source_incarnation, '--pack-id', selected.pack_id, '--revision', selected.revision];
    const fetched = invoke(['skill', selected.name, ...identity, '--schema-version', '2', '--json']);
    expect(fetched.status, fetched.stderr).toBe(0);
    const detail = JSON.parse(fetched.stdout);
    expect(detail.revision).toBe(selected.revision);
    expect(detail.usable).toBe(true);
    expect(detail.delivery).toBe('complete');
    const file = detail.files[0];
    const asset = invoke(['skill-asset', '--name', selected.name, ...identity, '--path', file.path, '--json']);
    expect(asset.status, asset.stderr).toBe(0);
    const bytes = JSON.parse(asset.stdout);
    expect(bytes.revision).toBe(selected.revision);
    expect(createHash('sha256').update(Buffer.from(bytes.content, bytes.encoding)).digest('hex')).toBe(file.sha256);
    const left = run([...base, '--skills', 'memory-only'], env);
    expect(left.code, left.stderr).toBe(0);
    expect(JSON.parse(left.stdout).reason).toBe('memory_only');
    expect(existsSync(receipt.native_router_path)).toBe(false);
    expect(readFileSync(join(dest, 'unrelated', 'SKILL.md'), 'utf8')).toBe('Keep this unrelated native skill');
  }, 180_000);

  test('openclaw --persona path: lane additions inside the persona are skipped-and-reported', () => {
    const { home, gbrainHome } = homes();
    const ws = mkdtempSync(join(tmpdir(), 'gb-harness-ws-'));
    cleanups.push(ws);
    // daily-driver contains gbrain-advisor — verify whether it's an addition;
    // the receipt's openclaw_skipped must exactly equal the persona's
    // lane-addition subset (possibly empty), and the run must not throw.
    const r = run(['scaffold', '--harness', 'openclaw', '--workspace', ws, '--persona', 'daily-driver', '--json'], {
      HOME: home,
      GBRAIN_HOME: gbrainHome,
    });
    expect(r.code, r.stderr).toBe(0);
    const receipt = JSON.parse(r.stdout);
    expect(Array.isArray(receipt.openclaw_skipped)).toBe(true);
    expect(existsSync(join(ws, 'skills', 'query', 'SKILL.md'))).toBe(true);
    for (const skipped of receipt.openclaw_skipped) {
      expect(existsSync(join(ws, 'skills', skipped))).toBe(false);
    }
  }, 120_000);

  test('unexpected positionals are rejected with a --skill hint (scaffold + remove)', () => {
    const { home, gbrainHome } = homes();
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    const sc = run(['scaffold', '--harness', 'claude-code', 'query'], env);
    expect(sc.code).toBe(2);
    expect(sc.stderr).toContain("unexpected argument 'query'");
    const rm = run(['remove', '--harness', 'claude-code', 'query'], env);
    expect(rm.code).toBe(2);
    expect(rm.stderr).toContain("unexpected argument 'query'");
  }, 120_000);

  test('stub preflight honors the DB config plane (gbrain config set, no config.json key)', () => {
    const { home, gbrainHome } = homes();
    const dest = mkdtempSync(join(tmpdir(), 'gb-harness-dest-'));
    cleanups.push(dest);
    const env = { HOME: home, GBRAIN_HOME: gbrainHome };
    // Initialize a PGLite brain and set the gate on the DB plane only.
    const init = spawnSync('bun', [CLI, 'init', '--pglite', '--db-only', '--no-embedding', '--non-interactive'], {
      encoding: 'utf8',
      cwd: REPO_ROOT,
      env: { ...process.env, ...env },
      timeout: 120_000,
    });
    expect(init.status, init.stderr).toBe(0);
    const set = spawnSync('bun', [CLI, 'config', 'set', 'mcp.publish_skills', 'true'], {
      encoding: 'utf8',
      cwd: REPO_ROOT,
      env: { ...process.env, ...env },
      timeout: 120_000,
    });
    expect(set.status, set.stderr).toBe(0);
    const r = run(['scaffold', '--harness', 'claude-code', '--stub', '--skill', 'query', '--dest', dest, '--json'], env);
    expect(r.code, r.stderr).toBe(0);
    expect(readFileSync(join(dest, 'query', 'SKILL.md'), 'utf-8')).toContain('gbrain-skill-stub');
  }, 180_000);
});

// #5912: the shared-dependency ledger key `_shared` is not a skill, and the
// scaffold's "Update lens" hint must run verbatim with the targeting flags the
// user passed.
describe('reference --harness after a scaffold (#5912)', () => {
  test('no slug: the lens covers the installed skills, never the reserved shared-dep key', () => {
    const { home, gbrainHome } = homes();
    const env = { HOME: home, GBRAIN_HOME: gbrainHome, CLAUDE_CONFIG_DIR: '' };
    const dest = join(home, 'dest');
    expect(run(['scaffold', '--harness', 'claude-code', '--skill', 'query', '--dest', dest], env).code).toBe(0);
    const all = run(['reference', '--harness', 'claude-code', '--dest', dest, '--json'], env);
    expect(all.code, all.stderr).toBe(0);
    const one = run(['reference', '--harness', 'claude-code', 'query', '--dest', dest, '--json'], env);
    expect(one.code, one.stderr).toBe(0);
    expect(JSON.parse(all.stdout).summary).toEqual(JSON.parse(one.stdout).summary);
    expect(all.stdout).not.toContain('_shared');
  });

  test('no slug after a full remove falls back to the default selection instead of failing', () => {
    const { home, gbrainHome } = homes();
    const env = { HOME: home, GBRAIN_HOME: gbrainHome, CLAUDE_CONFIG_DIR: '' };
    const dest = join(home, 'dest');
    expect(run(['scaffold', '--harness', 'claude-code', '--skill', 'query', '--dest', dest], env).code).toBe(0);
    expect(run(['remove', '--harness', 'claude-code', '--dest', dest, '--skill', 'query'], env).code).toBe(0);
    const r = run(['reference', '--harness', 'claude-code', '--dest', dest, '--json'], env);
    expect(r.code, r.stderr).toBe(0);
    expect(JSON.parse(r.stdout).summary.missing).toBeGreaterThan(0);
  });

  test('the printed Update lens command runs verbatim with the scaffold\'s --dest', () => {
    const { home, gbrainHome } = homes();
    const env = { HOME: home, GBRAIN_HOME: gbrainHome, CLAUDE_CONFIG_DIR: '' };
    const dest = join(home, 'codex-skills');
    const s = run(['scaffold', '--harness', 'codex', '--skill', 'query', '--dest', dest], env);
    expect(s.code, s.stderr).toBe(0);
    const hint = /Update lens: gbrain skillpack (.+?) \| remove: gbrain skillpack (.+)$/m.exec(s.stdout);
    expect(hint).not.toBeNull();
    for (const cmd of [hint![1], hint![2]]) expect(cmd).toContain(`--dest ${dest}`);
    const lens = run(hint![1].split(' '), env);
    expect(lens.code, lens.stderr).toBe(0);
  });
});