@sabaiway/agent-workflow-kit 1.15.1 → 1.15.2

package/tools/fs-safe.test.mjs

@@ -1,346 +0,0 @@
-import { describe, it, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  mkdtempSync, rmSync, mkdirSync, writeFileSync, symlinkSync, readlinkSync, readFileSync, existsSync, lstatSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-  assertContainedRealPath,
-  copyTreeRefresh,
-  linkManaged,
-  removeTreeManaged,
-  unlinkManaged,
-  MANAGED_LINK_CONFLICT,
-} from './fs-safe.mjs';
-
-// All three primitives are SYNC and operate on real tmp dirs here (the symlink behaviours are
-// fiddly enough that real fs is the honest test). The out-of-root case needs no fs at all.
-let dir;
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), 'awf-fs-safe-'));
-});
-afterEach(() => {
-  rmSync(dir, { recursive: true, force: true });
-});
-
-// ── assertContainedRealPath ───────────────────────────────────────────────────
-
-describe('assertContainedRealPath', () => {
-  it('rejects a dest outside the root (no fs needed — the relative check fires first)', () => {
-    assert.throws(() => assertContainedRealPath('/root', '/root/../etc/passwd'), /outside/);
-    assert.throws(() => assertContainedRealPath('/root', '/etc/passwd'), /outside/);
-  });
-
-  it('Issue-004: accepts a contained child literally named "..foo", still rejects a true ".." segment', () => {
-    // rel "..foo" is a real child, NOT a "../" escape — the old `rel.startsWith('..')` wrongly rejected it.
-    assert.doesNotThrow(() => assertContainedRealPath(dir, join(dir, '..foo')));
-    assert.throws(() => assertContainedRealPath(dir, join(dir, '..', 'escape')), /outside/);
-  });
-
-  it('rejects writing INTO a symlinked root', () => {
-    const real = join(dir, 'real');
-    const root = join(dir, 'root');
-    mkdirSync(real);
-    symlinkSync(real, root);
-    assert.throws(() => assertContainedRealPath(root, join(root, 'x')), /symlink/i);
-  });
-
-  it('rejects writing THROUGH a symlinked intermediate component', () => {
-    const root = join(dir, 'root');
-    const elsewhere = join(dir, 'elsewhere');
-    mkdirSync(root);
-    mkdirSync(elsewhere);
-    symlinkSync(elsewhere, join(root, 'sub'));
-    assert.throws(() => assertContainedRealPath(root, join(root, 'sub', 'file')), /symlink/i);
-  });
-
-  it('rejects a symlinked leaf dest', () => {
-    const root = join(dir, 'root');
-    mkdirSync(root);
-    symlinkSync(join(dir, 'target'), join(root, 'leaf'));
-    assert.throws(() => assertContainedRealPath(root, join(root, 'leaf')), /symlink/i);
-  });
-
-  it('accepts a clean dest within the root', () => {
-    const root = join(dir, 'root');
-    mkdirSync(root);
-    assert.doesNotThrow(() => assertContainedRealPath(root, join(root, 'a', 'b', 'c')));
-  });
-
-  it('lstat is injectable (closes the install.mjs injectability gap)', () => {
-    let seen = 0;
-    const lstat = (p) => { seen += 1; return { isSymbolicLink: () => false }; };
-    assert.doesNotThrow(() => assertContainedRealPath('/root', '/root/a/b', { lstat }));
-    assert.ok(seen > 0, 'the injected lstat was used');
-  });
-});
-
-// ── copyTreeRefresh ───────────────────────────────────────────────────────────
-
-describe('copyTreeRefresh', () => {
-  it('overwrites an existing regular file (refresh)', () => {
-    const root = join(dir, 'dest');
-    mkdirSync(root);
-    const src = join(dir, 'src.txt');
-    const dest = join(root, 'f.txt');
-    writeFileSync(src, 'new');
-    writeFileSync(dest, 'old');
-    copyTreeRefresh(src, dest, root);
-    assert.equal(readFileSync(dest, 'utf8'), 'new');
-  });
-
-  it('copies a nested directory tree', () => {
-    const src = join(dir, 'src');
-    const root = join(dir, 'dest');
-    mkdirSync(join(src, 'a'), { recursive: true });
-    writeFileSync(join(src, 'top.txt'), 'T');
-    writeFileSync(join(src, 'a', 'deep.txt'), 'D');
-    mkdirSync(root);
-    copyTreeRefresh(src, join(root, 'src'), root);
-    assert.equal(readFileSync(join(root, 'src', 'top.txt'), 'utf8'), 'T');
-    assert.equal(readFileSync(join(root, 'src', 'a', 'deep.txt'), 'utf8'), 'D');
-  });
-
-  it('skips a symlink whose dest already exists (additive — never replace)', () => {
-    const root = join(dir, 'dest');
-    mkdirSync(root);
-    const linkSrc = join(dir, 'link');
-    symlinkSync(join(dir, 'whatever'), linkSrc); // src IS a symlink
-    const dest = join(root, 'f');
-    writeFileSync(dest, 'keep');
-    copyTreeRefresh(linkSrc, dest, root);
-    assert.equal(readFileSync(dest, 'utf8'), 'keep'); // untouched
-    assert.equal(lstatSync(dest).isSymbolicLink(), false);
-  });
-
-  it('STOPs on a symlinked dest component (never writes through it)', () => {
-    const root = join(dir, 'root');
-    const elsewhere = join(dir, 'elsewhere');
-    mkdirSync(root);
-    mkdirSync(elsewhere);
-    symlinkSync(elsewhere, join(root, 'sub'));
-    const src = join(dir, 's.txt');
-    writeFileSync(src, 'x');
-    assert.throws(() => copyTreeRefresh(src, join(root, 'sub', 'f.txt'), root), /symlink/i);
-    assert.equal(existsSync(join(elsewhere, 'f.txt')), false); // no leak
-  });
-});
-
-// ── linkManaged ───────────────────────────────────────────────────────────────
-
-describe('linkManaged', () => {
-  const makeSrc = () => {
-    const src = join(dir, 'src.sh');
-    writeFileSync(src, '#!/bin/sh\n');
-    return src;
-  };
-
-  it('creates a symlink when the dest is absent', () => {
-    const src = makeSrc();
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    const dest = join(root, 'cmd');
-    const result = linkManaged(src, dest, root);
-    assert.equal(result, 'linked');
-    assert.equal(lstatSync(dest).isSymbolicLink(), true);
-    assert.equal(readlinkSync(dest), src);
-  });
-
-  it('creates the parent bindir if absent (mkdir -p)', () => {
-    const src = makeSrc();
-    const root = join(dir, 'base');
-    mkdirSync(root);
-    const dest = join(root, 'newbin', 'cmd');
-    linkManaged(src, dest, root);
-    assert.equal(readlinkSync(dest), src);
-  });
-
-  it('is idempotent — a second call is a no-op', () => {
-    const src = makeSrc();
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    const dest = join(root, 'cmd');
-    linkManaged(src, dest, root);
-    const again = linkManaged(src, dest, root);
-    assert.equal(again, 'noop');
-    assert.equal(readlinkSync(dest), src);
-  });
-
-  it('STOPs on a non-symlink dest (typed ManagedLinkConflict)', () => {
-    const src = makeSrc();
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    const dest = join(root, 'cmd');
-    writeFileSync(dest, 'someone-elses-file');
-    assert.throws(() => linkManaged(src, dest, root), (err) => err.code === MANAGED_LINK_CONFLICT);
-    assert.equal(readFileSync(dest, 'utf8'), 'someone-elses-file'); // untouched
-  });
-
-  it('STOPs on a foreign symlink (points elsewhere)', () => {
-    const src = makeSrc();
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    const dest = join(root, 'cmd');
-    const foreign = join(dir, 'foreign.sh');
-    writeFileSync(foreign, '#!/bin/sh\n');
-    symlinkSync(foreign, dest);
-    assert.throws(() => linkManaged(src, dest, root), (err) => err.code === MANAGED_LINK_CONFLICT);
-    assert.equal(readlinkSync(dest), foreign); // untouched
-  });
-
-  it('refuses a symlinked source (never links through a symlink)', () => {
-    const realSrc = makeSrc();
-    const linkSrc = join(dir, 'link.sh');
-    symlinkSync(realSrc, linkSrc);
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    assert.throws(() => linkManaged(linkSrc, join(root, 'cmd'), root), /symlink/i);
-  });
-
-  it('refuses a non-regular-file source (e.g. a directory)', () => {
-    const srcDir = join(dir, 'src-dir');
-    mkdirSync(srcDir);
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    assert.throws(() => linkManaged(srcDir, join(root, 'cmd'), root), /regular file/i);
-  });
-});
-
-// ── removeTreeManaged ───────────────────────────────────────────────────────────
-
-describe('removeTreeManaged', () => {
-  it('recursively removes a managed dir tree', () => {
-    const root = join(dir, 'skills');
-    const skill = join(root, 'agent-workflow-kit');
-    mkdirSync(join(skill, 'tools'), { recursive: true });
-    writeFileSync(join(skill, 'SKILL.md'), 'x');
-    writeFileSync(join(skill, 'tools', 'a.mjs'), 'y');
-    const result = removeTreeManaged(skill, root);
-    assert.equal(result, 'removed');
-    assert.equal(existsSync(skill), false);
-    assert.equal(existsSync(root), true); // only the target went, not the parent
-  });
-
-  it('is a no-op when the target is already absent', () => {
-    const root = join(dir, 'skills');
-    mkdirSync(root);
-    assert.equal(removeTreeManaged(join(root, 'gone'), root), 'noop');
-  });
-
-  it('STOPs on a symlinked target (never follows + deletes through it)', () => {
-    const root = join(dir, 'skills');
-    const real = join(dir, 'real-skill');
-    mkdirSync(root);
-    mkdirSync(real);
-    writeFileSync(join(real, 'keep.txt'), 'keep');
-    symlinkSync(real, join(root, 'agent-workflow-kit')); // the skill dir is a symlink
-    assert.throws(() => removeTreeManaged(join(root, 'agent-workflow-kit'), root), /symlink/i);
-    assert.equal(existsSync(join(real, 'keep.txt')), true); // the target it pointed at is untouched
-  });
-
-  it('removes a symlink ENTRY inside the tree without touching what it points at', () => {
-    const root = join(dir, 'skills');
-    const skill = join(root, 'agent-workflow-kit');
-    const outside = join(dir, 'outside');
-    mkdirSync(skill, { recursive: true });
-    mkdirSync(outside);
-    writeFileSync(join(outside, 'precious.txt'), 'precious');
-    symlinkSync(outside, join(skill, 'link-to-outside')); // an internal symlink
-    removeTreeManaged(skill, root);
-    assert.equal(existsSync(skill), false);
-    assert.equal(existsSync(join(outside, 'precious.txt')), true); // never recursed through the link
-  });
-
-  it('refuses a target outside the root', () => {
-    const root = join(dir, 'skills');
-    mkdirSync(root);
-    assert.throws(() => removeTreeManaged(join(dir, 'elsewhere'), root), /outside/);
-  });
-
-  it('rm is injectable (no real deletion when injected)', () => {
-    const root = join(dir, 'skills');
-    const skill = join(root, 'agent-workflow-kit');
-    mkdirSync(skill, { recursive: true });
-    let removed = null;
-    const result = removeTreeManaged(skill, root, { rm: (p) => { removed = p; } });
-    assert.equal(result, 'removed');
-    assert.equal(removed, skill);
-    assert.equal(existsSync(skill), true); // the injected rm did nothing
-  });
-});
-
-// ── unlinkManaged ───────────────────────────────────────────────────────────────
-
-describe('unlinkManaged', () => {
-  const makeSrc = () => {
-    const src = join(dir, 'src.sh');
-    writeFileSync(src, '#!/bin/sh\n');
-    return src;
-  };
-
-  it('unlinks a symlink that points at our source', () => {
-    const src = makeSrc();
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    const dest = join(root, 'cmd');
-    symlinkSync(src, dest);
-    const result = unlinkManaged(dest, src, root);
-    assert.equal(result, 'unlinked');
-    assert.equal(existsSync(dest), false);
-    assert.equal(existsSync(src), true); // the source it pointed at is untouched
-  });
-
-  it('is a no-op when the dest is absent', () => {
-    const src = makeSrc();
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    assert.equal(unlinkManaged(join(root, 'cmd'), src, root), 'noop');
-  });
-
-  it('STOPs on a non-symlink dest (typed ManagedLinkConflict)', () => {
-    const src = makeSrc();
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    const dest = join(root, 'cmd');
-    writeFileSync(dest, 'someone-elses-file');
-    assert.throws(() => unlinkManaged(dest, src, root), (err) => err.code === MANAGED_LINK_CONFLICT);
-    assert.equal(readFileSync(dest, 'utf8'), 'someone-elses-file'); // untouched
-  });
-
-  it('STOPs on a foreign symlink (points elsewhere)', () => {
-    const src = makeSrc();
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    const dest = join(root, 'cmd');
-    const foreign = join(dir, 'foreign.sh');
-    writeFileSync(foreign, '#!/bin/sh\n');
-    symlinkSync(foreign, dest);
-    assert.throws(() => unlinkManaged(dest, src, root), (err) => err.code === MANAGED_LINK_CONFLICT);
-    assert.equal(readlinkSync(dest), foreign); // untouched
-  });
-
-  it('removes a dangling symlink that still textually points at our source', () => {
-    const src = join(dir, 'src.sh'); // never created → the link is dangling
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    const dest = join(root, 'cmd');
-    symlinkSync(src, dest);
-    assert.equal(unlinkManaged(dest, src, root), 'unlinked');
-    assert.equal(lstatSync(root).isDirectory(), true);
-    assert.equal(existsSync(dest), false);
-  });
-
-  it('unlink is injectable', () => {
-    const src = makeSrc();
-    const root = join(dir, 'bin');
-    mkdirSync(root);
-    const dest = join(root, 'cmd');
-    symlinkSync(src, dest);
-    let unlinked = null;
-    const result = unlinkManaged(dest, src, root, { unlink: (p) => { unlinked = p; } });
-    assert.equal(result, 'unlinked');
-    assert.equal(unlinked, dest);
-    assert.equal(existsSync(dest), true); // the injected unlink did nothing
-  });
-});

package/tools/hide-footprint.integration.test.mjs

@@ -1,168 +0,0 @@
-// Integration acceptance for hide-footprint against a REAL `git` — what injected-git mocks cannot
-// prove: real `git rev-parse --git-path info/exclude` (incl. a linked worktree), real precedence
-// (tracked .gitignore > .git/info/exclude > global core.excludesFile), and the delegated-memory
-// hand-off (fresh + stale). Every test ISOLATES the git environment (per-test HOME + GIT_CONFIG_GLOBAL
-// + GIT_CONFIG_NOSYSTEM) so the host's real ~/.gitignore_global — which already hides /AGENTS.md,
-// /docs/ai/ — cannot make a real check-ignore pass/fail for host-state reasons (Review fold R2 codex#8).
-
-import { describe, it, before, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync, readFileSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { hideFootprint, excludePath, START_MARKER } from './hide-footprint.mjs';
-
-let gitOk = true;
-before(() => {
-  try { execFileSync('git', ['--version'], { encoding: 'utf8' }); } catch { gitOk = false; }
-});
-
-const made = [];
-const mkdtemp = (tag) => { const d = mkdtempSync(join(tmpdir(), tag)); made.push(d); return d; };
-afterEach(() => { while (made.length) { try { rmSync(made.pop(), { recursive: true, force: true }); } catch { /* best effort */ } } });
-
-// An isolated repo: empty global config (no host excludesFile), committer identity in env.
-const setup = () => {
-  const home = mkdtemp('aw-home-');
-  const dir = mkdtemp('aw-repo-');
-  const gcfg = join(home, '.gitconfig');
-  writeFileSync(gcfg, '');
-  const env = {
-    ...process.env, HOME: home, GIT_CONFIG_GLOBAL: gcfg, GIT_CONFIG_NOSYSTEM: '1',
-    GIT_AUTHOR_NAME: 'T', GIT_AUTHOR_EMAIL: 't@e', GIT_COMMITTER_NAME: 'T', GIT_COMMITTER_EMAIL: 't@e',
-  };
-  const git = (args, cwd = dir) => execFileSync('git', args, { cwd, env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
-  git(['init', '-q', '-b', 'main']);
-  return { home, dir, gcfg, env, git, deps: { env, home } };
-};
-const readExclude = (dir) => { const p = join(dir, '.git/info/exclude'); return existsSync(p) ? readFileSync(p, 'utf8') : ''; };
-const count = (s, sub) => s.split(sub).length - 1;
-const checkIgnoreSource = (git, dir, probe) => {
-  try { return git(['check-ignore', '-v', '--', probe], dir).split('\t')[0]; } catch { return null; }
-};
-
-describe('hide-footprint integration (real git)', { skip: !gitOk }, () => {
-  let env;
-  beforeEach(() => { env = setup(); });
-
-  it('resolves info/exclude, writes ONE managed block, and real check-ignore reports it', () => {
-    const { dir, git, deps } = env;
-    writeFileSync(join(dir, 'AGENTS.md'), '# entry\n');
-    const ep = excludePath(deps, dir);
-    assert.ok(ep.endsWith('.git/info/exclude'));
-    const r = hideFootprint({ dir }, deps);
-    assert.equal(r.action, 'created');
-    const content = readExclude(dir);
-    assert.equal(count(content, START_MARKER), 1, 'exactly one managed block');
-    assert.match(checkIgnoreSource(git, dir, 'AGENTS.md') ?? '', /info\/exclude/);
-    // Idempotent: a second run changes nothing.
-    const r2 = hideFootprint({ dir }, deps);
-    assert.equal(r2.action, 'noop');
-    assert.equal(readExclude(dir), content);
-  });
-
-  it('works inside a linked git worktree', () => {
-    const { dir, git, deps, env: e } = env;
-    git(['commit', '-q', '--allow-empty', '-m', 'init']);
-    const wt = mkdtemp('aw-wt-');
-    rmSync(wt, { recursive: true, force: true }); // git worktree add wants a non-existent path
-    git(['worktree', 'add', '-q', wt]);
-    writeFileSync(join(wt, 'AGENTS.md'), '# entry\n');
-    const r = hideFootprint({ dir: wt }, deps);
-    assert.equal(r.visibility, 'hidden');
-    assert.equal(count(r.wrote.join('\n'), '/AGENTS.md'), 1);
-    assert.match(checkIgnoreSource((a, c) => execFileSync('git', a, { cwd: c, env: e, encoding: 'utf8' }), wt, 'AGENTS.md') ?? '', /exclude/);
-  });
-
-  it('precedence: a path in a TRACKED .gitignore is dropped (redundant), reported by .gitignore', () => {
-    const { dir, git, deps } = env;
-    writeFileSync(join(dir, '.gitignore'), '/docs/ai/\n');
-    git(['add', '.gitignore']);
-    const r = hideFootprint({ dir }, deps);
-    assert.ok(r.dropped.includes('/docs/ai/'), 'covered by tracked .gitignore → dropped');
-    assert.ok(!r.wrote.includes('/docs/ai/'));
-    assert.match(checkIgnoreSource(git, dir, 'docs/ai/') ?? '', /\.gitignore/);
-  });
-
-  it('precedence: a path in BOTH global excludes and the local block is reported by the LOCAL block', () => {
-    const { dir, git, deps } = env;
-    const globalExcludes = join(env.home, 'gitignore_global');
-    writeFileSync(globalExcludes, '/AGENTS.md\n');
-    git(['config', 'core.excludesFile', globalExcludes]);
-    writeFileSync(join(dir, 'AGENTS.md'), '# entry\n');
-    const r = hideFootprint({ dir }, deps); // default keeps the global block
-    assert.ok(r.wrote.includes('/AGENTS.md'));
-    assert.match(checkIgnoreSource(git, dir, 'AGENTS.md') ?? '', /info\/exclude/, 'local exclude wins precedence');
-    assert.equal(r.global.action, 'kept');
-  });
-
-  it('a machine-global core.excludesFile NAMED .gitignore is not mistaken for a project .gitignore (no spurious STOP)', () => {
-    const { dir, git, deps } = env;
-    const globalGitignore = join(env.home, '.gitignore'); // basename collides with a project .gitignore
-    writeFileSync(globalGitignore, '/AGENTS.md\n');
-    git(['config', 'core.excludesFile', globalGitignore]);
-    writeFileSync(join(dir, 'AGENTS.md'), '# entry\n');
-    const r = hideFootprint({ dir }, deps); // must not STOP probing an outside-repo path
-    assert.ok(r.wrote.includes('/AGENTS.md'), 'AGENTS.md hidden project-local, not dropped as a "tracked .gitignore"');
-    assert.match(checkIgnoreSource(git, dir, 'AGENTS.md') ?? '', /info\/exclude/);
-  });
-
-  it('delegated-hidden, FRESH memory: bare project-local lines are absorbed into ONE canonical fence', () => {
-    const { dir, deps } = env;
-    // What a 1.1.0 memory writes project-local (bare, no fence):
-    writeFileSync(join(dir, '.git/info/exclude'), '/AGENTS.md\n/CLAUDE.md\n/docs/ai/\n');
-    const r = hideFootprint({ dir }, deps);
-    const content = readExclude(dir);
-    assert.equal(count(content, START_MARKER), 1, 'one fence');
-    assert.equal(count(content, '/AGENTS.md\n'), 1, 'no duplicate AGENTS.md rule');
-    // the bare lines are now INSIDE the fence, not loose above it.
-    assert.ok(content.indexOf('/AGENTS.md') > content.indexOf(START_MARKER));
-    assert.ok(r.wrote.includes('/AGENTS.md') && r.wrote.includes('/docs/ai/'));
-  });
-
-  it('delegated-hidden, STALE memory: a memory-old GLOBAL block is migrated away with --remove-global', () => {
-    const { dir, git, deps } = env;
-    const globalExcludes = join(env.home, 'gitignore_global');
-    writeFileSync(globalExcludes, '# agent-workflow-kit hidden mode (machine-local; remove these lines to un-hide)\n/AGENTS.md\n/docs/ai/\n/docs/ai/.memory-version\n');
-    git(['config', 'core.excludesFile', globalExcludes]);
-    writeFileSync(join(dir, 'AGENTS.md'), '# entry\n');
-    const r = hideFootprint({ dir, removeGlobal: true }, deps);
-    assert.equal(r.global.action, 'removed');
-    assert.ok(!readFileSync(globalExcludes, 'utf8').includes('/AGENTS.md'), 'global block removed');
-    assert.match(checkIgnoreSource(git, dir, 'AGENTS.md') ?? '', /info\/exclude/, 'now hidden project-local');
-  });
-
-  describe('visibility inference (D16)', () => {
-    it('tracked anchor → VISIBLE → --reconcile writes zero bytes', () => {
-      const { dir, git, deps } = env;
-      writeFileSync(join(dir, 'AGENTS.md'), '# entry\n');
-      git(['add', 'AGENTS.md']);
-      const before = readExclude(dir);
-      const r = hideFootprint({ dir, reconcile: true }, deps);
-      assert.equal(r.visibility, 'visible');
-      assert.equal(readExclude(dir), before, 'no bytes written in visible mode');
-    });
-
-    it('untracked + ignored anchor → HIDDEN → --reconcile runs the hide', () => {
-      const { dir, git, deps } = env;
-      const globalExcludes = join(env.home, 'gitignore_global');
-      writeFileSync(globalExcludes, '/AGENTS.md\n');
-      git(['config', 'core.excludesFile', globalExcludes]);
-      writeFileSync(join(dir, 'AGENTS.md'), '# entry\n');
-      const r = hideFootprint({ dir, reconcile: true }, deps);
-      assert.equal(r.visibility, 'hidden');
-      assert.ok(r.wrote.includes('/AGENTS.md'));
-    });
-
-    it('untracked + not ignored anchor → AMBIGUOUS → --reconcile surfaces it, writes nothing', () => {
-      const { dir, deps } = env;
-      writeFileSync(join(dir, 'AGENTS.md'), '# entry\n');
-      const before = readExclude(dir);
-      const r = hideFootprint({ dir, reconcile: true }, deps);
-      assert.equal(r.ambiguous, true);
-      assert.equal(r.visibility, 'ambiguous');
-      assert.equal(readExclude(dir), before, 'ambiguous → no write, agent ASKs');
-    });
-  });
-});