@haposoft/cafekit 0.18.1 → 0.18.3

package/src/claude/hooks/__tests__/setup-statusline.test.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const { test, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const BUILD = path.resolve(__dirname, '../../../../scripts/build-claude-plugin.mjs');
+let work;
+let tree;
+
+before(() => {
+  work = fs.mkdtempSync(path.join(os.tmpdir(), 'ck-statusline-setup-'));
+  tree = path.join(work, "plug'in", 'cf');
+  const built = spawnSync('node', [BUILD, '--out', tree], { encoding: 'utf8' });
+  assert.equal(built.status, 0, built.stderr);
+});
+
+after(() => fs.rmSync(work, { recursive: true, force: true }));
+
+const sha = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+
+// A private HOME per case: these tests must never touch the real ~/.claude.
+function home() {
+  const dir = fs.mkdtempSync(path.join(work, 'home-'));
+  fs.mkdirSync(path.join(dir, '.claude'));
+  return { dir, data: path.join(dir, 'plugin-data') };
+}
+
+function sessionStart(h, root = tree) {
+  const run = spawnSync('node', [path.join(root, 'hooks/plugin-context.cjs')], {
+    input: '{}', encoding: 'utf8',
+    env: { ...process.env, HOME: h.dir, CLAUDE_PLUGIN_ROOT: root, CLAUDE_PLUGIN_DATA: h.data },
+  });
+  assert.equal(run.status, 0, run.stderr);
+}
+
+function setup(h, ...args) {
+  return spawnSync('node', [path.join(tree, 'scripts/setup-statusline.cjs'), ...args], {
+    encoding: 'utf8', env: { ...process.env, HOME: h.dir },
+  });
+}
+
+const launcher = (h) => path.join(h.data, 'status.cjs');
+const settingsFile = (h) => path.join(h.dir, '.claude/settings.json');
+
+test('launcher-written: SessionStart writes a launcher and a data pointer that run the statusline', () => {
+  const h = home();
+  sessionStart(h);
+  assert.equal(fs.readFileSync(path.join(h.dir, '.claude/cafekit-plugin-data'), 'utf8').trim(), h.data);
+  const run = spawnSync('node', [launcher(h)], { input: JSON.stringify({ model: { display_name: 'Test' }, workspace: { current_dir: work } }), encoding: 'utf8' });
+  assert.equal(run.status, 0, run.stderr);
+  assert.notEqual(run.stdout.trim(), '');
+});
+
+test('quote-in-path: a plugin root containing a quote still loads', () => {
+  assert.ok(tree.includes("'"));
+  const h = home();
+  sessionStart(h);
+  assert.equal(spawnSync('node', ['--check', launcher(h)]).status, 0);
+});
+
+test('launcher-missing-root-silent: a removed plugin version makes the launcher exit 0 silently', () => {
+  const h = home();
+  const gone = path.join(work, 'gone', 'cf');
+  spawnSync('node', [BUILD, '--out', gone]);
+  sessionStart(h, gone);
+  fs.rmSync(path.dirname(gone), { recursive: true, force: true });
+  const run = spawnSync('node', [launcher(h)], { input: '{}', encoding: 'utf8' });
+  assert.equal(run.status, 0);
+  assert.equal(run.stdout, '');
+});
+
+test('set-when-absent: setup adds statusLine and keeps every other key', () => {
+  const h = home();
+  sessionStart(h);
+  fs.writeFileSync(settingsFile(h), JSON.stringify({ theme: 'dark', permissions: { allow: ['Bash(ls:*)'] } }, null, 2));
+  const run = setup(h);
+  assert.equal(run.status, 0, run.stderr);
+  const settings = JSON.parse(fs.readFileSync(settingsFile(h), 'utf8'));
+  assert.equal(settings.theme, 'dark');
+  assert.deepEqual(settings.permissions, { allow: ['Bash(ls:*)'] });
+  assert.equal(settings.statusLine.type, 'command');
+  assert.ok(settings.statusLine.command.includes(launcher(h)));
+});
+
+test('replace-own-launcher: setup refreshes a statusLine that already points to the launcher', () => {
+  const h = home();
+  sessionStart(h);
+  fs.writeFileSync(settingsFile(h), JSON.stringify({ statusLine: { type: 'command', command: `node ${launcher(h)}`, padding: 4 } }));
+  assert.equal(setup(h).status, 0);
+  const { statusLine } = JSON.parse(fs.readFileSync(settingsFile(h), 'utf8'));
+  assert.equal(statusLine.command, `node ${JSON.stringify(launcher(h))}`);
+  assert.equal(statusLine.padding, 0);
+});
+
+test('keep-extended-launcher-command: a user command that wraps the launcher is not replaced', () => {
+  const h = home();
+  sessionStart(h);
+  for (const statusLine of [
+    { type: 'command', command: `node "${launcher(h)}" | tee /tmp/status.log` },
+    { type: 'command' },
+    'not-an-object',
+  ]) {
+    fs.writeFileSync(settingsFile(h), JSON.stringify({ statusLine }));
+    const before = sha(settingsFile(h));
+    assert.equal(setup(h).status, 0);
+    assert.equal(sha(settingsFile(h)), before, `replaced ${JSON.stringify(statusLine)}`);
+  }
+});
+
+test('mode-preserved: a 0600 settings file stays 0600 after setup', () => {
+  const h = home();
+  sessionStart(h);
+  fs.writeFileSync(settingsFile(h), JSON.stringify({ env: { EXAMPLE_KEY: 'placeholder' } }), { mode: 0o600 });
+  fs.chmodSync(settingsFile(h), 0o600);
+  assert.equal(setup(h).status, 0);
+  assert.equal(fs.statSync(settingsFile(h)).mode & 0o777, 0o600);
+  assert.ok(JSON.parse(fs.readFileSync(settingsFile(h), 'utf8')).statusLine);
+});
+
+test('launcher-broken-version-reports: a present but broken statusline is not silenced', () => {
+  const h = home();
+  const broken = path.join(work, 'broken', 'cf');
+  spawnSync('node', [BUILD, '--out', broken]);
+  sessionStart(h, broken);
+  fs.rmSync(path.join(broken, 'hooks/lib/color.cjs'));
+  const run = spawnSync('node', [launcher(h)], { input: '{}', encoding: 'utf8' });
+  assert.notEqual(run.status, 0);
+  assert.match(run.stderr, /color\.cjs/);
+});
+
+test('keep-foreign-status-cjs-byte-identical: another statusLine named status.cjs is left alone', () => {
+  const h = home();
+  sessionStart(h);
+  fs.writeFileSync(settingsFile(h), JSON.stringify({ statusLine: { type: 'command', command: 'node ~/tools/status.cjs' } }));
+  const before = sha(settingsFile(h));
+  const run = setup(h);
+  assert.equal(run.status, 0);
+  assert.equal(sha(settingsFile(h)), before);
+  assert.match(run.stdout + run.stderr, /already has a statusLine/);
+});
+
+test('malformed-exit-1: unparsable settings stay byte-identical and exit 1', () => {
+  const h = home();
+  sessionStart(h);
+  fs.writeFileSync(settingsFile(h), '{ "theme": "dark", // comment\n}');
+  const before = sha(settingsFile(h));
+  const run = setup(h);
+  assert.equal(run.status, 1);
+  assert.equal(sha(settingsFile(h)), before);
+});
+
+test('symlink-preserved: a symlinked settings file is updated through its target', () => {
+  const h = home();
+  sessionStart(h);
+  const target = path.join(h.dir, 'dotfiles-settings.json');
+  fs.writeFileSync(target, '{}');
+  fs.symlinkSync(target, settingsFile(h));
+  assert.equal(setup(h).status, 0);
+  assert.ok(fs.lstatSync(settingsFile(h)).isSymbolicLink());
+  assert.ok(JSON.parse(fs.readFileSync(target, 'utf8')).statusLine);
+});
+
+test('missing-pointer-exit-1: setup before any plugin session writes nothing', () => {
+  const h = home();
+  fs.writeFileSync(settingsFile(h), '{}');
+  const run = setup(h);
+  assert.equal(run.status, 1);
+  assert.equal(fs.readFileSync(settingsFile(h), 'utf8'), '{}');
+});
+
+test('command-registered: the plugin ships /cf:setup-statusline calling the script', () => {
+  const command = fs.readFileSync(path.join(tree, 'commands/setup-statusline.md'), 'utf8');
+  assert.match(command, /\$\{CLAUDE_PLUGIN_ROOT\}\/scripts\/setup-statusline\.cjs/);
+});

package/src/claude/hooks/__tests__/spec-gate.test.js

@@ -4,7 +4,7 @@
 // a real subprocess: a Stop payload is piped to stdin; we assert exit code and
 // whether stdout carries {"decision":"block",...}. The hook resolves its own
 // state directory; running from source that is a temp directory rather than the
-// source tree, and it is shared, so each test seeds/clears it deliberately.
+// source tree, so each test seeds/clears it deliberately.
 
 const { test, beforeEach, after } = require('node:test');
 const assert = require('node:assert');
@@ -14,6 +14,11 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
+// Hooks run from source keep state under os.tmpdir(); a private one per test process
+// keeps a parallel run of this file from reading or clearing this run's state.
+const PRIVATE_TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'ck-spec-gate-tmp-'));
+for (const key of ['TMPDIR', 'TMP', 'TEMP']) process.env[key] = PRIVATE_TMP;
+
 const HOOK = path.join(__dirname, '..', 'spec-gate.cjs');
 const { hookStateDir } = require(path.join(__dirname, '..', 'lib', 'hook-state-dir.cjs'));
 const CACHE = path.join(hookStateDir(), 'spec-gate-last.json');
@@ -29,9 +34,10 @@ const FIXTURE_ARTIFACT_DIGEST = crypto.createHash('sha256').update(FIXTURE_ARTIF
 function runHook(payload, cwd) {
   const projectRoot = cwd || payload.cwd;
   const specsRoot = path.join(projectRoot, 'specs');
-  // PROJECT_ROOT wins over cwd in the hook; pin it to the fixture so a host
-  // monorepo's real specs/ cannot leak into the test (e.g. active rtk-* specs).
-  const env = { ...process.env, PROJECT_ROOT: projectRoot };
+  // Source hooks use payload.cwd without inherited root overrides.
+  const env = { ...process.env };
+  delete env.CLAUDE_PROJECT_DIR;
+  delete env.PROJECT_ROOT;
   const res = spawnSync(process.execPath, [HOOK], {
     input: JSON.stringify({
       hook_event_name: 'Stop',
@@ -235,6 +241,8 @@ function installClaudeGate(root, policyMode = 'valid') {
   fs.copyFileSync(HOOK, path.join(hooks, 'spec-gate.cjs'));
   fs.mkdirSync(path.join(hooks, 'lib'), { recursive: true });
   fs.copyFileSync(path.join(__dirname, '..', 'lib', 'runtime-dir.cjs'), path.join(hooks, 'lib', 'runtime-dir.cjs'));
+  fs.copyFileSync(path.join(__dirname, '..', 'lib', 'project-root.cjs'), path.join(hooks, 'lib', 'project-root.cjs'));
+  fs.copyFileSync(path.join(__dirname, '..', 'lib', 'spec-touch.cjs'), path.join(hooks, 'lib', 'spec-touch.cjs'));
   fs.copyFileSync(path.join(__dirname, '..', 'lib', 'hook-payload.cjs'), path.join(hooks, 'lib', 'hook-payload.cjs'));
   fs.copyFileSync(
     path.join(__dirname, '..', 'lib', 'hook-state-dir.cjs'),
@@ -288,6 +296,7 @@ beforeEach(() => {
 
 after(() => {
   clearCache();
+  fs.rmSync(PRIVATE_TMP, { recursive: true, force: true });
 });
 
 test('1. newly-done task WITHOUT receipt → block, reason names task path', () => {
@@ -1264,11 +1273,14 @@ function boundReceipt(base = VALID_BASE, head = VALID_HEAD) {
 }
 
 function runHookFrom(dir, cwd) {
+  const env = { ...process.env };
+  delete env.CLAUDE_PROJECT_DIR;
+  delete env.PROJECT_ROOT;
   const res = spawnSync(process.execPath, [HOOK], {
     cwd,
     input: JSON.stringify({ hook_event_name: 'Stop', session_id: 'test', transcript_path: '/tmp/t', stop_hook_active: false, cwd: dir }),
     encoding: 'utf8',
-    env: { ...process.env, PROJECT_ROOT: dir },
+    env,
   });
   return { code: res.status, stdout: (res.stdout || '').trim(), stderr: res.stderr || '' };
 }
@@ -1371,17 +1383,142 @@ test('41. unborn HEAD fails closed before any receipt check', () => {
     clearCache();
     const body = parseBlock(runHook({}, dir).stdout);
     assert.ok(body && body.decision === 'block', 'an unborn HEAD must block');
-    // The block arrives from provenance derivation, which cannot resolve a base
-    // commit here, so the receipt check is never reached. Asserting the reason
-    // keeps this case honest: it guards fail-closed behavior on an unborn HEAD,
-    // not the binding-mode selector. The selector's own HEAD-unreadable branch
-    // is guarded by cases 38 and 39.
-    assert.match(body.reason, /controlled failure/);
+    // A done task still blocks before receipt validation, with guidance to
+    // create the first commit before recording its Base/Head.
+    assert.match(body.reason, /first commit/);
   } finally {
     fs.rmSync(dir, { recursive: true, force: true });
   }
 });
 
+function noHistoryFixture() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ck-spec-no-history-'));
+  for (const args of [['init', '-q'], ['config', 'user.email', 'cafekit@example.invalid'], ['config', 'user.name', 'CafeKit Test']]) {
+    const result = spawnSync('git', ['-C', dir, ...args], { encoding: 'utf8' });
+    assert.strictEqual(result.status, 0, result.stderr);
+  }
+  installClaudeGate(dir);
+  fs.copyFileSync(path.join(__dirname, '..', 'spec-state.cjs'), path.join(dir, '.claude/hooks/spec-state.cjs'));
+  return dir;
+}
+
+test('Stop still blocks multiple active specs for an untouched session', () => {
+  const dir = tmpDir();
+  try {
+    const gate = installClaudeGate(dir);
+    for (const feature of ['demo', 'other']) writeNoHistoryPacket(dir, feature, 'in_progress');
+    const result = spawnSync(process.execPath, [gate], {
+      cwd: dir, encoding: 'utf8', env: { ...process.env, PROJECT_ROOT: dir, CLAUDE_PROJECT_DIR: dir },
+      input: JSON.stringify({ cwd: dir, session_id: 'untouched-session', hook_event_name: 'Stop', prompt: 'Continue' }),
+    });
+    assert.strictEqual(result.status, 0, result.stderr);
+    const body = parseBlock(result.stdout);
+    assert.strictEqual(body.decision, 'block');
+    assert.match(body.reason, /multiple active specs/);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+function writeNoHistoryPacket(dir, feature, status) {
+  const packet = path.join(dir, 'specs', feature);
+  fs.mkdirSync(packet, { recursive: true });
+  fs.writeFileSync(path.join(packet, 'plan.md'), `# ${feature}\nSpecs-Contract: process-first-ready-v1\n`);
+  fs.writeFileSync(path.join(packet, 'task-01-work.md'), [
+    '# Task 01: work', '', `Status: ${status}`, '', '## Dependencies', '', '- none', '',
+    '## Verification Plan', '', '- Command: node --test', '',
+    ...(status === 'done' ? ['## Receipt', '', 'Verification: PASS', ''] : []),
+  ].join('\n'));
+}
+
+function runInstalledHistoryHook(dir, hook = 'spec-gate', extraEnv = {}) {
+  return spawnSync(process.execPath, [path.join(dir, '.claude/hooks', `${hook}.cjs`)], {
+    cwd: dir, encoding: 'utf8',
+    env: { ...process.env, PROJECT_ROOT: dir, CLAUDE_PROJECT_DIR: dir, ...extraEnv },
+    input: JSON.stringify({ cwd: dir, session_id: 'no-history',
+      hook_event_name: hook === 'spec-state' ? 'UserPromptSubmit' : 'Stop', prompt: 'Continue specs/demo' }),
+  });
+}
+
+test('no commits allows Stop without done tasks and prints one reminder', () => {
+  const dir = noHistoryFixture();
+  try {
+    writeNoHistoryPacket(dir, 'demo', 'in_progress');
+    const gate = runInstalledHistoryHook(dir);
+    assert.strictEqual(gate.status, 0, gate.stderr);
+    assert.strictEqual(gate.stdout.trim(), '');
+    const state = runInstalledHistoryHook(dir, 'spec-state');
+    assert.strictEqual(state.status, 0, state.stderr);
+    assert.match(state.stdout, /no commits/);
+    assert.strictEqual(state.stdout.trim().split('\n').length, 1);
+    assert.doesNotMatch(state.stdout, /Spec tollgate unavailable/);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('no commits blocks a done task with first commit guidance', () => {
+  const dir = noHistoryFixture();
+  try {
+    writeNoHistoryPacket(dir, 'demo', 'done');
+    const result = runInstalledHistoryHook(dir);
+    assert.strictEqual(result.status, 0, result.stderr);
+    const body = parseBlock(result.stdout);
+    assert.strictEqual(body.decision, 'block');
+    assert.match(body.reason, /first commit/);
+    assert.doesNotMatch(body.reason, /controlled failure/);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('no commits blocks two completed packets with first commit guidance', () => {
+  const dir = noHistoryFixture();
+  try {
+    for (const feature of ['demo', 'other']) writeNoHistoryPacket(dir, feature, 'done');
+    const result = runInstalledHistoryHook(dir);
+    assert.strictEqual(result.status, 0, result.stderr);
+    const body = parseBlock(result.stdout);
+    assert.strictEqual(body.decision, 'block');
+    assert.match(body.reason, /first commit/);
+    assert.doesNotMatch(body.reason, /controlled failure/);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('a corrupt current branch ref remains a controlled failure', () => {
+  const dir = tmpDir();
+  try {
+    installClaudeGate(dir);
+    writeNoHistoryPacket(dir, 'demo', 'in_progress');
+    const ref = spawnSync('git', ['-C', dir, 'symbolic-ref', '-q', 'HEAD'], { encoding: 'utf8' });
+    assert.strictEqual(ref.status, 0, ref.stderr);
+    fs.writeFileSync(path.join(dir, '.git', ref.stdout.trim()), 'corrupt-ref\n');
+    const result = runInstalledHistoryHook(dir);
+    assert.strictEqual(result.status, 0, result.stderr);
+    const body = parseBlock(result.stdout);
+    assert.strictEqual(body.decision, 'block');
+    assert.match(body.reason, /controlled failure/);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('unavailable git remains a controlled failure in a repo without commits', () => {
+  const dir = noHistoryFixture();
+  try {
+    writeNoHistoryPacket(dir, 'demo', 'in_progress');
+    const emptyPath = path.join(dir, 'empty-path');
+    fs.mkdirSync(emptyPath);
+    const result = runInstalledHistoryHook(dir, 'spec-gate', { PATH: emptyPath });
+    assert.strictEqual(result.status, 0, result.stderr);
+    const body = parseBlock(result.stdout);
+    assert.strictEqual(body.decision, 'block');
+    assert.match(body.reason, /controlled failure/);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
+test('a committed repo still accepts a valid done task receipt', () => {
+  const dir = makeFixture({ evidence: 'valid' });
+  try {
+    installClaudeGate(dir);
+    const result = runInstalledHistoryHook(dir);
+    assert.strictEqual(result.status, 0, result.stderr);
+    assert.strictEqual(result.stdout.trim(), '');
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});
+
 test('42. a dirty tree outside specs does not reopen a committed receipt', () => {
   // Contract change. This used to require a block. `Base` is the last commit
   // touching anything outside the specs root, so a receipt written before any
@@ -1866,3 +2003,82 @@ test('a packet holding both plan.md and spec.json is read as process-first and i
     fs.rmSync(dir, { recursive: true, force: true });
   }
 });
+
+// Head is sha256 over one JSON line per path with the file bytes as base64. It is now streamed instead of built, and
+// must stay byte-identical: every receipt already written carries a Head computed the old way.
+function referenceHead(dir) {
+  const git = (...args) => spawnSync('git', ['-C', dir, ...args], { encoding: 'buffer' }).stdout;
+  const split = (buffer) => buffer.toString('utf8').split('\0').filter(Boolean);
+  const raw = split(git('status', '--porcelain=v1', '-z', '--untracked-files=all'));
+  const statuses = new Map();
+  for (let index = 0; index < raw.length; index += 1) {
+    const xy = raw[index].slice(0, 2);
+    const first = raw[index].slice(3);
+    if (xy.includes('R') || xy.includes('C')) {
+      const next = raw[++index];
+      statuses.set(first, { xy, role: 'rename-source', counterpart: next });
+      statuses.set(next, { xy, role: 'rename-target', counterpart: first });
+    } else statuses.set(first, { xy, role: xy === '??' || xy === '!!' ? 'untracked' : 'tracked' });
+  }
+  const paths = [...new Set([...split(git('ls-files', '-z', '--cached')), ...split(git('ls-tree', '-r', '-z', '--name-only', 'HEAD')), ...statuses.keys()])]
+    .filter((relative) => !relative.startsWith('specs/') && !PROVENANCE.RUNTIME_STATE_ROOTS.some((root) => relative === root || relative.startsWith(`${root}/`)))
+    .sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+  const hash = crypto.createHash('sha256').update('cafekit-provenance\0');
+  for (const relative of paths) {
+    const absolute = path.join(dir, relative);
+    const status = statuses.get(relative) || null;
+    let stat;
+    try { stat = fs.lstatSync(absolute); } catch {
+      hash.update(`${JSON.stringify({ path: relative, type: 'deleted', mode: '0000', status, content: null })}\n`);
+      continue;
+    }
+    const type = stat.isSymbolicLink() ? 'symlink' : stat.isFile() ? 'file' : 'directory';
+    const content = type === 'symlink' ? Buffer.from(fs.readlinkSync(absolute), 'utf8') : type === 'file' ? fs.readFileSync(absolute) : Buffer.alloc(0);
+    const mode = (stat.mode & 0o7777).toString(8).padStart(4, '0');
+    hash.update(`${JSON.stringify({ path: relative, type, mode, status, content: content.toString('base64') })}\n`);
+  }
+  return hash.digest('hex');
+}
+
+function provenanceFixture() {
+  const dir = fs.realpathSync(tmpDir());
+  fs.mkdirSync(path.join(dir, 'specs', FEATURE), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'specs', FEATURE, 'plan.md'), '# Demo plan\n');
+  return dir;
+}
+
+test('Head is unchanged by streaming: files around the 3 MB chunk edge, symlink, rename, deletion, quoted names', () => {
+  const dir = provenanceFixture();
+  try {
+    const chunk = 3 * 1024 * 1024;
+    for (const size of [0, 1, 2, 4, chunk - 1, chunk, chunk + 1, 2 * chunk + 2]) {
+      fs.writeFileSync(path.join(dir, `bin-${size}.dat`), crypto.randomBytes(size));
+    }
+    fs.writeFileSync(path.join(dir, 'tiếng "việt" \\ name.txt'), 'x');
+    fs.writeFileSync(path.join(dir, 'run.sh'), '#!/bin/sh\n');
+    fs.chmodSync(path.join(dir, 'run.sh'), 0o755);
+    fs.writeFileSync(path.join(dir, 'gone.txt'), 'g');
+    fs.writeFileSync(path.join(dir, 'old-name.txt'), 'r');
+    for (const args of [['add', '-A'], ['commit', '-qm', 'files']]) assert.strictEqual(spawnSync('git', ['-C', dir, ...args]).status, 0);
+    fs.unlinkSync(path.join(dir, 'gone.txt'));
+    assert.strictEqual(spawnSync('git', ['-C', dir, 'mv', 'old-name.txt', 'new-name.txt']).status, 0);
+    fs.symlinkSync('run.sh', path.join(dir, 'link'));
+    fs.writeFileSync(path.join(dir, 'untracked.bin'), crypto.randomBytes(1000));
+    assert.strictEqual(workflowRuntimeContext(dir).head, referenceHead(dir));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('a checkout whose files exceed the longest string V8 can hold still yields a Head', () => {
+  const dir = provenanceFixture();
+  try {
+    // Sparse: 600 MB of zeros on disk costs nothing, but its base64 alone (800M characters) is past V8's string limit.
+    const descriptor = fs.openSync(path.join(dir, 'large-asset.bin'), 'w');
+    fs.ftruncateSync(descriptor, 600 * 1024 * 1024);
+    fs.closeSync(descriptor);
+    assert.match(workflowRuntimeContext(dir).head, /^[0-9a-f]{64}$/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});