kenaz 0.0.0-stage → 0.3.2

package/core/.formation/tools/post-complete.test.js

@@ -0,0 +1,1002 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const {
+  isDaemonManagedPath,
+  listDaemonManagedPaths,
+  verifyStagedScopeCoverage,
+  checkAndUpdatePostCompleteGuard,
+  writeInboxEntryIdempotent,
+} = require('./post-complete');
+const {
+  saveTaskHealthSnapshot,
+  readPreTaskHealthSnapshot,
+  resolveMcpProjectPath,
+} = require('./post-complete/health');
+const {
+  isAutoWritePath,
+  filterOutcomeFilesForPrediction,
+} = require('./post-complete/outcome');
+const {
+  findTaskCommitOnUserBranch,
+  hasChangesInScope,
+  _neutralizeUntrackedCollisions,
+  _restoreNeutralizedCollisions,
+  gitBranchAndMerge,
+} = require('./post-complete/git-merge');
+
+test('isDaemonManagedPath matches explicit files and future daemon patterns', () => {
+  assert.equal(isDaemonManagedPath('.synapse/pulse_cache.json'), true);
+  assert.equal(isDaemonManagedPath('.synapse/heat_cache.json'), true);
+  assert.equal(isDaemonManagedPath('.synapse/future_cache.json'), true);
+  assert.equal(isDaemonManagedPath('.memory/registry.json'), true);
+  assert.equal(isDaemonManagedPath('.prefrontal/generalize_counter.json'), true);
+  assert.equal(isDaemonManagedPath('.tmp/runtime/session.json'), true);
+  assert.equal(isDaemonManagedPath('src/app.js'), false);
+});
+
+test('listDaemonManagedPaths discovers new daemon cache files', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'post-complete-daemon-'));
+  try {
+    fs.mkdirSync(path.join(tmpRoot, '.synapse'), { recursive: true });
+    fs.mkdirSync(path.join(tmpRoot, '.tmp', 'runtime'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, '.synapse', 'focus_cache.json'), '{}');
+    fs.writeFileSync(path.join(tmpRoot, '.synapse', 'memory-shared.json'), '{}');
+    fs.writeFileSync(path.join(tmpRoot, '.tmp', 'runtime', 'pid.json'), '{}');
+
+    const discovered = listDaemonManagedPaths(tmpRoot);
+
+    assert.ok(discovered.includes('.synapse/focus_cache.json'));
+    assert.ok(discovered.includes('.synapse/memory-shared.json'));
+    assert.ok(discovered.includes('.tmp/'));
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('isAutoWritePath identifies surprise-metric noise files', () => {
+  assert.equal(isAutoWritePath('.kenaz/specialist/muninn_observations.json'), true);
+  assert.equal(isAutoWritePath('.kenaz/specialist/ansuz_self_model.json'), true);
+  assert.equal(isAutoWritePath('dashboard/src-tauri/src/main.rs'), false);
+});
+
+test('filterOutcomeFilesForPrediction excludes auto-write noise from prediction metrics', () => {
+  const result = filterOutcomeFilesForPrediction([
+    '.kenaz/specialist/muninn_observations.json',
+    '.kenaz/specialist/ansuz_self_model.json',
+    '.specialist/tools/phase-gate.js',
+    '.formation/tools/post-complete/outcome.js',
+  ]);
+
+  assert.deepEqual(result.included, [
+    '.specialist/tools/phase-gate.js',
+    '.formation/tools/post-complete/outcome.js',
+  ]);
+  assert.deepEqual(result.excluded, [
+    '.kenaz/specialist/muninn_observations.json',
+    '.kenaz/specialist/ansuz_self_model.json',
+  ]);
+});
+
+// Helper: run a git command in a directory, throwing on failure
+function git(cmd, cwd) {
+  return execSync(cmd, { cwd, encoding: 'utf8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+}
+
+// Helper: create a minimal git repo with an initial commit
+function makeGitRepo(dir) {
+  git('git init', dir);
+  git('git config user.email "test@test.com"', dir);
+  git('git config user.name "Test"', dir);
+  // Create initial commit so HEAD is valid
+  fs.writeFileSync(path.join(dir, 'README.md'), 'init');
+  git('git add README.md', dir);
+  git('git commit --no-verify -m "init"', dir);
+}
+
+test('verifyStagedScopeCoverage: prior-session-committed case — step 2.2b fix (TASK_1192)', () => {
+  // Reproduces the TASK_1191 scenario:
+  // - scope_paths = ['src/synapse.rs']
+  // - File was already committed in a prior session with [TASK_TEST1] in the commit message
+  // - Working tree is clean, staging area is empty
+  // - verifyStagedScopeCoverage should NOT flag synapse.rs as missingFromStage
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'post-complete-scope-'));
+  try {
+    makeGitRepo(tmpRoot);
+
+    // Simulate prior-session commit: agent committed src/synapse.rs with TASK_TEST1 in message
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'synapse.rs'), 'fn foo() {}');
+    git('git add src/synapse.rs', tmpRoot);
+    git('git commit --no-verify -m "[TASK_TEST1] align path resolution"', tmpRoot);
+
+    // Working tree is now clean — no staged or unstaged changes
+    const result = verifyStagedScopeCoverage(['src/synapse.rs'], tmpRoot, 'TASK_TEST1');
+
+    assert.equal(result.ok, true, 'scope coverage should be ok when path is in prior commit');
+    assert.deepEqual(result.missingFromStage, [], 'missingFromStage should be empty');
+    assert.ok(
+      result.coveredByPriorCommits.includes('src/synapse.rs'),
+      'src/synapse.rs should be listed in coveredByPriorCommits'
+    );
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('verifyStagedScopeCoverage: genuinely missing path is still flagged even with prior commits', () => {
+  // A path that has NO prior commits and is not staged should still be flagged.
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'post-complete-scope-'));
+  try {
+    makeGitRepo(tmpRoot);
+
+    // Only commit a DIFFERENT file under TASK_TEST2
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'other.rs'), 'fn bar() {}');
+    git('git add src/other.rs', tmpRoot);
+    git('git commit --no-verify -m "[TASK_TEST2] unrelated change"', tmpRoot);
+
+    // synapse.rs exists on disk but was never committed and is not staged
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'synapse.rs'), 'fn foo() {}');
+
+    const result = verifyStagedScopeCoverage(['src/synapse.rs'], tmpRoot, 'TASK_TEST2');
+
+    assert.equal(result.ok, false, 'scope coverage should fail for a genuinely missing path');
+    assert.ok(
+      result.missingFromStage.includes('src/synapse.rs'),
+      'src/synapse.rs should appear in missingFromStage'
+    );
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('verifyStagedScopeCoverage: prior commit from different taskId does not satisfy coverage', () => {
+  // Commits from a different task should not satisfy coverage for the current task.
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'post-complete-scope-'));
+  try {
+    makeGitRepo(tmpRoot);
+
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'synapse.rs'), 'fn foo() {}');
+    git('git add src/synapse.rs', tmpRoot);
+    // Committed under a DIFFERENT task ID
+    git('git commit --no-verify -m "[TASK_OTHER] change synapse"', tmpRoot);
+
+    // Now checking for TASK_TEST3 — should NOT be satisfied by TASK_OTHER commit
+    const result = verifyStagedScopeCoverage(['src/synapse.rs'], tmpRoot, 'TASK_TEST3');
+
+    assert.equal(result.ok, false, 'different-taskId commit should not satisfy coverage');
+    assert.ok(
+      result.missingFromStage.includes('src/synapse.rs'),
+      'src/synapse.rs should still be in missingFromStage'
+    );
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('verifyStagedScopeCoverage: salvage branch commits also count for coverage', () => {
+  // Reproduces the scenario where the original task branch was renamed to salvage/
+  // but the commits are still accessible via --all in git log.
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'post-complete-scope-'));
+  try {
+    makeGitRepo(tmpRoot);
+
+    // Simulate the salvage scenario:
+    // Create a task branch, commit the scope file, then rename it to salvage
+    git('git checkout -b task/task-test4', tmpRoot);
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'synapse.rs'), 'fn foo() {}');
+    git('git add src/synapse.rs', tmpRoot);
+    git('git commit --no-verify -m "[TASK_TEST4] scope change"', tmpRoot);
+
+    // Rename the branch to salvage (as post-complete does when it recreates the task branch)
+    git('git branch -m task/task-test4 task/task-test4_salvage_12345', tmpRoot);
+
+    // Switch back to the base branch (master or main depending on git version/config)
+    const allBranches = execSync('git branch --format=%(refname:short)', { cwd: tmpRoot, encoding: 'utf8' }).trim().split('\n');
+    const parentBranch = allBranches.find(b => !b.startsWith('task/')) || 'master';
+    git(`git checkout ${parentBranch}`, tmpRoot);
+    git('git checkout -b task/task-test4', tmpRoot);
+
+    // Now check coverage — src/synapse.rs exists on disk (from the WT), staging is empty
+    // The path is covered by the salvage branch commit (accessible via --all)
+    // Recreate the src/ dir since it's not tracked on the base branch.
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'synapse.rs'), 'fn foo() {}');
+
+    const result = verifyStagedScopeCoverage(['src/synapse.rs'], tmpRoot, 'TASK_TEST4');
+
+    assert.equal(result.ok, true, 'salvage branch commits should satisfy scope coverage');
+    assert.deepEqual(result.missingFromStage, []);
+    assert.ok(result.coveredByPriorCommits.includes('src/synapse.rs'));
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('verifyStagedScopeCoverage: mixed staged + prior-session coverage passes', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'post-complete-scope-'));
+  try {
+    makeGitRepo(tmpRoot);
+
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'a.rs'), 'fn a_v1() {}');
+    git('git add src/a.rs', tmpRoot);
+    git('git commit --no-verify -m "[TASK_TEST5] add a"', tmpRoot);
+
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'b.rs'), 'fn b() {}');
+    git('git add src/b.rs', tmpRoot);
+
+    const result = verifyStagedScopeCoverage(['src/a.rs', 'src/b.rs'], tmpRoot, 'TASK_TEST5');
+
+    assert.equal(result.ok, true, 'mixed staged + prior-session coverage should pass');
+    assert.deepEqual(result.missingFromStage, []);
+    assert.ok(result.coveredByPriorCommits.includes('src/a.rs'));
+    assert.ok(result.coveredByStage.includes('src/b.rs'));
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('verifyStagedScopeCoverage: unchanged scope path is allowed when another scope path is covered', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'post-complete-scope-'));
+  try {
+    makeGitRepo(tmpRoot);
+
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'a.rs'), 'fn a() {}');
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'b.rs'), 'fn b() {}');
+    git('git add src/a.rs src/b.rs', tmpRoot);
+    git('git commit --no-verify -m "seed scope files"', tmpRoot);
+
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'a.rs'), 'fn a() { println!(\"changed\"); }');
+    git('git add src/a.rs', tmpRoot);
+
+    const result = verifyStagedScopeCoverage(['src/a.rs', 'src/b.rs'], tmpRoot, 'TASK_TEST6');
+
+    assert.equal(result.ok, true, 'one covered scope path should allow another unchanged scope path');
+    assert.deepEqual(result.missingFromStage, []);
+    assert.ok(result.coveredByStage.includes('src/a.rs'));
+    assert.ok(result.uncoveredButAllowed.includes('src/b.rs'));
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+// ─────────────────────────────────────────
+// TASK_1419: Direct-commit detection (post-complete fast-path)
+// ─────────────────────────────────────────
+
+test('findTaskCommitOnUserBranch finds matching commit subject by task id', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'direct-commit-'));
+  try {
+    makeGitRepo(tmpRoot);
+    fs.writeFileSync(path.join(tmpRoot, 'preamble.rs'), 'fn build() {}');
+    git('git add preamble.rs', tmpRoot);
+    git('git commit --no-verify -m "[dashboard] session banner: filter stale alerts (TASK_1418)"', tmpRoot);
+
+    const branch = git('git rev-parse --abbrev-ref HEAD', tmpRoot);
+    const found = findTaskCommitOnUserBranch(tmpRoot, 'TASK_1418', branch);
+
+    assert.ok(found, 'should find a commit with TASK_1418 in subject');
+    assert.match(found.subject, /TASK_1418/);
+    assert.equal(found.hash.length, 40, 'hash should be a full sha');
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('findTaskCommitOnUserBranch returns null when no commit matches the task id', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'direct-commit-'));
+  try {
+    makeGitRepo(tmpRoot);
+    fs.writeFileSync(path.join(tmpRoot, 'a.rs'), '');
+    git('git add a.rs', tmpRoot);
+    git('git commit --no-verify -m "[TASK_OTHER] unrelated work"', tmpRoot);
+
+    const branch = git('git rev-parse --abbrev-ref HEAD', tmpRoot);
+    const found = findTaskCommitOnUserBranch(tmpRoot, 'TASK_1418', branch);
+
+    assert.equal(found, null);
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('findTaskCommitOnUserBranch is case-insensitive on the task id', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'direct-commit-'));
+  try {
+    makeGitRepo(tmpRoot);
+    fs.writeFileSync(path.join(tmpRoot, 'a.rs'), '');
+    git('git add a.rs', tmpRoot);
+    git('git commit --no-verify -m "lower-case task_1418 still counts"', tmpRoot);
+
+    const branch = git('git rev-parse --abbrev-ref HEAD', tmpRoot);
+    const found = findTaskCommitOnUserBranch(tmpRoot, 'TASK_1418', branch);
+
+    assert.ok(found, 'lowercase task_1418 should match TASK_1418 query');
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('findTaskCommitOnUserBranch returns null for missing inputs', () => {
+  assert.equal(findTaskCommitOnUserBranch(null, 'TASK_1', 'main'), null);
+  assert.equal(findTaskCommitOnUserBranch('/tmp', null, 'main'), null);
+  assert.equal(findTaskCommitOnUserBranch('/tmp', 'TASK_1', null), null);
+});
+
+test('hasChangesInScope returns true only when scope path is dirty', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'scope-changes-'));
+  try {
+    makeGitRepo(tmpRoot);
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'a.rs'), 'fn a() {}');
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'b.rs'), 'fn b() {}');
+    git('git add src/a.rs src/b.rs', tmpRoot);
+    git('git commit --no-verify -m "seed"', tmpRoot);
+
+    assert.equal(hasChangesInScope(tmpRoot, ['src/a.rs']), false, 'clean tree → no changes in scope');
+
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'a.rs'), 'fn a() { println!(\"v2\"); }');
+    assert.equal(hasChangesInScope(tmpRoot, ['src/a.rs']), true, 'dirty in-scope → true');
+    assert.equal(hasChangesInScope(tmpRoot, ['src/b.rs']), false, 'dirty out-of-scope → false');
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+// ── TASK_2035: serial gitBranchAndMerge must merge an existing task/<id> branch
+// directly, never rewrite it via the salvage/rebuild pipeline ─────────────────
+//
+// Field report (geo-analyzer TASK_1516, 2026-09-26): main had one uncommitted
+// change to a tracked file; the agent's real commit (10 files) was already on
+// task/task_1516 from a prior run. post-complete's serial merge path treated
+// the pre-existing task branch as leftover cruft, renamed it to a *_salvage_*
+// branch, recreated task/task_1516 from main HEAD, and committed only main's
+// dirty file onto it — the merge then landed 1 file instead of 10 and reported
+// merged=false. Fix (git-merge.js step "0.06"): detect an existing task/<id>
+// with commits ahead of userBranch BEFORE the salvage/rebuild pipeline and
+// delegate to the task-branch-only merge path instead of rewriting it.
+
+test('TASK_2035: gitBranchAndMerge merges an existing task/<id> with agent commits instead of rewriting it', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-t2035-'));
+  try {
+    makeGitRepo(tmpRoot);
+    git('git config commit.gpgsign false', tmpRoot);
+    const gitSafe = (cmd) => { try { return git(cmd, tmpRoot); } catch { return null; } };
+    gitSafe('git checkout -b xyz9516');
+
+    const taskId = 'TASK_9035';
+    const taskBranch = `task/${taskId.toLowerCase()}`;
+
+    // Agent already committed real work on task/<id> in a prior run (e.g. a
+    // worktree dispatch that committed but whose merge never completed) —
+    // 1 commit adding 2 files, the TASK_1516 field-report shape.
+    gitSafe(`git checkout -b ${taskBranch} xyz9516`);
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'a.js'), 'export const a = 1;\n');
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'b.js'), 'export const b = 2;\n');
+    git('git add -A', tmpRoot);
+    git(`git commit --no-verify -m "[${taskId}] task completed"`, tmpRoot);
+    const agentCommitSha = git('git rev-parse HEAD', tmpRoot);
+
+    // Back on the user branch: main never received the agent's commits, and
+    // has its own unrelated dirty tracked file (the field report's shape: ONE
+    // uncommitted change to a tracked file on main).
+    git('git checkout xyz9516', tmpRoot);
+    fs.writeFileSync(path.join(tmpRoot, 'README.md'), 'init\nmain dirt\n');
+
+    const result = gitBranchAndMerge({
+      taskId, message: `[${taskId}] task completed`, projectPath: tmpRoot, skipTests: true,
+    });
+
+    assert.equal(result.merged, true, 'the agent commits on task/<id> must land on the user branch');
+    assert.ok(fs.existsSync(path.join(tmpRoot, 'src', 'a.js')), 'src/a.js must land on main');
+    assert.ok(fs.existsSync(path.join(tmpRoot, 'src', 'b.js')), 'src/b.js must land on main');
+
+    // task/<id> must never have been rewritten with a substitute commit before
+    // the merge: no *_salvage_* branch, and if the ref still exists its tip
+    // must still be the agent's own commit.
+    const branches = gitSafe('git branch -a') || '';
+    assert.doesNotMatch(branches, new RegExp(`${taskId.toLowerCase()}_salvage_`),
+      `no *_salvage_* branch should have been created — got:\n${branches}`);
+    const tipAfter = gitSafe(`git rev-parse --verify --quiet refs/heads/${taskBranch}`);
+    if (tipAfter) {
+      assert.equal(tipAfter, agentCommitSha,
+        `${taskBranch} head must still be the agent's own commit, not a substitute commit made from main's dirty tree`);
+    }
+
+    // Main's own dirty tracked file must be left exactly as it was — still
+    // modified, uncommitted — never swept into the task branch.
+    const unstagedDiff = (gitSafe('git diff --name-only -- README.md') || '').trim();
+    assert.equal(unstagedDiff, 'README.md',
+      'README.md must still show as an unstaged modification after the merge');
+    const stagedDiff = (gitSafe('git diff --cached --name-only -- README.md') || '').trim();
+    assert.equal(stagedDiff, '', 'README.md must not have been staged or committed');
+    assert.equal(
+      fs.readFileSync(path.join(tmpRoot, 'README.md'), 'utf8').replace(/\r\n/g, '\n'),
+      'init\nmain dirt\n',
+    );
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+// Ansuz review gap on the TASK_2035 fix above: task/<id> being ahead of
+// userBranch is not proof it holds the CURRENT real work — it could be a
+// STALE branch from an earlier failed attempt while the agent's actual
+// (current) work sits uncommitted in the main tree, within this task's
+// declared scope_paths. Step 0.06 must refuse to guess in that case: no
+// merge, no rewrite of either side, blockedReason='ambiguous_task_branch'.
+test('TASK_2035: gitBranchAndMerge refuses to guess when task/<id> is ahead AND main has in-scope uncommitted dirt (ambiguous_task_branch)', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-t2035-ambig-'));
+  try {
+    makeGitRepo(tmpRoot);
+    git('git config commit.gpgsign false', tmpRoot);
+    const gitSafe = (cmd) => { try { return git(cmd, tmpRoot); } catch { return null; } };
+    gitSafe('git checkout -b xyz9516');
+
+    const taskId = 'TASK_9036';
+    const taskBranch = `task/${taskId.toLowerCase()}`;
+
+    // Seed the in-scope file as already tracked so a later edit shows as a
+    // MODIFICATION (not a new untracked file) — the realistic shape of "the
+    // agent is mid-edit in the main tree".
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'a.js'), 'export const a = 0;\n');
+    git('git add -A', tmpRoot);
+    git('git commit --no-verify -m "seed src/a.js"', tmpRoot);
+
+    // Task card declares scope_paths=['src/a.js'].
+    const activeDir = path.join(tmpRoot, '.kenaz', 'tasks', 'active');
+    fs.mkdirSync(activeDir, { recursive: true });
+    fs.writeFileSync(path.join(activeDir, `${taskId}.yaml`), [
+      `id: "${taskId}"`,
+      `title: "repro"`,
+      `status: active`,
+      `scope_paths:`,
+      `  - "src/a.js"`,
+      ``,
+    ].join('\n'));
+    git('git add -A', tmpRoot);
+    git('git commit --no-verify -m "add task yaml"', tmpRoot);
+
+    // A STALE task/<id> branch from an earlier, unrelated attempt — ahead of
+    // userBranch, but NOT necessarily today's real work.
+    gitSafe(`git checkout -b ${taskBranch} xyz9516`);
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'stale.js'), 'export const stale = 1;\n');
+    git('git add -A', tmpRoot);
+    git(`git commit --no-verify -m "[${taskId}] stale prior attempt"`, tmpRoot);
+    const staleTipBefore = git('git rev-parse HEAD', tmpRoot);
+
+    // Back on the user branch: the agent's CURRENT work is an uncommitted,
+    // in-scope edit to src/a.js — this is what makes the branch ambiguous.
+    git('git checkout xyz9516', tmpRoot);
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'a.js'), 'export const a = 1; // in-progress edit\n');
+
+    const result = gitBranchAndMerge({
+      taskId, message: `[${taskId}] task completed`, projectPath: tmpRoot, skipTests: true,
+    });
+
+    assert.equal(result.merged, false, 'must not merge either side when ambiguous');
+    assert.equal(result.committed, false, 'must not commit anything when ambiguous');
+    assert.equal(result.blockedReason, 'ambiguous_task_branch');
+    assert.equal(result.failure_reason, 'ambiguous_task_branch');
+
+    // task/<id> must be completely untouched — same tip, no rename/rewrite.
+    const tipAfter = gitSafe(`git rev-parse --verify --quiet refs/heads/${taskBranch}`);
+    assert.equal(tipAfter, staleTipBefore, `${taskBranch} must not be rewritten while ambiguous`);
+
+    // No *_salvage_* branch created on either side.
+    const branches = gitSafe('git branch -a') || '';
+    assert.doesNotMatch(branches, new RegExp(`${taskId.toLowerCase()}_salvage_`),
+      `no *_salvage_* branch should have been created — got:\n${branches}`);
+
+    // The in-scope uncommitted edit in the main tree must still be dirty,
+    // untouched — never swept, stashed-and-lost, or committed.
+    const unstagedDiff = (gitSafe('git diff --name-only -- src/a.js') || '').trim();
+    assert.equal(unstagedDiff, 'src/a.js', 'src/a.js must still show as an unstaged modification');
+    assert.equal(
+      fs.readFileSync(path.join(tmpRoot, 'src', 'a.js'), 'utf8').replace(/\r\n/g, '\n'),
+      'export const a = 1; // in-progress edit\n',
+    );
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+// ── TASK_2066: shared-tree (serial_lock/direct, no task worktree) complete must
+// never auto-stage dirty scope_paths files into a task commit ────────────────
+//
+// Field report (Ashfall TASK_441, 2026-09-26): all agent work was already
+// committed on main. scope_paths overlapped directories/scenes the USER was
+// mid-editing (Prefabs/, Scenes/*.unity). Running task-api.js complete printed
+// "Committed on task/task_441" + "Merged task/task_441 -> main" and created a
+// commit containing 7 files the agent never touched (incl. a +5514-line
+// unsaved scene). Root cause: gitAddSafe (staging.js, `git add -- "<scope_path>"`
+// per declared path) stages whatever is currently dirty under a scope path with
+// no notion of WHO dirtied it, and gitBranchAndMerge's step 0.05 direct-commit
+// fast path used to require "no in-scope dirt" before skipping, so any leftover
+// dirt (however unrelated) fell through into the branch/stash/gitAddSafe
+// pipeline. Fix: shared-tree mode never auto-stages by scope_paths — it only
+// trusts a commit the executor already made, and otherwise refuses and lists
+// the dirty in-scope files.
+
+test('TASK_2066: shared-tree complete refuses (no commit/merge) when scope_paths has a pre-existing dirty file and no executor commit exists', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-t2066-nocommit-'));
+  try {
+    makeGitRepo(tmpRoot);
+    git('git config commit.gpgsign false', tmpRoot);
+    const gitSafe = (cmd) => { try { return git(cmd, tmpRoot); } catch { return null; } };
+    gitSafe('git checkout -b xyz9516');
+
+    const taskId = 'TASK_9066A';
+
+    // Scene/prefab-like file the USER is mid-editing — tracked, then dirtied.
+    fs.mkdirSync(path.join(tmpRoot, 'Scenes'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'Scenes', 'Sandbox.unity'), 'scene v1\n');
+    git('git add -A', tmpRoot);
+    git('git commit --no-verify -m "seed Scenes/Sandbox.unity"', tmpRoot);
+
+    // Task card declares scope_paths covering that same directory (the
+    // Ashfall shape: scope overlaps a directory the user, not the agent, edits).
+    const activeDir = path.join(tmpRoot, '.kenaz', 'tasks', 'active');
+    fs.mkdirSync(activeDir, { recursive: true });
+    fs.writeFileSync(path.join(activeDir, `${taskId}.yaml`), [
+      `id: "${taskId}"`,
+      `title: "repro"`,
+      `status: active`,
+      `scope_paths:`,
+      `  - "Scenes/"`,
+      ``,
+    ].join('\n'));
+    git('git add -A', tmpRoot);
+    git('git commit --no-verify -m "add task yaml"', tmpRoot);
+
+    // The user's uncommitted WIP — no executor commit for this task exists
+    // anywhere (no direct commit on xyz9516, no task/<id> branch).
+    fs.writeFileSync(path.join(tmpRoot, 'Scenes', 'Sandbox.unity'), 'scene v1\nuser unsaved edit\n');
+
+    const result = gitBranchAndMerge({
+      taskId, message: `[${taskId}] task completed`, projectPath: tmpRoot, skipTests: true,
+    });
+
+    assert.equal(result.committed, false, 'must not create a commit from unattributed in-scope dirt');
+    assert.equal(result.merged, false, 'must not merge anything');
+    assert.equal(result.blockedReason, 'dirty_in_scope_uncommitted');
+    assert.equal(result.failure_reason, 'dirty_in_scope_uncommitted');
+    assert.ok(Array.isArray(result.dirtyInScopePaths) && result.dirtyInScopePaths.some(p => p.includes('Sandbox.unity')),
+      `dirtyInScopePaths must list the dirty file — got: ${JSON.stringify(result.dirtyInScopePaths)}`);
+
+    // No task/<id> branch was created, and the file is still dirty & unstaged.
+    const branches = gitSafe('git branch -a') || '';
+    assert.doesNotMatch(branches, new RegExp(`task/${taskId.toLowerCase()}`), 'no task branch should have been created');
+    const unstagedDiff = (gitSafe('git diff --name-only -- Scenes/Sandbox.unity') || '').trim();
+    assert.equal(unstagedDiff, 'Scenes/Sandbox.unity', 'the user edit must still be an unstaged modification');
+    const stagedDiff = (gitSafe('git diff --cached --name-only -- Scenes/Sandbox.unity') || '').trim();
+    assert.equal(stagedDiff, '', 'the user edit must never have been staged');
+    assert.equal(
+      fs.readFileSync(path.join(tmpRoot, 'Scenes', 'Sandbox.unity'), 'utf8').replace(/\r\n/g, '\n'),
+      'scene v1\nuser unsaved edit\n',
+    );
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('TASK_2066: shared-tree complete with an executor commit already on the user branch does not stage a leftover in-scope dirty file', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-t2066-committed-'));
+  try {
+    makeGitRepo(tmpRoot);
+    git('git config commit.gpgsign false', tmpRoot);
+    const gitSafe = (cmd) => { try { return git(cmd, tmpRoot); } catch { return null; } };
+    gitSafe('git checkout -b xyz9516');
+
+    const taskId = 'TASK_9066B';
+
+    // Seed both scope files as tracked.
+    fs.mkdirSync(path.join(tmpRoot, 'src'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'a.js'), 'export const a = 0;\n');
+    fs.mkdirSync(path.join(tmpRoot, 'Scenes'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'Scenes', 'Sandbox.unity'), 'scene v1\n');
+    git('git add -A', tmpRoot);
+    git('git commit --no-verify -m "seed"', tmpRoot);
+
+    // Task declares scope over BOTH the file the executor will touch AND the
+    // scene the user is (separately, concurrently) mid-editing.
+    const activeDir = path.join(tmpRoot, '.kenaz', 'tasks', 'active');
+    fs.mkdirSync(activeDir, { recursive: true });
+    fs.writeFileSync(path.join(activeDir, `${taskId}.yaml`), [
+      `id: "${taskId}"`,
+      `title: "repro"`,
+      `status: active`,
+      `scope_paths:`,
+      `  - "src/a.js"`,
+      `  - "Scenes/"`,
+      ``,
+    ].join('\n'));
+    git('git add -A', tmpRoot);
+    git('git commit --no-verify -m "add task yaml"', tmpRoot);
+
+    // Executor already committed ITS work directly on the shared tree.
+    fs.writeFileSync(path.join(tmpRoot, 'src', 'a.js'), 'export const a = 1;\n');
+    git('git add src/a.js', tmpRoot);
+    git(`git commit --no-verify -m "[${taskId}] task completed"`, tmpRoot);
+    const executorCommitSha = git('git rev-parse HEAD', tmpRoot);
+
+    // Concurrently, the user is mid-editing the scene — never committed,
+    // not the executor's work, but it lives under the same declared scope.
+    fs.writeFileSync(path.join(tmpRoot, 'Scenes', 'Sandbox.unity'), 'scene v1\nuser unsaved edit\n');
+
+    const result = gitBranchAndMerge({
+      taskId, message: `[${taskId}] task completed`, projectPath: tmpRoot, skipTests: true,
+    });
+
+    assert.equal(result.merged, true, 'the executor’s own commit must be recognized as landed');
+    assert.equal(result.committed, true);
+    assert.equal(result.verify_merge_landed_reason, 'direct_commit_on_user_branch');
+    assert.equal(result.directCommitHash, executorCommitSha);
+
+    // HEAD must still be the executor's own commit — nothing extra was committed.
+    const headAfter = git('git rev-parse HEAD', tmpRoot);
+    assert.equal(headAfter, executorCommitSha, 'no additional commit must have been created');
+
+    // The user's scene edit must be left exactly as it was — dirty, unstaged,
+    // never swept into a commit.
+    const unstagedDiff = (gitSafe('git diff --name-only -- Scenes/Sandbox.unity') || '').trim();
+    assert.equal(unstagedDiff, 'Scenes/Sandbox.unity', 'the user edit must still be an unstaged modification');
+    const stagedDiff = (gitSafe('git diff --cached --name-only -- Scenes/Sandbox.unity') || '').trim();
+    assert.equal(stagedDiff, '', 'the user edit must never have been staged');
+    assert.equal(
+      fs.readFileSync(path.join(tmpRoot, 'Scenes', 'Sandbox.unity'), 'utf8').replace(/\r\n/g, '\n'),
+      'scene v1\nuser unsaved edit\n',
+    );
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+// ── TASK_1430: ansuz_inbox idempotency + null-null dup guard ──────────────────
+
+test('writeInboxEntryIdempotent: 10 rapid calls produce at most 1 task_completed entry (TASK_1430)', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-inbox-idem-'));
+  try {
+    const specialistDir = path.join(tmpDir, '.kenaz', 'specialist');
+    fs.mkdirSync(specialistDir, { recursive: true });
+    const inboxFile = path.join(specialistDir, 'ansuz_inbox.json');
+
+    // Deterministic ID mirrors prod behaviour: same commit-bucket → same id
+    const entry = {
+      id: 'task_completed_TASK_X_abc123def456',
+      type: 'task_completed',
+      task_id: 'TASK_X',
+      task_title: 'Test Task',
+      completed_at: new Date().toISOString(),
+      branch: null,
+    };
+
+    for (let i = 0; i < 10; i++) {
+      writeInboxEntryIdempotent(inboxFile, specialistDir, entry);
+    }
+
+    const inbox = JSON.parse(fs.readFileSync(inboxFile, 'utf8'));
+    assert.equal(inbox.messages.length, 1, 'exactly 1 entry after 10 identical writes');
+    assert.equal(inbox.messages[0].task_id, 'TASK_X');
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('writeInboxEntryIdempotent: processed entries do not block new writes for same task_id (TASK_1430)', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-inbox-proc-'));
+  try {
+    const specialistDir = path.join(tmpDir, '.kenaz', 'specialist');
+    fs.mkdirSync(specialistDir, { recursive: true });
+    const inboxFile = path.join(specialistDir, 'ansuz_inbox.json');
+
+    const entry = {
+      id: 'task_completed_TASK_Y_aaa',
+      type: 'task_completed',
+      task_id: 'TASK_Y',
+      task_title: 'Task Y',
+      completed_at: new Date().toISOString(),
+      branch: null,
+    };
+
+    // Write once, then mark it as processed
+    writeInboxEntryIdempotent(inboxFile, specialistDir, entry);
+    const inbox = JSON.parse(fs.readFileSync(inboxFile, 'utf8'));
+    inbox.processed_ids = [entry.id];
+    require('fs').writeFileSync(inboxFile, JSON.stringify(inbox, null, 2), 'utf8');
+
+    // New entry with different ID (e.g. after a re-run on a new commit) should be allowed
+    const entry2 = { ...entry, id: 'task_completed_TASK_Y_bbb' };
+    const r = writeInboxEntryIdempotent(inboxFile, specialistDir, entry2);
+    assert.equal(r.written, true, 'new entry should be written when prior entry is processed');
+
+    const inbox2 = JSON.parse(fs.readFileSync(inboxFile, 'utf8'));
+    assert.equal(inbox2.messages.length, 2);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('checkAndUpdatePostCompleteGuard: null→null retry within 30s is suppressed (TASK_1430)', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-guard-nn-'));
+  try {
+    const guardFile = path.join(tmpDir, 'post-complete-guard.json');
+    const taskId = 'TASK_NULL_RETRY';
+
+    // First call with no worktreePath — establishes guard entry
+    const first = checkAndUpdatePostCompleteGuard(guardFile, taskId, null);
+    assert.equal(first, null, 'first call should not be suppressed');
+    assert.ok(fs.existsSync(guardFile), 'guard file should be written');
+
+    // Second call within 30s with null worktreePath — should be suppressed
+    const second = checkAndUpdatePostCompleteGuard(guardFile, taskId, null);
+    assert.ok(second !== null, 'second null→null call should be suppressed');
+    assert.equal(second.skipped, true);
+    assert.equal(second.nullNullRetry, true, 'nullNullRetry flag must be set');
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('checkAndUpdatePostCompleteGuard: worktree→null still fires (TASK_1430)', () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-guard-wt-'));
+  try {
+    const guardFile = path.join(tmpDir, 'post-complete-guard.json');
+    const taskId = 'TASK_WT_NULL';
+
+    // First call with a worktreePath — establishes guard with worktreePath set
+    const first = checkAndUpdatePostCompleteGuard(guardFile, taskId, '/some/worktree');
+    assert.equal(first, null, 'worktree call should not be suppressed');
+
+    // Second call with null worktreePath within 120s — worktree→null guard fires
+    const second = checkAndUpdatePostCompleteGuard(guardFile, taskId, null);
+    assert.ok(second !== null, 'worktree→null call within 120s should be suppressed');
+    assert.equal(second.skipped, true);
+    assert.equal(second.previousWorktreePath, '/some/worktree');
+    assert.ok(!second.nullNullRetry, 'should not be flagged as nullNullRetry');
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+// ── Health snapshot enrichment tests (TASK_1431) ─────────────────────────────
+
+test('saveTaskHealthSnapshot: delta_from_previous computed against most recent prior _after snapshot', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-health-delta-'));
+  try {
+    const snapshotsDir = path.join(tmpRoot, '.kenaz', 'health_snapshots');
+    fs.mkdirSync(snapshotsDir, { recursive: true });
+
+    // Write a prior _after snapshot with a slightly older timestamp
+    fs.writeFileSync(
+      path.join(snapshotsDir, 'TASK_100_after.json'),
+      JSON.stringify({
+        score: 45.0, grade: 'F (Critical)', score_version: 'memory-v1',
+        timestamp: new Date(Date.now() - 10000).toISOString(), sub_metrics: {},
+      }, null, 2)
+    );
+
+    saveTaskHealthSnapshot('TASK_200', 'after', { score: 47.0, grade: 'F (Critical)', sub_metrics: { degree_entropy: { score: 60 } } }, tmpRoot);
+
+    const saved = JSON.parse(fs.readFileSync(path.join(snapshotsDir, 'TASK_200_after.json'), 'utf8'));
+    assert.equal(saved.score, 47.0);
+    assert.equal(saved.delta_from_previous, 2.0, 'delta should be 47 - 45 = 2.0');
+    assert.equal(saved.trend_5tasks, null, 'trend_5tasks is null when <5 priors');
+    assert.ok(saved.sub_metrics && typeof saved.sub_metrics === 'object', 'sub_metrics should be present');
+    assert.ok(saved.timestamp, 'timestamp must be present');
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('saveTaskHealthSnapshot: trend_5tasks=null when fewer than 5 prior _after snapshots', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-health-trend4-'));
+  try {
+    const snapshotsDir = path.join(tmpRoot, '.kenaz', 'health_snapshots');
+    fs.mkdirSync(snapshotsDir, { recursive: true });
+
+    // Write exactly 4 prior _after snapshots (one short of 5)
+    for (let i = 0; i < 4; i++) {
+      fs.writeFileSync(
+        path.join(snapshotsDir, `TASK_${100 + i}_after.json`),
+        JSON.stringify({
+          score: 45.0 + i, grade: 'F (Critical)', score_version: 'memory-v1',
+          timestamp: new Date(Date.now() - (4 - i) * 10000).toISOString(), sub_metrics: {},
+        }, null, 2)
+      );
+    }
+
+    saveTaskHealthSnapshot('TASK_200', 'after', { score: 50.0, grade: 'D (Poor)', sub_metrics: {} }, tmpRoot);
+
+    const saved = JSON.parse(fs.readFileSync(path.join(snapshotsDir, 'TASK_200_after.json'), 'utf8'));
+    assert.equal(saved.trend_5tasks, null, 'trend_5tasks must be null when only 4 priors exist');
+    assert.ok(typeof saved.delta_from_previous === 'number', 'delta_from_previous should be a number when 1+ prior exists');
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('saveTaskHealthSnapshot: trend_5tasks computed when exactly 5 prior snapshots exist', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-health-trend5-'));
+  try {
+    const snapshotsDir = path.join(tmpRoot, '.kenaz', 'health_snapshots');
+    fs.mkdirSync(snapshotsDir, { recursive: true });
+
+    // 5 prior snapshots: scores 40,41,42,43,44 (newest=44 at i=4, oldest=40 at i=0)
+    for (let i = 0; i < 5; i++) {
+      fs.writeFileSync(
+        path.join(snapshotsDir, `TASK_${100 + i}_after.json`),
+        JSON.stringify({
+          score: 40.0 + i, grade: 'F (Critical)', score_version: 'memory-v1',
+          timestamp: new Date(Date.now() - (5 - i) * 10000).toISOString(), sub_metrics: {},
+        }, null, 2)
+      );
+    }
+
+    // current score=50; priors newest-first=[44,43,42,41,40]; 5th prior = 40
+    // trend_5tasks = 50 - 40 = 10
+    saveTaskHealthSnapshot('TASK_200', 'after', { score: 50.0, grade: 'D (Poor)', sub_metrics: {} }, tmpRoot);
+
+    const saved = JSON.parse(fs.readFileSync(path.join(snapshotsDir, 'TASK_200_after.json'), 'utf8'));
+    assert.equal(saved.trend_5tasks, 10.0, 'trend_5tasks = currentScore - score5TasksAgo = 50 - 40');
+    assert.equal(saved.delta_from_previous, 6.0, 'delta_from_previous = 50 - 44 (most recent prior)');
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('saveTaskHealthSnapshot: sub_metrics object passes through from health response', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-health-subm-'));
+  try {
+    const snapshotsDir = path.join(tmpRoot, '.kenaz', 'health_snapshots');
+    fs.mkdirSync(snapshotsDir, { recursive: true });
+
+    const subMetrics = {
+      degree_entropy: { score: 60.5, weight: 0.25, excluded_count: 3 },
+      community_balance: { score: 45.0, weight: 0.20 },
+    };
+    saveTaskHealthSnapshot('TASK_300', 'after', { score: 52.0, grade: 'D (Poor)', sub_metrics: subMetrics }, tmpRoot);
+
+    const saved = JSON.parse(fs.readFileSync(path.join(snapshotsDir, 'TASK_300_after.json'), 'utf8'));
+    assert.deepEqual(saved.sub_metrics, subMetrics, 'sub_metrics should be stored unchanged');
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('readPreTaskHealthSnapshot: old snapshot without enrichment fields loads without error', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-health-compat-'));
+  try {
+    const snapshotsDir = path.join(tmpRoot, '.kenaz', 'health_snapshots');
+    fs.mkdirSync(snapshotsDir, { recursive: true });
+
+    // Old-format snapshot: only score, grade, timestamp (no sub_metrics/delta/trend)
+    fs.writeFileSync(
+      path.join(snapshotsDir, 'TASK_OLD_before.json'),
+      JSON.stringify({ score: 48.0, grade: 'F (Critical)', timestamp: new Date().toISOString() }, null, 2)
+    );
+
+    const sn = readPreTaskHealthSnapshot('TASK_OLD', tmpRoot);
+    assert.ok(sn, 'old snapshot should load without error');
+    assert.equal(sn.score, 48.0, 'score should be readable');
+    // New fields are absent in old snapshots — undefined is fine, not an error
+    assert.equal(sn.delta_from_previous, undefined, 'missing delta_from_previous is undefined not error');
+    assert.equal(sn.sub_metrics, undefined, 'missing sub_metrics is undefined not error');
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+// ---- TASK_1674: untracked-path collision tests --------------------------------
+
+test('_neutralizeUntrackedCollisions: TASK_1674 -- untracked file collides with task-branch-added path, merge proceeds and WIP preserved', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pc-t1674-"));
+  try {
+    makeGitRepo(tmpRoot);
+    const userBranch = execSync("git rev-parse --abbrev-ref HEAD", { cwd: tmpRoot, encoding: "utf8" }).trim();
+    fs.mkdirSync(path.join(tmpRoot, "ref"), { recursive: true });
+    git("git checkout -b task/task_t1674", tmpRoot);
+    fs.writeFileSync(path.join(tmpRoot, "ref/data.xlsx"), Buffer.from("tracked-by-task-branch"));
+    git("git add ref/data.xlsx", tmpRoot);
+    git("git commit --no-verify -m \"[TASK_T1674] add ref data\"", tmpRoot);
+    const taskBranch = "task/task_t1674";
+    git("git checkout " + userBranch, tmpRoot);
+    fs.mkdirSync(path.join(tmpRoot, "ref"), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, "ref/data.xlsx"), Buffer.from("untracked-wip-content"));
+    fs.writeFileSync(path.join(tmpRoot, "README.md"), "modified README");
+    const statusBefore = execSync("git status --porcelain", { cwd: tmpRoot, encoding: "utf8" }).trim();
+    assert.ok(statusBefore.includes("?? ref/") || statusBefore.includes("?? ref/data.xlsx"), "untracked ref/data.xlsx must appear in git status");
+    const neutralized = _neutralizeUntrackedCollisions(tmpRoot, taskBranch, userBranch);
+    assert.ok(neutralized.colliding.length > 0, "should find at least 1 colliding path");
+    assert.ok(neutralized.colliding.some(function(p) { return p === "ref/data.xlsx"; }), "ref/data.xlsx must be in colliding list");
+    assert.ok(neutralized.saved["ref/data.xlsx"], "saved bytes must exist for ref/data.xlsx");
+    assert.ok(!fs.existsSync(path.join(tmpRoot, "ref/data.xlsx")), "ref/data.xlsx must be removed from disk after neutralize");
+    assert.equal(fs.readFileSync(path.join(tmpRoot, "README.md"), "utf8"), "modified README", "(b) unrelated WIP README.md must be untouched by neutralize");
+    git("git merge task/task_t1674 --no-ff -m \"Merge TASK_T1674\"", tmpRoot);
+    const mergedContent = fs.readFileSync(path.join(tmpRoot, "ref/data.xlsx"));
+    assert.equal(mergedContent.toString(), "tracked-by-task-branch", "(a) task branch content must be present on userBranch after merge");
+    _restoreNeutralizedCollisions(tmpRoot, neutralized.saved, false);
+    const afterRestore = fs.readFileSync(path.join(tmpRoot, "ref/data.xlsx"));
+    assert.equal(afterRestore.toString(), "tracked-by-task-branch", "(a) merged version must not be clobbered by non-force restore");
+    assert.equal(fs.readFileSync(path.join(tmpRoot, "README.md"), "utf8"), "modified README", "(b) unrelated WIP README.md preserved after merge");
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+test('_restoreNeutralizedCollisions: force=true restores all WIP when merge fails (TASK_1674)', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "pc-t1674-force-"));
+  try {
+    makeGitRepo(tmpRoot);
+    fs.mkdirSync(path.join(tmpRoot, "ref"), { recursive: true });
+    const wip = Buffer.from("original-wip-bytes");
+    const saved = {};
+    saved["ref/data.xlsx"] = wip;
+    _restoreNeutralizedCollisions(tmpRoot, saved, true);
+    assert.ok(fs.existsSync(path.join(tmpRoot, "ref/data.xlsx")), "ref/data.xlsx must be restored when force=true");
+    assert.equal(fs.readFileSync(path.join(tmpRoot, "ref/data.xlsx")).toString(), "original-wip-bytes", "WIP content must match original bytes after force restore");
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});
+
+// ---- TASK_1679: CJK/non-ASCII untracked-path collision regression test ------
+
+test('_neutralizeUntrackedCollisions: TASK_1679 -- CJK filename collides with task-branch-added path, merge proceeds and WIP preserved', () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'pc-t1679-'));
+  try {
+    makeGitRepo(tmpRoot);
+    const userBranch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: tmpRoot, encoding: 'utf8' }).trim();
+    // Set up task branch that ADDS a CJK-named file
+    fs.mkdirSync(path.join(tmpRoot, 'ref'), { recursive: true });
+    git('git checkout -b task/task_t1679', tmpRoot);
+    fs.writeFileSync(path.join(tmpRoot, 'ref/數據.xlsx'), Buffer.from('tracked-by-task-branch'));
+    git('git add ref', tmpRoot);
+    git('git commit --no-verify -m "[TASK_T1679] add CJK ref data"', tmpRoot);
+    const taskBranch = 'task/task_t1679';
+    // Switch back to user branch, place untracked CJK WIP + unrelated WIP
+    git('git checkout ' + userBranch, tmpRoot);
+    fs.mkdirSync(path.join(tmpRoot, 'ref'), { recursive: true });
+    fs.writeFileSync(path.join(tmpRoot, 'ref/數據.xlsx'), Buffer.from('untracked-cjk-wip-content'));
+    fs.writeFileSync(path.join(tmpRoot, 'README.md'), 'modified README by CJK test');
+    // Verify git reports the CJK file as untracked (core.quotePath=true default would quote it)
+    const statusBefore = execSync('git -c core.quotePath=false status --porcelain', { cwd: tmpRoot, encoding: 'utf8' }).trim();
+    assert.ok(
+      statusBefore.includes('?? ref/') || statusBefore.includes('?? ref/數據.xlsx'),
+      'untracked CJK ref/數據.xlsx must appear in git status'
+    );
+    // (1) Collision must be detected -- this was the bug: CJK paths returned colliding=[]
+    const neutralized = _neutralizeUntrackedCollisions(tmpRoot, taskBranch, userBranch);
+    assert.ok(neutralized.colliding.length > 0, 'TASK_1679: should find at least 1 colliding CJK path');
+    assert.ok(
+      neutralized.colliding.some(function(p) { return p === 'ref/數據.xlsx'; }),
+      'TASK_1679: ref/數據.xlsx must be in colliding list'
+    );
+    assert.ok(neutralized.saved['ref/數據.xlsx'], 'saved bytes must exist for CJK path');
+    assert.ok(!fs.existsSync(path.join(tmpRoot, 'ref/數據.xlsx')), 'CJK file must be removed from disk after neutralize');
+    // (2) Unrelated WIP must be untouched
+    assert.equal(fs.readFileSync(path.join(tmpRoot, 'README.md'), 'utf8'), 'modified README by CJK test', '(b) unrelated WIP README.md must be untouched by neutralize');
+    // (3) Merge must land task branch content
+    git('git merge task/task_t1679 --no-ff -m "Merge TASK_T1679"', tmpRoot);
+    const mergedContent = fs.readFileSync(path.join(tmpRoot, 'ref/數據.xlsx'));
+    assert.equal(mergedContent.toString(), 'tracked-by-task-branch', '(a) task branch CJK content must land on userBranch after merge');
+    // (4) Non-force restore must not clobber merged version
+    _restoreNeutralizedCollisions(tmpRoot, neutralized.saved, false);
+    const afterRestore = fs.readFileSync(path.join(tmpRoot, 'ref/數據.xlsx'));
+    assert.equal(afterRestore.toString(), 'tracked-by-task-branch', '(a) merged CJK version must not be clobbered by non-force restore');
+    assert.equal(fs.readFileSync(path.join(tmpRoot, 'README.md'), 'utf8'), 'modified README by CJK test', '(b) unrelated WIP README.md preserved after merge');
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+});