harness-everything 0.2.2 → 0.4.0

package/ci/mechanism-2t-transcript-parser.test.js

@@ -0,0 +1,179 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const helper = require('./test-helper');
+const {
+  parseTranscript,
+  parseTranscriptFile,
+  gradeExecutionEvidence,
+} = require('../behavioral-evals/transcript-parser');
+const {
+  grade,
+  extractAgentTrace,
+  parseTranscriptEvents,
+  pairVerdict,
+  summarizePairResults,
+} = require('../behavioral-evals/run');
+
+const fixtures = path.join(__dirname, '..', 'behavioral-evals', 'fixtures');
+const readFixture = (name) => fs.readFileSync(path.join(fixtures, name), 'utf8');
+
+console.log('\n[2t] Structured behavioral transcript parser...');
+
+const claude = parseTranscript(readFixture('claude-success.jsonl'), 'claude');
+helper.check('2t. Claude stream is parsed', claude.parseStatus === 'parsed' && claude.format === 'claude-stream-json', JSON.stringify(claude));
+helper.check('2t. Claude trace keeps assistant text and tool input', claude.trace.includes('I will run the check.') && claude.trace.includes('[Bash]') && claude.trace.includes('npm test'), claude.trace);
+helper.check('2t. Claude trace excludes tool output', !claude.trace.includes('zoom-out/SKILL.md') && !claude.trace.includes('all tests passed'), claude.trace);
+helper.check('2t. Claude preserves result metadata', claude.metadata.cost === 0.0042 && claude.metadata.usage.input_tokens === 100 && claude.metadata.num_turns === 2, JSON.stringify(claude.metadata));
+helper.check('2t. Claude correlates completed tool evidence', claude.executionEvidence.counts.attempted === 1 && claude.executionEvidence.counts.completed === 1 && claude.executionEvidence.counts.denied === 0, JSON.stringify(claude.executionEvidence));
+
+const denied = parseTranscript(readFixture('claude-denied.jsonl'), 'claude');
+helper.check('2t. Permission denial is evidence', denied.executionEvidence.counts.attempted === 1 && denied.executionEvidence.counts.denied === 1 && denied.executionEvidence.counts.completed === 0, JSON.stringify(denied.executionEvidence));
+helper.check('2t. Denial grader passes only denied evidence', gradeExecutionEvidence({ type: 'tool_denied', value: 'Bash' }, denied).status === 'pass', JSON.stringify(gradeExecutionEvidence({ type: 'tool_denied', value: 'Bash' }, denied)));
+
+const oral = parseTranscript(readFixture('claude-oral-only.jsonl'), 'claude');
+helper.check('2t. Oral command mention has no attempted tool', oral.executionEvidence.counts.attempted === 0 && oral.executionEvidence.counts.completed === 0, JSON.stringify(oral.executionEvidence));
+const oralTraceGrade = grade({
+  expectations: [{ type: 'trace_contains', value: 'npm test' }],
+}, path.join(fixtures, 'unused-workspace'), path.join(fixtures, 'claude-oral-only.jsonl'), 'claude');
+helper.check('2t. Oral command prose cannot satisfy trace execution evidence', oralTraceGrade.status === 'inconclusive' && !oralTraceGrade.passed, JSON.stringify(oralTraceGrade));
+
+const opencode = parseTranscript(readFixture('opencode-success.jsonl'), 'opencode');
+helper.check('2t. Existing opencode JSONL remains supported', opencode.parseStatus === 'parsed' && opencode.format === 'opencode-jsonl', JSON.stringify(opencode));
+helper.check('2t. Duplicate opencode tool events are one call', opencode.executionEvidence.counts.attempted === 1 && opencode.executionEvidence.counts.completed === 1, JSON.stringify(opencode.executionEvidence));
+helper.check('2t. Opencode tool output never enters trace', !opencode.trace.includes('zoom-out/SKILL.md'), opencode.trace);
+
+const duplicateExplicit = parseTranscript([
+  JSON.stringify({ type: 'assistant', message: { content: [
+    { type: 'tool_use', id: 'call-1', name: 'Bash', input: { command: 'npm test' } },
+    { type: 'tool_use', id: 'call-1', name: 'Bash', input: { command: 'npm test' } },
+    { type: 'tool_use', name: 'Bash', input: { command: 'npm test' } },
+  ] } }),
+  JSON.stringify({ type: 'result', subtype: 'success', result: 'Done' }),
+].join('\n'), 'claude');
+helper.check('2t. Explicit IDs coalesce only by their ID', duplicateExplicit.executionEvidence.counts.attempted === 2, JSON.stringify(duplicateExplicit.executionEvidence));
+
+const resultBeforeCall = parseTranscript([
+  JSON.stringify({ type: 'user', message: { content: [
+    { type: 'tool_result', tool_use_id: 'late-call', content: 'done', is_error: false },
+  ] } }),
+  JSON.stringify({ type: 'assistant', message: { content: [
+    { type: 'tool_use', id: 'late-call', name: 'Bash', input: { command: 'npm test' } },
+  ] } }),
+  JSON.stringify({ type: 'result', subtype: 'success', result: 'Done' }),
+].join('\n'), 'claude');
+helper.check('2t. Out-of-order result and call events coalesce by ID', resultBeforeCall.executionEvidence.counts.attempted === 1 && resultBeforeCall.executionEvidence.counts.completed === 1, JSON.stringify(resultBeforeCall.executionEvidence));
+
+const completedWithDenialPhrase = parseTranscript([
+  JSON.stringify({ type: 'assistant', message: { content: [
+    { type: 'tool_use', id: 'call-output', name: 'Bash', input: { command: 'cat report.txt' } },
+  ] } }),
+  JSON.stringify({ type: 'user', message: { content: [
+    { type: 'tool_result', tool_use_id: 'call-output', content: 'command output: Permission denied', is_error: false },
+  ] } }),
+  JSON.stringify({ type: 'result', subtype: 'success', result: 'Done' }),
+].join('\n'), 'claude');
+helper.check('2t. Output text cannot masquerade as permission denial', completedWithDenialPhrase.executionEvidence.counts.completed === 1 && completedWithDenialPhrase.executionEvidence.counts.denied === 0, JSON.stringify(completedWithDenialPhrase.executionEvidence));
+
+const truncated = parseTranscript(readFixture('claude-truncated.jsonl').replace(/\n/g, '\r\n'), 'claude');
+helper.check('2t. Truncated CRLF stream is inconclusive', truncated.parseStatus === 'partial' && truncated.parseError, JSON.stringify(truncated));
+helper.check('2t. Partial execution evidence is inconclusive', gradeExecutionEvidence({ type: 'tool_completed', value: 'Bash' }, truncated).status === 'inconclusive', JSON.stringify(gradeExecutionEvidence({ type: 'tool_completed', value: 'Bash' }, truncated)));
+
+const legacy = parseTranscriptFile(path.join(fixtures, 'claude-legacy.json'), 'claude');
+helper.check('2t. Legacy JSON keeps readable final text', legacy.trace === 'Legacy final response', legacy.trace);
+helper.check('2t. Legacy JSON does not claim tool visibility', legacy.executionEvidence.visibility === 'unavailable' && legacy.executionEvidence.counts.attempted === null, JSON.stringify(legacy.executionEvidence));
+helper.check('2t. Unavailable evidence is inconclusive', gradeExecutionEvidence({ type: 'tool_completed', value: 'Bash' }, legacy).status === 'inconclusive', JSON.stringify(gradeExecutionEvidence({ type: 'tool_completed', value: 'Bash' }, legacy)));
+helper.check('2t. Auto detection preserves legacy JSON', parseTranscriptFile(path.join(fixtures, 'claude-legacy.json')).format === 'claude-json', parseTranscriptFile(path.join(fixtures, 'claude-legacy.json')).format);
+
+const legacyTraceGrade = grade({
+  expectations: [{ type: 'trace_contains', value: 'Legacy final response' }],
+}, path.join(fixtures, 'unused-workspace'), path.join(fixtures, 'claude-legacy.json'), 'claude');
+helper.check('2t. Legacy final prose cannot produce a definitive trace grade', legacyTraceGrade.status === 'inconclusive' && !legacyTraceGrade.passed, JSON.stringify(legacyTraceGrade));
+
+const userText = parseTranscript([
+  JSON.stringify({ type: 'system', subtype: 'init' }),
+  JSON.stringify({ type: 'user', message: { content: [{ type: 'text', text: 'tool output mentions npm test and zoom-out/SKILL.md' }] } }),
+  JSON.stringify({ type: 'result', subtype: 'success', result: 'Done' }),
+].join('\n'), 'claude');
+helper.check('2t. Claude user-event text is not agent trace', !userText.trace.includes('tool output mentions npm test'), userText.trace);
+
+const npmInstall = parseTranscript([
+  JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', id: 'npm-install', name: 'Bash', input: { command: 'npm install' } }] } }),
+  JSON.stringify({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'npm-install', content: 'installed', is_error: false }] } }),
+  JSON.stringify({ type: 'result', subtype: 'success', result: 'Done' }),
+].join('\n'), 'claude');
+for (const expectation of [
+  { type: 'tool_executed', command: 'npm test' },
+  { type: 'tool_executed', command: 'rm -rf /' },
+  { type: 'tool_executed', tool: 'npm test' },
+]) {
+  const result = gradeExecutionEvidence(expectation, npmInstall);
+  helper.check(`2t. ${JSON.stringify(expectation)} does not match another completed command`, !result.pass, JSON.stringify(result));
+}
+
+const npmCoverage = parseTranscript([
+  JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', id: 'npm-coverage', name: 'Bash', input: { command: 'npm test --coverage' } }] } }),
+  JSON.stringify({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'npm-coverage', content: 'passed', is_error: false }] } }),
+  JSON.stringify({ type: 'result', subtype: 'success', result: 'Done' }),
+].join('\n'), 'claude');
+helper.check('2t. Command targets reject extra arguments', !gradeExecutionEvidence({ type: 'tool_executed', command: 'npm test' }, npmCoverage).pass, JSON.stringify(gradeExecutionEvidence({ type: 'tool_executed', command: 'npm test' }, npmCoverage)));
+
+const generic = parseTranscript([
+  JSON.stringify({ type: 'tool_call', id: 'patch-1', name: 'apply_patch', input: { file_path: 'changes.patch' } }),
+  JSON.stringify({ type: 'tool_result', tool_use_id: 'patch-1', is_error: false, content: 'patched' }),
+  JSON.stringify({ type: 'tool_call', id: 'test-1', name: 'Bash', input: { command: 'npm test' } }),
+  JSON.stringify({ type: 'tool_result', tool_use_id: 'test-1', is_error: false, content: 'passed' }),
+  JSON.stringify({ type: 'text', text: 'finished' }),
+].join('\n'), 'auto');
+helper.check(
+  '2t. top-level tool calls and results remain structured evidence',
+  generic.parseStatus === 'parsed' && generic.executionEvidence.counts.completed === 2,
+  JSON.stringify(generic)
+);
+helper.check(
+  '2t. structured trace preserves tool-before-text event order',
+  generic.trace.indexOf('[apply_patch]') < generic.trace.indexOf('[Bash]') && generic.trace.indexOf('[Bash]') < generic.trace.indexOf('finished'),
+  generic.trace
+);
+
+const orderedDir = fs.mkdtempSync(path.join(os.tmpdir(), 'behavioral-parser-order-'));
+const orderedTranscript = path.join(orderedDir, 'trace.jsonl');
+fs.writeFileSync(orderedTranscript, [
+  { type: 'tool_call', id: 'patch-file', name: 'tool', input: { file_path: 'changes.patch' }, status: 'completed' },
+  { type: 'tool_call', id: 'run-test', name: 'Bash', input: { command: 'npm test' }, status: 'completed' },
+  { type: 'text', text: 'finished' },
+].map(event => JSON.stringify(event)).join('\n'));
+const orderedEvents = parseTranscriptEvents(orderedTranscript);
+const orderedTrace = extractAgentTrace(orderedTranscript);
+helper.check('2t. bare patch filenames count as edits for after_edit grading', orderedEvents.events[0] && orderedEvents.events[0].edit === true, JSON.stringify(orderedEvents.events));
+helper.check('2t. runner trace keeps bare patch, bash, then final text order', orderedTrace.indexOf('[tool]') < orderedTrace.indexOf('[Bash]') && orderedTrace.indexOf('[Bash]') < orderedTrace.indexOf('finished'), orderedTrace);
+fs.rmSync(orderedDir, { recursive: true, force: true });
+
+const todoPending = parseTranscript([
+  JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', id: 'todo-pending', name: 'TodoWrite', input: { todos: [{ status: 'pending', content: 'wait' }] } }] } }),
+  JSON.stringify({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'todo-pending', content: 'saved', is_error: false }] } }),
+  JSON.stringify({ type: 'result', subtype: 'success', result: 'Done' }),
+].join('\n'), 'claude');
+const todoExpectation = { type: 'tool_completed', name: 'TodoWrite', input_contains: 'in_progress' };
+helper.check('2t. Tool input qualifiers do not match unrelated TodoWrite state', !gradeExecutionEvidence(todoExpectation, todoPending).pass, JSON.stringify(gradeExecutionEvidence(todoExpectation, todoPending)));
+
+const caseDir = path.join(__dirname, '..', 'behavioral-evals', 'cases');
+const staleGuidance = fs.readdirSync(caseDir)
+  .filter(file => file.endsWith('.yaml'))
+  .filter(file => /#52|trace only captures|final message only/i.test(fs.readFileSync(path.join(caseDir, file), 'utf8')));
+helper.check('2t. Behavioral cases do not retain the obsolete #52 trace limitation', staleGuidance.length === 0, staleGuidance.join(', '));
+
+helper.check('2t. Non-definitive arm cannot produce effectiveness', pairVerdict({ outcome: 'inconclusive' }, { outcome: 'pass' }) === 'INCONCLUSIVE', pairVerdict({ outcome: 'inconclusive' }, { outcome: 'pass' }));
+helper.check('2t. Session errors cannot produce effectiveness', pairVerdict({ outcome: 'session-error' }, { outcome: 'pass' }) === 'INCONCLUSIVE', pairVerdict({ outcome: 'session-error' }, { outcome: 'pass' }));
+const pairSummary = summarizePairResults([
+  { id: 'uncertain', verdict: 'INCONCLUSIVE', arms: { baseline: { outcome: 'inconclusive' }, treatment: { outcome: 'pass' } } },
+  { id: 'effective', verdict: 'EFFECTIVE', arms: { baseline: { outcome: 'fail', tool_call_count: 0 }, treatment: { outcome: 'pass', tool_call_count: 1 } } },
+]);
+helper.check('2t. Inconclusive pairs are excluded from effectiveness aggregates', pairSummary.completed_pairs === 1 && pairSummary.session_failures === 0 && pairSummary.verdicts.INCONCLUSIVE === 0 && pairSummary.verdicts.EFFECTIVE === 1, JSON.stringify(pairSummary));
+helper.check('2t. Missing tool counts preserve a null delta', summarizePairResults([
+  { id: 'unknown-count', verdict: 'EFFECTIVE', arms: { baseline: { outcome: 'fail', tool_call_count: null }, treatment: { outcome: 'pass', tool_call_count: 1 } } },
+]).tool_call_delta[0].treatment_minus_baseline === null, JSON.stringify(summarizePairResults([
+  { id: 'unknown-count', verdict: 'EFFECTIVE', arms: { baseline: { outcome: 'fail', tool_call_count: null }, treatment: { outcome: 'pass', tool_call_count: 1 } } },
+])));
+
+helper.finish();

package/ci/mechanism-2t-workspace-identity.test.js

@@ -0,0 +1,200 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const root = path.resolve(__dirname, '..');
+let failures = 0;
+
+console.log('\n[2t] Session-stable workspace identity and standalone fable audit...');
+
+function check(name, condition, detail) {
+  if (condition) console.log(`  PASS ${name}`);
+  else {
+    console.error(`  FAIL ${name}`);
+    if (detail) console.error(`       ${detail}`);
+    failures += 1;
+  }
+}
+
+function run(cwd, script, env) {
+  return spawnSync(process.execPath, ['-e', script], {
+    cwd,
+    env,
+    encoding: 'utf8'
+  });
+}
+
+function filesRecursive(dir) {
+  if (!fs.existsSync(dir)) return [];
+  const files = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const target = path.join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...filesRecursive(target));
+    else files.push(target);
+  }
+  return files;
+}
+
+function nodeRequire(file) {
+  return JSON.stringify(file.replace(/\\/g, '/'));
+}
+
+// macOS exposes /var through the physical /private/var path. Canonicalize the
+// temp roots up front so expected fixture paths use the same identity contract
+// as workspace.js (realpath before hashing/binding) on every OS.
+const fixture = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2t-identity-')));
+const fakeHome = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2t-home-')));
+const stateHome = path.join(fakeHome, '.agents', 'harness-everything');
+const outer = path.join(fixture, 'outer-repo');
+const nested = path.join(outer, 'packages', 'nested');
+const nestedRepo = path.join(outer, 'embedded-repo');
+const scratch = path.join(fixture, 'scratch');
+for (const dir of [outer, nested, nestedRepo, scratch]) fs.mkdirSync(dir, { recursive: true });
+spawnSync('git', ['init', '--quiet'], { cwd: outer });
+spawnSync('git', ['init', '--quiet'], { cwd: nestedRepo });
+
+const baseEnv = { ...process.env, HOME: fakeHome, USERPROFILE: fakeHome, HARNESS_STATE_HOME: stateHome };
+const workspaceModule = path.join(root, 'scripts', 'lib', 'workspace.js');
+const stateModule = path.join(root, 'hooks', 'scripts', 'lib', 'harness-state.js');
+
+function identityScript(context) {
+  return `
+    const { getWorkspaceRoot, resolveWorkspaceIdentity } = require(${nodeRequire(workspaceModule)});
+    const context = ${JSON.stringify(context)};
+    console.log(JSON.stringify({ root: getWorkspaceRoot(context), identity: resolveWorkspaceIdentity(context) }));
+  `;
+}
+
+const session = 'issue-42-stable-session';
+let result = run(outer, identityScript({ session_id: session, hook_event_name: 'SessionStart', cwd: outer }), baseEnv);
+let parsed = JSON.parse(result.stdout);
+check('SessionStart binds the repository root', result.status === 0 && path.resolve(parsed.root) === path.resolve(outer), result.stderr);
+
+for (const [label, cwd] of [['nested directory', nested], ['scratch directory', scratch], ['nested repository', nestedRepo]]) {
+  result = run(cwd, identityScript({ session_id: session, cwd }), baseEnv);
+  parsed = JSON.parse(result.stdout);
+  check(`same session stays bound after entering a ${label}`, result.status === 0 && path.resolve(parsed.root) === path.resolve(outer), result.stderr || result.stdout);
+}
+
+result = run(scratch, identityScript({
+  session_id: 'explicit-context-session', cwd: scratch, workspace_root: outer
+}), { ...baseEnv, HARNESS_WORKSPACE_ROOT: nestedRepo });
+parsed = JSON.parse(result.stdout);
+check('explicit workspace context outranks inherited workspace environment', result.status === 0 && path.resolve(parsed.root) === path.resolve(outer), result.stderr || result.stdout);
+
+result = run(nestedRepo, identityScript({
+  session_id: session, hook_event_name: 'SessionStart', cwd: nestedRepo
+}), baseEnv);
+parsed = JSON.parse(result.stdout);
+check('resume SessionStart keeps the existing binding', result.status === 0 && path.resolve(parsed.root) === path.resolve(outer), result.stderr || result.stdout);
+
+result = run(nestedRepo, identityScript({
+  session_id: session, workspace_identity_reset: true, cwd: nestedRepo
+}), baseEnv);
+parsed = JSON.parse(result.stdout);
+check('explicit identity reset permits a deliberate rebind', result.status === 0 && path.resolve(parsed.root) === path.resolve(nestedRepo), result.stderr || result.stdout);
+result = run(scratch, identityScript({ session_id: session, cwd: scratch }), baseEnv);
+parsed = JSON.parse(result.stdout);
+check('identity reset persists the new binding for later cwd changes', result.status === 0 && path.resolve(parsed.root) === path.resolve(nestedRepo), result.stderr || result.stdout);
+
+result = run(outer, identityScript({ session_id: 'issue-42-host-session', host_id: 'host-a', cwd: outer }), baseEnv);
+parsed = JSON.parse(result.stdout);
+check('host/session identity binds the first host workspace', result.status === 0 && path.resolve(parsed.root) === path.resolve(outer), result.stderr || result.stdout);
+result = run(nestedRepo, identityScript({ session_id: 'issue-42-host-session', host_id: 'host-a', cwd: nestedRepo }), baseEnv);
+parsed = JSON.parse(result.stdout);
+check('same host/session stays bound after a nested-repository cwd change', result.status === 0 && path.resolve(parsed.root) === path.resolve(outer), result.stderr || result.stdout);
+result = run(scratch, identityScript({ session_id: 'issue-42-host-session', cwd: scratch }), baseEnv);
+parsed = JSON.parse(result.stdout);
+check('hostless follow-up reuses an unambiguous host/session binding', result.status === 0 && path.resolve(parsed.root) === path.resolve(outer), result.stderr || result.stdout);
+result = run(nestedRepo, identityScript({ session_id: 'issue-42-host-session', host_id: 'host-b', cwd: nestedRepo }), baseEnv);
+parsed = JSON.parse(result.stdout);
+check('different hosts may bind the same session id independently', result.status === 0 && path.resolve(parsed.root) === path.resolve(nestedRepo), result.stderr || result.stdout);
+result = run(scratch, identityScript({ session_id: 'issue-42-host-session', cwd: scratch }), baseEnv);
+parsed = JSON.parse(result.stdout);
+check('ambiguous hostless identity falls back to explicit context', result.status === 0 && path.resolve(parsed.root) === path.resolve(scratch), result.stderr || result.stdout);
+
+const stateScript = `
+  const { getWorkspaceRoot, getSessionDir } = require(${nodeRequire(stateModule)});
+  const payload = ${JSON.stringify({ session_id: 'issue-42-state-session', cwd: outer })};
+  const root = getWorkspaceRoot(payload);
+  console.log(JSON.stringify({ root, dir: getSessionDir(root, payload.session_id) }));
+`;
+result = run(scratch, stateScript, baseEnv);
+parsed = JSON.parse(result.stdout);
+const stateDir = path.resolve(parsed.dir);
+check('hooks can resolve state from a bound session after cwd changes', result.status === 0 && stateDir.startsWith(path.resolve(stateHome)) && !stateDir.startsWith(path.resolve(fixture)), result.stderr || result.stdout);
+
+// The fable script is copied as a standalone skill at install time. Keeping a
+// second copy here catches accidental imports of repo-only helpers and checks
+// that its audit uses the same session registry/state stream.
+const installed = path.join(fixture, 'installed', 'fable-mode', 'scripts');
+fs.mkdirSync(installed, { recursive: true });
+fs.copyFileSync(path.join(root, 'fable-mode', 'scripts', 'model-selector.js'), path.join(installed, 'model-selector.js'));
+fs.copyFileSync(path.join(root, 'fable-mode', 'model-matrix.json'), path.join(installed, '..', 'model-matrix.json'));
+const fable = path.join(installed, 'model-selector.js');
+const fableArgs = ['--requested', 'haiku', '--available', 'haiku', '--available-agents', 'fable-worker-haiku', '--stage-brief', 'identity', '--pass-condition', 'audit', '--verification-command', 'node test', '--verifier-result', 'pass', '--session-id', 'issue-42-fable-session'];
+result = spawnSync(process.execPath, [fable, ...fableArgs], { cwd: outer, env: baseEnv, encoding: 'utf8' });
+check('standalone fable audit runs after install', result.status === 0, result.stderr || result.stdout);
+result = spawnSync(process.execPath, [fable, ...fableArgs], { cwd: scratch, env: baseEnv, encoding: 'utf8' });
+const fableAudits = filesRecursive(stateHome).filter(file => file.endsWith(path.join('fable-mode', 'audit.jsonl')));
+const fableAuditRecords = fableAudits.length === 1
+  ? fs.readFileSync(fableAudits[0], 'utf8').trim().split(/\r?\n/).filter(Boolean)
+  : [];
+check(
+  'standalone fable audit follows its session binding across cwd changes',
+  result.status === 0 && fableAudits.length === 1 && fableAuditRecords.length === 2,
+  JSON.stringify({ audits: fableAudits, records: fableAuditRecords.length })
+);
+
+// Migration merges every platform source into an already-used destination,
+// preserves conflicting/unsupported entries, and succeeds on a later retry
+// after the user resolves the conflict.
+const migrationScript = `
+  const fs = require('fs');
+  const path = require('path');
+  const { getWorkspaceStateDir } = require(${nodeRequire(workspaceModule)});
+  const { migrateLegacyState } = require(${nodeRequire(stateModule)});
+  const workspace = ${JSON.stringify(outer)};
+  const destination = path.join(getWorkspaceStateDir(workspace), 'state');
+  const claude = path.join(workspace, '.claude', 'harness-everything', 'state');
+  const cursor = path.join(workspace, '.cursor', 'harness-everything', 'state');
+  const conflict = path.join('sessions', 'migration-conflict.json');
+  fs.mkdirSync(path.join(claude, 'sessions'), { recursive: true });
+  fs.mkdirSync(path.join(cursor, 'sessions'), { recursive: true });
+  fs.mkdirSync(path.join(destination, 'sessions'), { recursive: true });
+  fs.writeFileSync(path.join(claude, conflict), 'legacy');
+  fs.writeFileSync(path.join(cursor, 'sessions', 'cursor-only.json'), 'cursor');
+  fs.writeFileSync(path.join(destination, conflict), 'newer');
+  let symlink = false;
+  try {
+    fs.writeFileSync(path.join(claude, 'sessions', 'symlink-target.txt'), 'target');
+    fs.symlinkSync('symlink-target.txt', path.join(claude, 'sessions', 'unsupported-link'), 'file');
+    symlink = true;
+  } catch (err) {}
+  const first = migrateLegacyState(workspace, destination);
+  const firstState = {
+    first,
+    claudeExists: fs.existsSync(claude),
+    cursorExists: fs.existsSync(cursor),
+    conflict: fs.readFileSync(path.join(destination, conflict), 'utf8'),
+    cursorOnly: fs.readFileSync(path.join(destination, 'sessions', 'cursor-only.json'), 'utf8'),
+    symlinkCopied: fs.existsSync(path.join(destination, 'sessions', 'unsupported-link')),
+    symlink
+  };
+  if (symlink) fs.unlinkSync(path.join(claude, 'sessions', 'unsupported-link'));
+  fs.rmSync(path.join(destination, conflict), { force: true });
+  const second = migrateLegacyState(workspace, destination);
+  console.log(JSON.stringify({ firstState, second, claudeExistsAfterRetry: fs.existsSync(claude), conflictAfterRetry: fs.readFileSync(path.join(destination, conflict), 'utf8') }));
+`;
+result = run(scratch, migrationScript, baseEnv);
+parsed = JSON.parse(result.stdout);
+check('migration keeps conflicting sources available for recovery', result.status === 0 && parsed.firstState.claudeExists && parsed.firstState.conflict === 'newer', result.stderr || result.stdout);
+check('migration merges independent platform sources even when one conflicts', result.status === 0 && !parsed.firstState.cursorExists && parsed.firstState.cursorOnly === 'cursor', result.stderr || result.stdout);
+check('migration preserves unsupported symlink entries', result.status === 0 && (!parsed.firstState.symlink || !parsed.firstState.symlinkCopied), result.stderr || result.stdout);
+check('migration retry completes after the conflict is resolved', result.status === 0 && !parsed.claudeExistsAfterRetry && parsed.conflictAfterRetry === 'legacy', result.stderr || result.stdout);
+
+fs.rmSync(fixture, { recursive: true, force: true });
+fs.rmSync(fakeHome, { recursive: true, force: true });
+
+if (failures > 0) process.exit(1);

package/ci/mechanism-2u-issue-42-regressions.test.js

@@ -0,0 +1,239 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+const { pathToFileURL } = require('url');
+
+const root = path.resolve(__dirname, '..');
+const workspaceModule = path.join(root, 'scripts', 'lib', 'workspace.js');
+const stateModule = path.join(root, 'hooks', 'scripts', 'lib', 'harness-state.js');
+const fixture = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-2u-issue-42-'));
+const fakeHome = path.join(fixture, 'home');
+const stateHome = path.join(fakeHome, '.agents', 'harness-everything');
+const noGitA = path.join(fixture, 'scratch-a');
+const noGitB = path.join(fixture, 'scratch-b');
+const failures = [];
+
+for (const dir of [fakeHome, stateHome, noGitA, noGitB]) fs.mkdirSync(dir, { recursive: true });
+
+const baseEnv = { ...process.env, HOME: fakeHome, USERPROFILE: fakeHome, HARNESS_STATE_HOME: stateHome };
+for (const name of ['HARNESS_WORKSPACE_ROOT', 'CLAUDE_PROJECT_DIR', 'CODEX_PROJECT_DIR', 'FABLE_WORKSPACE_ROOT']) {
+  delete baseEnv[name];
+}
+
+function check(name, condition, detail) {
+  if (condition) console.log(`PASS ${name}`);
+  else {
+    console.error(`FAIL ${name}`);
+    if (detail) console.error(`     ${detail}`);
+    failures.push(name);
+  }
+}
+
+function run(cwd, args, env = baseEnv) {
+  return spawnSync(process.execPath, args, { cwd, env, encoding: 'utf8' });
+}
+
+function requirePath(file) {
+  return JSON.stringify(file.replace(/\\/g, '/'));
+}
+
+function filesUnder(dir) {
+  if (!fs.existsSync(dir)) return [];
+  const result = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const target = path.join(dir, entry.name);
+    result.push(target);
+    if (entry.isDirectory()) result.push(...filesUnder(target));
+  }
+  return result;
+}
+
+function parseJSON(result) {
+  try { return JSON.parse(result.stdout); } catch { return null; }
+}
+
+console.log('\n[2u] Issue #42 adversarial regressions...');
+
+const identityScript = `
+  const { getWorkspaceRoot, getWorkspaceKey } = require(${requirePath(workspaceModule)});
+  console.log(JSON.stringify({ root: getWorkspaceRoot(), key: getWorkspaceKey() }));
+`;
+const identityA = parseJSON(run(noGitA, ['-e', identityScript]));
+const identityB = parseJSON(run(noGitB, ['-e', identityScript]));
+check(
+  '2u. no-context non-git calls do not adopt either invocation directory',
+  identityA && identityB && identityA.root === null && identityB.root === null,
+  JSON.stringify({ identityA, identityB })
+);
+check(
+  '2u. no-context non-git calls use one stable unbound workspace key',
+  identityA && identityB && identityA.key === identityB.key,
+  JSON.stringify({ identityA, identityB })
+);
+
+const scaffold = path.join(root, 'multi-agent-workspace', 'scripts', 'scaffold.js');
+const scaffoldRun = run(noGitA, [scaffold]);
+check(
+  '2u. scaffold refuses to infer a workspace outside git instead of writing locally',
+  scaffoldRun.status !== 0 && !fs.existsSync(path.join(noGitA, '.harness')),
+  `exit=${scaffoldRun.status} output=${scaffoldRun.stderr || scaffoldRun.stdout}`
+);
+
+const evaluate = path.join(root, 'eval-harness', 'scripts', 'evaluate.js');
+const evaluateRun = run(noGitA, [evaluate, '10', '10', '10', '10', 'issue 42']);
+check(
+  '2u. evaluate refuses to write a report without a resolved workspace',
+  evaluateRun.status !== 0 && !fs.existsSync(path.join(noGitA, 'evals')),
+  `exit=${evaluateRun.status} output=${evaluateRun.stderr || evaluateRun.stdout}`
+);
+
+const persistMemory = path.join(root, 'self-evolve', 'scripts', 'persist-memory.js');
+const persistRun = run(noGitA, [persistMemory, 'Always verify workspace-root resolution with regression tests before writing state.']);
+check(
+  '2u. persist-memory refuses to write project memory without a resolved workspace',
+  persistRun.status !== 0 && !fs.existsSync(path.join(noGitA, 'memories')),
+  `exit=${persistRun.status} output=${persistRun.stderr || persistRun.stdout}`
+);
+
+const copiedResolverFiles = [
+  'eval-harness/scripts/evaluate.js',
+  'multi-agent-workspace/scripts/scaffold.js',
+  'self-evolve/scripts/persist-memory.js',
+  'self-evolve/scripts/register-dynamic-skill.js',
+  'security-review/scripts/audit-secrets.js',
+  'to-spec/scripts/check-project-docs.js'
+];
+for (const relative of copiedResolverFiles) {
+  const source = fs.readFileSync(path.join(root, relative), 'utf8');
+  check(
+    `2u. ${relative} has no bare process.cwd fallback`,
+    !/return\s+process\.cwd\(\);/.test(source),
+    'found a bare cwd return'
+  );
+}
+
+const findSkill = path.join(root, 'find-skills', 'scripts', 'use-skill.js');
+const cacheSource = `owner/repo@issue42-cache-${process.pid}-${Date.now()}`;
+const cacheHash = crypto.createHash('sha1').update(cacheSource).digest('hex');
+const expectedCache = path.join(stateHome, 'cache', 'find-skills', `${cacheHash}.md`);
+fs.mkdirSync(path.dirname(expectedCache), { recursive: true });
+fs.writeFileSync(expectedCache, 'CACHED\n', 'utf8');
+const fakeBin = path.join(fixture, 'bin');
+fs.mkdirSync(fakeBin, { recursive: true });
+const fakeNpx = path.join(fakeBin, process.platform === 'win32' ? 'npx.cmd' : 'npx');
+fs.writeFileSync(
+  fakeNpx,
+  process.platform === 'win32' ? '@echo off\r\necho FETCHED\r\n' : '#!/bin/sh\necho FETCHED\n',
+  'utf8'
+);
+if (process.platform !== 'win32') fs.chmodSync(fakeNpx, 0o755);
+const cacheRun = run(noGitA, [findSkill, cacheSource, '--max-age', '6'], {
+  ...baseEnv,
+  PATH: `${fakeBin}${path.delimiter}${process.env.PATH || ''}`
+});
+const legacyCache = path.join(os.tmpdir(), 'harness-find-skills-cache', `${cacheHash}.md`);
+check(
+  '2u. find-skills reads its cache from HARNESS_STATE_HOME',
+  cacheRun.status === 0 && cacheRun.stdout.includes('CACHED') && fs.existsSync(expectedCache),
+  `exit=${cacheRun.status} stdout=${cacheRun.stdout} stderr=${cacheRun.stderr}`
+);
+check(
+  '2u. find-skills does not create the legacy OS-temp cache',
+  !fs.existsSync(legacyCache),
+  legacyCache
+);
+if (fs.existsSync(legacyCache)) fs.unlinkSync(legacyCache);
+
+const fable = path.join(root, 'fable-mode', 'scripts', 'model-selector.js');
+const fableArgs = [
+  fable, '--requested', 'haiku', '--available', 'haiku',
+  '--available-agents', 'fable-worker-haiku', '--stage-brief', 'identity',
+  '--pass-condition', 'audit', '--verification-command', 'node test',
+  '--verifier-result', 'pass'
+];
+const fableA = run(noGitA, fableArgs);
+const fableB = run(noGitB, fableArgs);
+const auditFiles = filesUnder(stateHome).filter(file => path.basename(file) === 'audit.jsonl');
+check(
+  '2u. standalone fable calls from unrelated non-git dirs share one unbound audit stream',
+  fableA.status === 0 && fableB.status === 0 &&
+    filesUnder(noGitA).length === 0 && filesUnder(noGitB).length === 0 &&
+    auditFiles.length === 1 && fs.readFileSync(auditFiles[0], 'utf8').trim().split(/\r?\n/).length === 2,
+  `runs=${fableA.status},${fableB.status} audits=${JSON.stringify(auditFiles)}`
+);
+
+const gitWorkspace = path.join(fixture, 'git-workspace');
+fs.mkdirSync(gitWorkspace, { recursive: true });
+const gitInit = spawnSync('git', ['init', '--quiet'], { cwd: gitWorkspace, encoding: 'utf8' });
+check('2u. git fixture initialized for migration checks', gitInit.status === 0, gitInit.stderr);
+
+const legacyMultiAgent = path.join(gitWorkspace, '.harness', 'multi-agent');
+fs.mkdirSync(path.join(legacyMultiAgent, 'state'), { recursive: true });
+fs.writeFileSync(path.join(legacyMultiAgent, 'state', 'legacy.json'), 'legacy', 'utf8');
+const migrateScript = `
+  const { getStateRoot } = require(${requirePath(stateModule)});
+  console.log(getStateRoot(${JSON.stringify(gitWorkspace)}));
+`;
+const migrationRun = run(noGitA, ['-e', migrateScript]);
+const newStateRoot = migrationRun.stdout.trim();
+check(
+  '2u. legacy .harness/multi-agent state moves under the global workspace state',
+  migrationRun.status === 0 && !fs.existsSync(legacyMultiAgent) &&
+    fs.existsSync(path.join(newStateRoot, 'multi-agent', 'state', 'legacy.json')),
+  `exit=${migrationRun.status} stdout=${migrationRun.stdout} stderr=${migrationRun.stderr}`
+);
+
+if (process.platform === 'win32') {
+  const caseScript = `
+    const { getWorkspaceKey } = require(${requirePath(workspaceModule)});
+    const root = ${JSON.stringify(gitWorkspace)};
+    console.log(JSON.stringify({ original: getWorkspaceKey(root), variant: getWorkspaceKey(root.toUpperCase()) }));
+  `;
+  const caseResult = parseJSON(run(noGitA, ['-e', caseScript]));
+  check(
+    '2u. Windows case variants resolve to one workspace key',
+    caseResult && caseResult.original === caseResult.variant,
+    JSON.stringify(caseResult)
+  );
+}
+
+const opencodeHome = path.join(fixture, 'opencode-home');
+const opencodeStateHome = path.join(fixture, 'opencode-state');
+const opencodeWorkspace = path.join(fixture, 'opencode-workspace');
+for (const dir of [opencodeHome, opencodeStateHome, opencodeWorkspace]) fs.mkdirSync(dir, { recursive: true });
+const opencodeReal = fs.realpathSync(path.resolve(opencodeWorkspace));
+const opencodeSlug = path.basename(opencodeReal).toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'workspace';
+const opencodeHash = crypto.createHash('sha1').update(process.platform === 'win32' ? opencodeReal.toLowerCase() : opencodeReal).digest('hex').slice(0, 12);
+const opencodeStateDir = path.join(opencodeStateHome, 'workspaces', `${opencodeSlug}-${opencodeHash}`);
+const opencodeLegacy = path.join(opencodeHome, '.harness-state');
+fs.mkdirSync(opencodeStateDir, { recursive: true });
+fs.mkdirSync(opencodeLegacy, { recursive: true });
+fs.writeFileSync(path.join(opencodeLegacy, 'edit-state.json'), '{"legacy":true}', 'utf8');
+const opencodeScript = `
+  import { existsSync } from 'node:fs';
+  const { HarnessEnforcement } = await import(${JSON.stringify(pathToFileURL(path.join(root, 'opencode-plugin', 'index.mjs')).href)});
+  await HarnessEnforcement({ client: {}, directory: ${JSON.stringify(opencodeWorkspace)} });
+  console.log(JSON.stringify({ legacy: existsSync(${JSON.stringify(opencodeLegacy)}), target: existsSync(${JSON.stringify(path.join(opencodeStateDir, 'edit-state.json'))}) }));
+`;
+const opencodeRun = run(noGitA, ['--input-type=module', '-e', opencodeScript], {
+  ...baseEnv,
+  HOME: opencodeHome,
+  USERPROFILE: opencodeHome,
+  HARNESS_STATE_HOME: opencodeStateHome
+});
+const opencodeResult = parseJSON(opencodeRun);
+check(
+  '2u. opencode merges flat legacy state even when the target directory exists',
+  opencodeRun.status === 0 && opencodeResult && opencodeResult.legacy === false && opencodeResult.target === true,
+  `exit=${opencodeRun.status} stdout=${opencodeRun.stdout} stderr=${opencodeRun.stderr}`
+);
+
+try { fs.rmSync(fixture, { recursive: true, force: true }); } catch (err) { /* best effort test cleanup */ }
+
+if (failures.length > 0) {
+  console.error(`\n${failures.length} issue-42 regression check(s) failed.`);
+  process.exit(1);
+}
+console.log('All issue-42 regression checks passed.');