harness-everything 0.2.2 → 0.4.0

package/ci/mechanism-2p-installer-links.test.js

@@ -0,0 +1,183 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const helper = require('./test-helper');
+
+console.log('\n[2p] Canonical-store link/copy install + link-aware uninstall (issue #49)...');
+
+const skills = require('../scripts/lib/skills');
+const manifest = require('../scripts/lib/manifest');
+
+const harnessSourceDir = path.resolve(__dirname, '..');
+const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2p-ws-'));
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2p-home-'));
+
+function target(name, dirName) {
+  const home_ = path.join(ws, dirName);
+  return { path: path.join(home_, 'skills'), label: `${dirName}/skills/`, manifestPath: manifest.getManifestPath(home_) };
+}
+
+// --- 1. Link mode: two targets sharing one canonical copy ---
+const claudeTarget = target('claude', '.claude');
+const cursorTarget = target('cursor', '.cursor');
+const canonicalDir = skills.getCanonicalSkillsDir({ isGlobal: false, workspaceRoot: ws, userHome: home });
+
+skills.installSkillsToTargets({
+  chosenSkills: ['tdd'],
+  targetDirs: [claudeTarget, cursorTarget],
+  harnessSourceDir,
+  packageVersion: '9.9.9',
+  canonicalDir,
+  linkMode: 'auto',
+});
+
+const claudeSkillDir = path.join(claudeTarget.path, 'tdd');
+const cursorSkillDir = path.join(cursorTarget.path, 'tdd');
+const canonicalSkillDir = path.join(canonicalDir, 'tdd');
+
+helper.check(
+  '2p. both platform targets are real links (symlink/junction), not physical copies',
+  skills.isLinkPath(claudeSkillDir) && skills.isLinkPath(cursorSkillDir),
+  `claude isLink=${skills.isLinkPath(claudeSkillDir)} cursor isLink=${skills.isLinkPath(cursorSkillDir)}`
+);
+helper.check(
+  '2p. the canonical copy itself is a physical directory, not a link',
+  fs.existsSync(canonicalSkillDir) && !skills.isLinkPath(canonicalSkillDir),
+  `canonical exists=${fs.existsSync(canonicalSkillDir)} isLink=${skills.isLinkPath(canonicalSkillDir)}`
+);
+helper.check(
+  '2p. content is readable through the link and matches source',
+  fs.existsSync(path.join(claudeSkillDir, 'SKILL.md')) &&
+    fs.readFileSync(path.join(claudeSkillDir, 'SKILL.md'), 'utf8') === fs.readFileSync(path.join(harnessSourceDir, 'tdd', 'SKILL.md'), 'utf8'),
+  'linked SKILL.md content did not match source'
+);
+
+const claudeManifestEntry = manifest.readManifest(claudeTarget.manifestPath).skills[0];
+helper.check(
+  '2p. manifest records kind + canonicalPath for a linked entry',
+  claudeManifestEntry && ['symlink', 'junction'].includes(claudeManifestEntry.kind) && claudeManifestEntry.canonicalPath === canonicalSkillDir,
+  `Got: ${JSON.stringify(claudeManifestEntry)}`
+);
+
+// --- 2. getInstalledSkills surfaces both links, and the canonical dir is
+// NOT double-listed as its own separate skill (advisor-flagged legacy-scan
+// collision fix). ---
+{
+  const installed = skills.getInstalledSkills(ws, home);
+  const tddEntries = installed.filter(s => s.id === 'tdd');
+  helper.check(
+    '2p. getInstalledSkills lists exactly the 2 linked entries, not the canonical dir as a 3rd',
+    tddEntries.length === 2,
+    `Got ${tddEntries.length}: ${JSON.stringify(tddEntries.map(e => e.dirPath))}`
+  );
+}
+
+// --- 3. Removing one link leaves the canonical copy (still referenced by
+// the other link) intact; removing the last link removes it too. ---
+{
+  const installedBefore = skills.getInstalledSkills(ws, home);
+  const claudeEntry = installedBefore.find(s => s.dirPath === claudeSkillDir);
+  skills.removeSkill(claudeEntry, { workspaceRoot: ws, userHome: home });
+
+  helper.check(
+    '2p. removing one link deletes only that link, canonical copy survives (still referenced)',
+    !fs.existsSync(claudeSkillDir) && fs.existsSync(canonicalSkillDir),
+    `claude exists=${fs.existsSync(claudeSkillDir)} canonical exists=${fs.existsSync(canonicalSkillDir)}`
+  );
+
+  const installedAfterFirst = skills.getInstalledSkills(ws, home);
+  const cursorEntry = installedAfterFirst.find(s => s.dirPath === cursorSkillDir);
+  skills.removeSkill(cursorEntry, { workspaceRoot: ws, userHome: home });
+
+  helper.check(
+    '2p. removing the LAST link also removes the now-orphaned canonical copy',
+    !fs.existsSync(cursorSkillDir) && !fs.existsSync(canonicalSkillDir),
+    `cursor exists=${fs.existsSync(cursorSkillDir)} canonical exists=${fs.existsSync(canonicalSkillDir)}`
+  );
+}
+
+// --- 4. --copy mode produces independent physical copies, no canonical
+// store, no links at all. ---
+{
+  const copyTarget = target('codex', '.codex');
+  skills.installSkillsToTargets({
+    chosenSkills: ['tdd'],
+    targetDirs: [copyTarget],
+    harnessSourceDir,
+    packageVersion: '9.9.9',
+    canonicalDir: skills.getCanonicalSkillsDir({ isGlobal: false, workspaceRoot: ws, userHome: home }),
+    linkMode: 'copy',
+  });
+  const copySkillDir = path.join(copyTarget.path, 'tdd');
+  helper.check(
+    '2p. --copy mode installs a physical directory, not a link',
+    fs.existsSync(copySkillDir) && !skills.isLinkPath(copySkillDir),
+    `exists=${fs.existsSync(copySkillDir)} isLink=${skills.isLinkPath(copySkillDir)}`
+  );
+  const entry = manifest.readManifest(copyTarget.manifestPath).skills[0];
+  helper.check(
+    '2p. --copy mode manifest entry has no kind/canonicalPath',
+    entry && !entry.kind && !entry.canonicalPath,
+    `Got: ${JSON.stringify(entry)}`
+  );
+  const installedEntry = skills.getInstalledSkills(ws, home).find(s => s.dirPath === copySkillDir);
+  skills.removeSkill(installedEntry, { workspaceRoot: ws, userHome: home });
+  helper.check('2p. --copy mode entry uninstalls cleanly', !fs.existsSync(copySkillDir), 'copy-mode dir still exists after removeSkill');
+}
+
+// --- 5. Dangling link (canonical target manually deleted) is still
+// detected and cleaned up rather than silently ignored. ---
+{
+  const danglingTarget = target('continue', '.continue');
+  skills.installSkillsToTargets({
+    chosenSkills: ['tdd'],
+    targetDirs: [danglingTarget],
+    harnessSourceDir,
+    packageVersion: '9.9.9',
+    canonicalDir: skills.getCanonicalSkillsDir({ isGlobal: false, workspaceRoot: ws, userHome: home }),
+    linkMode: 'symlink',
+  });
+  const linkDir = path.join(danglingTarget.path, 'tdd');
+  const canonicalTddDir = path.join(skills.getCanonicalSkillsDir({ isGlobal: false, workspaceRoot: ws, userHome: home }), 'tdd');
+  fs.rmSync(canonicalTddDir, { recursive: true, force: true }); // simulate manual/out-of-band deletion
+
+  helper.check(
+    '2p. a dangling link is still detected as present (pathPresent) even though its target is gone',
+    skills.pathPresent(linkDir) && !fs.existsSync(linkDir),
+    `pathPresent=${skills.pathPresent(linkDir)} existsSync=${fs.existsSync(linkDir)}`
+  );
+
+  const installed = skills.getInstalledSkills(ws, home);
+  const danglingEntry = installed.find(s => s.dirPath === linkDir);
+  helper.check('2p. getInstalledSkills still surfaces the dangling link for cleanup', !!danglingEntry, 'dangling link entry missing from getInstalledSkills');
+  if (danglingEntry) {
+    skills.removeSkill(danglingEntry, { workspaceRoot: ws, userHome: home });
+    helper.check(
+      '2p. removeSkill cleans up the dangling link and its manifest row',
+      !skills.isLinkPath(linkDir) && manifest.readManifest(danglingTarget.manifestPath).skills.length === 0,
+      `isLink=${skills.isLinkPath(linkDir)} manifest=${JSON.stringify(manifest.readManifest(danglingTarget.manifestPath))}`
+    );
+  }
+}
+
+// --- 6. A legacy manifest entry with no canonicalPath (pre-#49 install)
+// still uninstalls exactly as before - no forced migration required. ---
+{
+  const legacyTarget = target('copilot', '.github');
+  fs.mkdirSync(legacyTarget.path, { recursive: true });
+  const legacyDir = path.join(legacyTarget.path, 'tdd');
+  skills.copyDir(path.join(harnessSourceDir, 'tdd'), legacyDir);
+  manifest.recordSkillInstall(legacyTarget.manifestPath, '0.3.0', 'tdd', legacyDir); // no linkInfo - pre-#49 shape
+
+  const entry = skills.getInstalledSkills(ws, home).find(s => s.dirPath === legacyDir);
+  helper.check('2p. a pre-#49 manifest entry (no kind/canonicalPath) is still discovered', !!entry, 'legacy entry not found');
+  if (entry) {
+    skills.removeSkill(entry, { workspaceRoot: ws, userHome: home });
+    helper.check('2p. a pre-#49 entry uninstalls cleanly with no canonical-store side effects', !fs.existsSync(legacyDir), 'legacy dir still exists');
+  }
+}
+
+fs.rmSync(ws, { recursive: true, force: true });
+fs.rmSync(home, { recursive: true, force: true });
+
+helper.finish();

package/ci/mechanism-2q-installer-global-shared-store.test.js

@@ -0,0 +1,132 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const helper = require('./test-helper');
+
+console.log('\n[2q] Global scope: canonical store reuses the pre-existing shared ~/.agents/skills (issue #49)...');
+
+const skills = require('../scripts/lib/skills');
+const manifest = require('../scripts/lib/manifest');
+
+const harnessSourceDir = path.resolve(__dirname, '..');
+
+const installerHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2q-installer-home-'));
+const installerCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2q-installer-cwd-'));
+const installerResult = spawnSync(
+  process.execPath,
+  [path.join(harnessSourceDir, 'scripts', 'installer.js'), 'install', '--global', '--yes', '--no-skills', '--claude'],
+  {
+    cwd: installerCwd,
+    env: { ...process.env, HOME: installerHome, USERPROFILE: installerHome, APPDATA: path.join(installerHome, 'AppData', 'Roaming') },
+    encoding: 'utf8'
+  }
+);
+helper.check(
+  '2q. global installer works from a non-git directory',
+  installerResult.status === 0 && fs.existsSync(path.join(installerHome, '.claude', 'settings.json')),
+  `status=${installerResult.status} stdout=${installerResult.stdout} stderr=${installerResult.stderr}`
+);
+fs.rmSync(installerHome, { recursive: true, force: true });
+fs.rmSync(installerCwd, { recursive: true, force: true });
+
+const home = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2q-home-'));
+const ws = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2q-ws-'));
+
+// Mirrors what cursor.js/codex.js/continue.js/copilot.js/hermes.js's
+// getSkillsTarget({isGlobal:true}) all independently return today: the SAME
+// path + SAME manifest, deduped in installer.js's main() into one targetDirs
+// entry before installSkillsToTargets ever runs.
+const globalAgentsDir = path.join(home, '.agents');
+const sharedTarget = {
+  path: path.join(globalAgentsDir, 'skills'),
+  label: '~/.agents/skills/',
+  manifestPath: manifest.getManifestPath(globalAgentsDir),
+};
+// claude.js's global target is separate: ~/.claude/skills/.
+const claudeGlobalTarget = {
+  path: path.join(home, '.claude', 'skills'),
+  label: '~/.claude/skills/',
+  manifestPath: manifest.getManifestPath(path.join(home, '.claude')),
+};
+
+const canonicalDir = skills.getCanonicalSkillsDir({ isGlobal: true, workspaceRoot: ws, userHome: home });
+helper.check(
+  '2q. global canonical dir IS the pre-existing shared ~/.agents/skills path, not a new location',
+  canonicalDir === sharedTarget.path,
+  `canonicalDir=${canonicalDir} sharedTarget.path=${sharedTarget.path}`
+);
+
+skills.installSkillsToTargets({
+  chosenSkills: ['tdd'],
+  targetDirs: [sharedTarget, claudeGlobalTarget],
+  harnessSourceDir,
+  packageVersion: '9.9.9',
+  canonicalDir,
+  linkMode: 'auto',
+});
+
+const sharedSkillDir = path.join(sharedTarget.path, 'tdd');
+const claudeSkillDir = path.join(claudeGlobalTarget.path, 'tdd');
+
+helper.check(
+  '2q. the shared target (cursor/codex/continue/copilot/hermes stand-in) gets the PHYSICAL copy, not a link to itself',
+  fs.existsSync(sharedSkillDir) && !skills.isLinkPath(sharedSkillDir),
+  `exists=${fs.existsSync(sharedSkillDir)} isLink=${skills.isLinkPath(sharedSkillDir)}`
+);
+helper.check(
+  "2q. Claude's separate global target links into the shared store instead of duplicating it",
+  skills.isLinkPath(claudeSkillDir),
+  `isLink=${skills.isLinkPath(claudeSkillDir)}`
+);
+
+const sharedManifestEntry = manifest.readManifest(sharedTarget.manifestPath).skills.find(s => s.id === 'tdd');
+helper.check(
+  '2q. the shared-store manifest entry records a plain copy (no kind/canonicalPath)',
+  sharedManifestEntry && !sharedManifestEntry.kind && !sharedManifestEntry.canonicalPath,
+  `Got: ${JSON.stringify(sharedManifestEntry)}`
+);
+
+// --- Removing Claude's link must NOT delete the shared store: 5 other
+// platforms still depend on it directly (their own manifest row IS that
+// path), even though nothing else "links" to it. ---
+{
+  const installed = skills.getInstalledSkills(ws, home);
+  const claudeEntry = installed.find(s => s.dirPath === claudeSkillDir);
+  skills.removeSkill(claudeEntry, { workspaceRoot: ws, userHome: home });
+
+  helper.check(
+    "2q. removing Claude's link leaves the shared store intact (still independently in use)",
+    !fs.existsSync(claudeSkillDir) && fs.existsSync(sharedSkillDir),
+    `claude exists=${fs.existsSync(claudeSkillDir)} shared exists=${fs.existsSync(sharedSkillDir)}`
+  );
+}
+
+// --- Removing the shared store directly must also clean up any dependent
+// link (symmetric case - re-link Claude first to set this up). ---
+{
+  skills.installSkillsToTargets({
+    chosenSkills: ['tdd'],
+    targetDirs: [claudeGlobalTarget],
+    harnessSourceDir,
+    packageVersion: '9.9.9',
+    canonicalDir,
+    linkMode: 'auto',
+  });
+  helper.check('2q. (setup) Claude re-linked to the shared store', skills.isLinkPath(claudeSkillDir), 'relink failed');
+
+  const installed = skills.getInstalledSkills(ws, home);
+  const sharedEntry = installed.find(s => s.dirPath === sharedSkillDir);
+  skills.removeSkill(sharedEntry, { workspaceRoot: ws, userHome: home });
+
+  helper.check(
+    "2q. removing the shared store directly also sweeps Claude's now-dangling dependent link",
+    !fs.existsSync(sharedSkillDir) && !skills.isLinkPath(claudeSkillDir) && !fs.existsSync(claudeSkillDir),
+    `shared exists=${fs.existsSync(sharedSkillDir)} claude isLink=${skills.isLinkPath(claudeSkillDir)} claude exists=${fs.existsSync(claudeSkillDir)}`
+  );
+}
+
+fs.rmSync(home, { recursive: true, force: true });
+fs.rmSync(ws, { recursive: true, force: true });
+
+helper.finish();

package/ci/mechanism-2r-uninstall-flags.test.js

@@ -0,0 +1,148 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const helper = require('./test-helper');
+
+console.log('\n[2r] Uninstall CLI flag handling: no silent no-op, combined local+global (issue #48)...');
+
+const repoRoot = path.resolve(__dirname, '..');
+const installerPath = path.join(repoRoot, 'scripts', 'installer.js');
+
+function freshWorkspace(prefix) {
+  const ws = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  fs.mkdirSync(path.join(ws, '.git')); // pins getWorkspaceRoot() deterministically
+  return ws;
+}
+
+function run(cwd, args, env) {
+  // spawnSync with stdio 'pipe' has no attached TTY - process.stdin.isTTY is
+  // undefined, exactly like a piped/non-interactive invocation (npx in CI,
+  // some shells, etc.) - the scenario issue #48 is about.
+  return spawnSync(process.execPath, [installerPath, ...args], { cwd, env, encoding: 'utf8' });
+}
+
+function seedLocalInstall(ws, skillId) {
+  fs.mkdirSync(path.join(ws, '.claude'), { recursive: true });
+  fs.writeFileSync(path.join(ws, '.claude', 'settings.json'), '{}', 'utf8');
+  if (skillId) {
+    const skillDir = path.join(ws, '.claude', 'skills', skillId);
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '---\nname: x\nauthor: Miya Daniel\n---\n', 'utf8');
+    const manifest = require('../scripts/lib/manifest');
+    manifest.recordSkillInstall(manifest.getManifestPath(path.join(ws, '.claude')), require('../package.json').version, skillId, skillDir);
+  }
+}
+
+function seedGlobalInstall(fakeHome, skillId) {
+  fs.mkdirSync(path.join(fakeHome, '.claude'), { recursive: true });
+  fs.writeFileSync(path.join(fakeHome, '.claude', 'settings.json'), '{}', 'utf8');
+  if (skillId) {
+    const skillDir = path.join(fakeHome, '.claude', 'skills', skillId);
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, 'SKILL.md'), '---\nname: x\nauthor: Miya Daniel\n---\n', 'utf8');
+    const manifest = require('../scripts/lib/manifest');
+    manifest.recordSkillInstall(manifest.getManifestPath(path.join(fakeHome, '.claude')), require('../package.json').version, skillId, skillDir);
+  }
+}
+
+// --- 1. Bare `uninstall`, no flags, no TTY: must fail loudly, not silently
+// claim success while removing nothing. ---
+{
+  const ws = freshWorkspace('harness-2r-noop-');
+  const fakeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2r-noop-home-'));
+  seedLocalInstall(ws, 'dummy-skill');
+  const env = { ...process.env, HOME: fakeHome, USERPROFILE: fakeHome };
+
+  const res = run(ws, ['uninstall'], env);
+
+  helper.check('2r. bare uninstall with no TTY exits non-zero instead of silently succeeding', res.status !== 0, `status=${res.status} stdout=${res.stdout} stderr=${res.stderr}`);
+  helper.check('2r. ...and prints a hint about the flags to pass', /--local|--skills|--global/.test(res.stderr), `stderr=${res.stderr}`);
+  helper.check(
+    '2r. ...and actually removed nothing (settings.json + skill both still present)',
+    fs.existsSync(path.join(ws, '.claude', 'settings.json')) && fs.existsSync(path.join(ws, '.claude', 'skills', 'dummy-skill')),
+    'local install was modified despite no flags being passed'
+  );
+
+  fs.rmSync(ws, { recursive: true, force: true });
+  fs.rmSync(fakeHome, { recursive: true, force: true });
+}
+
+// --- 2. `uninstall --local --skills` (no -y): removes exactly local config +
+// local skills, in one non-interactive run, no menu. ---
+{
+  const ws = freshWorkspace('harness-2r-local-');
+  const fakeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2r-local-home-'));
+  seedLocalInstall(ws, 'dummy-skill');
+  const env = { ...process.env, HOME: fakeHome, USERPROFILE: fakeHome };
+
+  const res = run(ws, ['uninstall', '--local', '--skills'], env);
+
+  helper.check('2r. `uninstall --local --skills` exits 0', res.status === 0, `status=${res.status} stdout=${res.stdout} stderr=${res.stderr}`);
+  helper.check(
+    '2r. ...and actually removed the local skill',
+    !fs.existsSync(path.join(ws, '.claude', 'skills', 'dummy-skill')),
+    `skill dir still exists, stdout=${res.stdout}`
+  );
+
+  fs.rmSync(ws, { recursive: true, force: true });
+  fs.rmSync(fakeHome, { recursive: true, force: true });
+}
+
+// --- 3. `uninstall --local --global --skills` in ONE run removes both
+// scopes together (issue #48 point 3) - no need for two separate invocations. ---
+{
+  const ws = freshWorkspace('harness-2r-both-');
+  const fakeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2r-both-home-'));
+  seedLocalInstall(ws, 'local-skill');
+  seedGlobalInstall(fakeHome, 'global-skill');
+  const env = { ...process.env, HOME: fakeHome, USERPROFILE: fakeHome };
+
+  const res = run(ws, ['uninstall', '--local', '--global', '--skills'], env);
+
+  helper.check('2r. `uninstall --local --global --skills` exits 0', res.status === 0, `status=${res.status} stdout=${res.stdout} stderr=${res.stderr}`);
+  helper.check(
+    '2r. ...local skill removed',
+    !fs.existsSync(path.join(ws, '.claude', 'skills', 'local-skill')),
+    `local skill still exists, stdout=${res.stdout}`
+  );
+  helper.check(
+    '2r. ...AND global skill removed in the SAME run',
+    !fs.existsSync(path.join(fakeHome, '.claude', 'skills', 'global-skill')),
+    `global skill still exists, stdout=${res.stdout}`
+  );
+
+  fs.rmSync(ws, { recursive: true, force: true });
+  fs.rmSync(fakeHome, { recursive: true, force: true });
+}
+
+// --- 4. Point 2 regression: a second bare `uninstall --local` after a first
+// run that intentionally left skills in place still finds and can remove
+// them (was previously masked by the same no-op bug as scenario 1). ---
+{
+  const ws = freshWorkspace('harness-2r-second-run-');
+  const fakeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2r-second-run-home-'));
+  seedLocalInstall(ws, 'dummy-skill');
+  const env = { ...process.env, HOME: fakeHome, USERPROFILE: fakeHome };
+
+  const first = run(ws, ['uninstall', '--local'], env); // config only, skills intentionally kept
+  helper.check('2r. first run (--local only) exits 0', first.status === 0, `status=${first.status} stdout=${first.stdout}`);
+  helper.check(
+    '2r. ...and leaves the skill in place as requested',
+    fs.existsSync(path.join(ws, '.claude', 'skills', 'dummy-skill')),
+    'skill was removed even though --skills was not passed'
+  );
+
+  const second = run(ws, ['uninstall', '--skills'], env);
+  helper.check('2r. second run (--skills) exits 0', second.status === 0, `status=${second.status} stdout=${second.stdout} stderr=${second.stderr}`);
+  helper.check(
+    '2r. ...and this time removes the skill left over from the first run',
+    !fs.existsSync(path.join(ws, '.claude', 'skills', 'dummy-skill')),
+    `skill still exists after second run, stdout=${second.stdout}`
+  );
+
+  fs.rmSync(ws, { recursive: true, force: true });
+  fs.rmSync(fakeHome, { recursive: true, force: true });
+}
+
+helper.finish();

package/ci/mechanism-2s-tdd-quality.test.js

@@ -0,0 +1,203 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const helper = require('./test-helper');
+const { evaluateEvidence } = require('../tdd/scripts/quality-gate');
+
+console.log('\n[2s] TDD quality evidence gate (issue #58)...');
+
+const classes = {
+  inputCompleteness: ['required', 'optional', 'omitted', 'empty', 'null', 'min', 'max', 'boundary'],
+  outputCompleteness: ['value', 'type', 'schema', 'required-field', 'prohibited-extra-field', 'side-effect'],
+  errorHandling: ['error-type', 'error-code', 'message', 'state-cleanup', 'rollback', 'no-unintended-output'],
+  unexpectedInput: ['malformed', 'unknown', 'extra', 'unsupported', 'out-of-range', 'duplicate', 'wrong-type']
+};
+
+const scenarioCatalog = JSON.parse(fs.readFileSync(path.join(helper.root, 'tdd', 'fixtures', 'quality-scenarios.json'), 'utf8'));
+const requiredScenarios = ['PASS', 'unit profile', 'integration profile', 'weighted integration failure', 'weighted unit failure', 'NON_CONFORMANT', 'SOURCE_DEFECT', 'SOURCE_CONFLICT', 'malformed input', 'unexpected input', 'error handling', 'nondeterministic output', 'auditable N/A', 'skipped test'];
+helper.check('2s. fixture catalog covers every required outcome', requiredScenarios.every(name => scenarioCatalog.scenarios.some(scenario => scenario.name === name)));
+
+function checks(prefix, names) {
+  return names.map((name, index) => ({
+    id: `${prefix}-${index + 1}`,
+    class: name,
+    status: 'PASS',
+    evidence: `tests/example.test.js#${prefix}-${name}`
+  }));
+}
+
+function validEvidence() {
+  const sideEffects = {
+    createdFiles: [], changedFiles: [], deletedFiles: [],
+    persistentState: {}, events: [], logs: [], externalCalls: []
+  };
+  return {
+    schemaVersion: '1.0.0',
+    requirements: [{
+      requirementId: 'REQ-001',
+      testProfile: 'integration',
+      source: {
+        type: 'SPEC', path: 'docs/example.md', section: 'Expected behavior', status: 'AUTHORITATIVE'
+      },
+      sourceConformance: 'PASS',
+      sourceValidity: 'VALID',
+      dimensions: {
+        positiveParameters: { applicable: true, checks: checks('positive', ['supported-partition']) },
+        negativeParameters: { applicable: true, checks: checks('negative', ['rejected-partition']) },
+        inputCompleteness: { applicable: true, checks: checks('input', classes.inputCompleteness) },
+        outputCompleteness: { applicable: true, checks: checks('output', classes.outputCompleteness) },
+        errorHandling: { applicable: true, checks: checks('error', classes.errorHandling) },
+        unexpectedInput: { applicable: true, checks: checks('unexpected', classes.unexpectedInput) },
+        determinism: {
+          applicable: true,
+          runs: [
+            { id: 'run-1', input: { value: 1 }, exitStatus: 0, errorCategory: null, output: { value: 2 }, sideEffects },
+            { id: 'run-2', input: { value: 1 }, exitStatus: 0, errorCategory: null, output: { value: 2 }, sideEffects }
+          ],
+          normalizations: []
+        },
+        sourceTraceability: { applicable: true }
+      },
+      skippedTests: [],
+      naDeclarations: []
+    }]
+  };
+}
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function evaluate(mutator) {
+  const evidence = validEvidence();
+  if (mutator) mutator(evidence.requirements[0], evidence);
+  return evaluateEvidence(evidence);
+}
+
+const pass = evaluate();
+helper.check('2s. complete profile-routed evidence passes with a 100 score', pass.result === 'PASS' && pass.score === 100 && pass.requirements[0].testProfile === 'integration');
+helper.check(
+  '2s. report publishes the canonical weights and pass threshold',
+  pass.scoring.requiredScore === 100 && pass.scoring.weights.positiveParameters === 0.15 && pass.scoring.weights.determinism === 0.10
+);
+
+const weightedIntegration = evaluate(req => { req.dimensions.positiveParameters.checks[0].status = 'FAIL'; });
+helper.check('2s. integration score follows the canonical weighted formula exactly', weightedIntegration.score === 85);
+
+const missingProfile = evaluate(req => { delete req.testProfile; });
+helper.check('2s. every requirement must declare its selected test profile', missingProfile.result === 'FAIL' && missingProfile.errors.some(e => /testProfile/.test(e)));
+
+const unknownProfile = evaluate(req => { req.testProfile = 'contract'; });
+helper.check('2s. only unit and integration profiles are accepted', unknownProfile.result === 'FAIL' && unknownProfile.errors.some(e => /unit or integration/.test(e)));
+
+const unitProfile = evaluate(req => {
+  req.testProfile = 'unit';
+  req.dimensions.determinism = { applicable: false, reason: 'This isolated unit does not cross an integration boundary.' };
+});
+helper.check('2s. unit evidence may mark integration determinism N/A with a reason', unitProfile.result === 'PASS' && unitProfile.requirements[0].dimensions.determinism.applicable === false);
+
+const weightedUnit = evaluate(req => {
+  req.testProfile = 'unit';
+  req.dimensions.determinism = { applicable: false, reason: 'This isolated unit does not cross an integration boundary.' };
+  req.dimensions.positiveParameters.checks[0].status = 'FAIL';
+});
+helper.check('2s. unit score renormalizes only the applicable canonical weights', weightedUnit.score === 83.33);
+
+const integrationWithoutRepeat = evaluate(req => {
+  req.dimensions.determinism = { applicable: false, reason: 'Not measured.' };
+});
+helper.check('2s. integration evidence cannot bypass repeated determinism checks', integrationWithoutRepeat.result === 'FAIL' && integrationWithoutRepeat.errors.some(e => /integration.*determinism/.test(e)));
+helper.check(
+  '2s. report exposes raw counts, percentages, and mandatory gates',
+  pass.dimensions.inputCompleteness.passed === 8 &&
+    pass.dimensions.inputCompleteness.required === 8 &&
+    pass.dimensions.inputCompleteness.percentage === 100 &&
+    Object.values(pass.mandatoryGates).every(Boolean)
+);
+
+const incompleteInput = evaluate(req => { req.dimensions.inputCompleteness.checks.pop(); });
+helper.check('2s. missing an applicable input class is rejected', incompleteInput.result === 'FAIL' && incompleteInput.errors.some(e => /inputCompleteness.*boundary/.test(e)));
+
+const incompleteOutput = evaluate(req => { req.dimensions.outputCompleteness.checks[0].status = 'FAIL'; });
+helper.check('2s. incomplete output validation is rejected', incompleteOutput.result === 'FAIL' && incompleteOutput.mandatoryGates.allRequiredInputOutputValidated === false);
+
+const failedUnexpected = evaluate(req => { req.dimensions.unexpectedInput.checks[0].status = 'FAIL'; });
+helper.check('2s. failed unexpected-input behavior is rejected', failedUnexpected.result === 'FAIL' && failedUnexpected.dimensions.unexpectedInput.percentage < 100);
+
+const untestedError = evaluate(req => { req.dimensions.errorHandling.checks[0].status = 'SKIPPED'; });
+helper.check('2s. untested and skipped error paths are rejected and visible', untestedError.result === 'FAIL' && untestedError.skippedTests.length === 1 && untestedError.mandatoryGates.allDeclaredErrorPathsTested === false);
+
+const nondeterministic = evaluate(req => { req.dimensions.determinism.runs[1].output.value = 3; });
+helper.check('2s. unequal repeated integration output is rejected', nondeterministic.result === 'FAIL' && nondeterministic.dimensions.determinism.matchingRuns === 1);
+
+const nonConformant = evaluate(req => { req.sourceConformance = 'NON_CONFORMANT'; });
+helper.check('2s. implementation/source mismatches fail', nonConformant.result === 'FAIL' && nonConformant.mandatoryGates.noSourceMismatch === false);
+
+const sourceDefect = evaluate(req => { req.sourceValidity = 'SOURCE_DEFECT'; req.sourceNotes = 'The approved example appears internally wrong.'; });
+helper.check('2s. source defects are reported separately without inventing a mismatch', sourceDefect.result === 'PASS' && sourceDefect.requirements[0].sourceValidity === 'SOURCE_DEFECT');
+
+const sourceConflict = evaluate(req => {
+  req.sourceValidity = 'SOURCE_CONFLICT';
+  req.sourceNotes = 'ADR-1 and SPEC-2 disagree.';
+  req.additionalSources = [{ type: 'ADR', path: 'docs/adr/001.md', section: 'Contract', status: 'AUTHORITATIVE' }];
+});
+helper.check('2s. unresolved authoritative source conflicts fail', sourceConflict.result === 'FAIL' && sourceConflict.mandatoryGates.noSourceConflict === false && sourceConflict.dimensions.sourceTraceability.traced === 2);
+
+const inferred = evaluate(req => { req.source = { type: 'INFERENCE', status: 'INFERRED', inferenceBasis: 'Observed public API and user-approved acceptance criteria.' }; });
+helper.check('2s. inferred expectations remain explicit and traceable', inferred.result === 'PASS' && inferred.dimensions.sourceTraceability.percentage === 100);
+
+const badNa = evaluate(req => { req.dimensions.negativeParameters = { applicable: false }; });
+helper.check('2s. N/A declarations without a written reason are rejected', badNa.result === 'FAIL' && badNa.errors.some(e => /negativeParameters.*reason/.test(e)));
+
+const goodNa = evaluate(req => { req.dimensions.negativeParameters = { applicable: false, reason: 'This parameterless behavior has no rejected partition.' }; });
+helper.check('2s. reasoned N/A stays visible and does not lower applicable scores', goodNa.result === 'PASS' && goodNa.naDeclarations.length === 1);
+
+const normalized = evaluate(req => {
+  req.dimensions.determinism.runs[0].output.generatedId = 'a';
+  req.dimensions.determinism.runs[1].output.generatedId = 'b';
+  req.dimensions.determinism.normalizations = [{ path: 'output.generatedId', rule: 'generated ID may vary', sourceSection: 'docs/example.md#Volatile fields' }];
+});
+helper.check('2s. explicitly source-backed volatile fields may be normalized', normalized.result === 'PASS');
+
+const malformed = clone(validEvidence());
+malformed.requirements = 'not-an-array';
+const malformedReport = evaluateEvidence(malformed);
+helper.check('2s. malformed evidence fails closed', malformedReport.result === 'FAIL' && malformedReport.errors.length > 0);
+
+const incompleteSideEffects = evaluate(req => { delete req.dimensions.determinism.runs[1].sideEffects.externalCalls; });
+helper.check('2s. incomplete deterministic side-effect evidence is rejected', incompleteSideEffects.result === 'FAIL' && incompleteSideEffects.errors.some(e => /externalCalls is required/.test(e)));
+
+const duplicate = clone(validEvidence());
+duplicate.requirements.push(clone(duplicate.requirements[0]));
+const duplicateReport = evaluateEvidence(duplicate);
+helper.check('2s. duplicate requirement IDs are rejected', duplicateReport.result === 'FAIL' && duplicateReport.errors.some(e => /Duplicate requirementId/.test(e)));
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-tdd-quality-'));
+const inputPath = path.join(tmp, 'evidence.json');
+const outputPath = path.join(tmp, 'report.json');
+fs.writeFileSync(inputPath, JSON.stringify(validEvidence()), 'utf8');
+const cli = spawnSync(process.execPath, [path.join(helper.root, 'tdd', 'scripts', 'quality-gate.js'), inputPath, '--output', outputPath], { encoding: 'utf8' });
+helper.check('2s. CLI emits per-requirement human scores and structured JSON', cli.status === 0 && /TDD Quality Gate: PASS/.test(cli.stdout) && /REQ-001 \[integration\]: PASS 100%/.test(cli.stdout) && fs.existsSync(outputPath));
+const failInputPath = path.join(tmp, 'non-conformant.json');
+const failOutputPath = path.join(tmp, 'non-conformant-report.json');
+const failEvidence = validEvidence();
+failEvidence.requirements[0].sourceConformance = 'NON_CONFORMANT';
+fs.writeFileSync(failInputPath, JSON.stringify(failEvidence), 'utf8');
+const failedCli = spawnSync(process.execPath, [path.join(helper.root, 'tdd', 'scripts', 'quality-gate.js'), failInputPath, '--output', failOutputPath], { encoding: 'utf8' });
+let failedReport = null;
+try { failedReport = JSON.parse(fs.readFileSync(failOutputPath, 'utf8')); } catch (e) { /* asserted below */ }
+helper.check(
+  '2s. CLI returns exit 1 and writes structured JSON for a valid FAIL report',
+  failedCli.status === 1 && /TDD Quality Gate: FAIL/.test(failedCli.stdout) && failedReport && failedReport.result === 'FAIL'
+);
+const malformedPath = path.join(tmp, 'malformed.json');
+fs.writeFileSync(malformedPath, '{', 'utf8');
+const malformedCli = spawnSync(process.execPath, [path.join(helper.root, 'tdd', 'scripts', 'quality-gate.js'), malformedPath], { encoding: 'utf8' });
+helper.check('2s. CLI returns exit 2 for malformed JSON', malformedCli.status === 2 && /TDD Quality Gate: FAIL/.test(malformedCli.stderr));
+fs.rmSync(tmp, { recursive: true, force: true });
+
+const shippedFixture = JSON.parse(fs.readFileSync(path.join(helper.root, 'tdd', 'fixtures', 'pass-evidence.json'), 'utf8'));
+helper.check('2s. shipped PASS evidence is executable', evaluateEvidence(shippedFixture).result === 'PASS');
+
+helper.finish();