@mmnto/cli 1.119.0 → 1.121.0

package/dist/commands/install-hooks.test.js

@@ -5,6 +5,15 @@ import * as path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { cleanTmpDir } from '../test-utils.js';
 import { buildHookContent, buildPostCheckoutHookContent, buildPreCommitHook, buildPrePushHook, buildResolveBlock, checkHooksInstalled, detectTotemPrefix, generateHookHelpers, getFallbackCommand, installGitHook, installHooksNonInteractive, TOTEM_HOOK_END, TOTEM_HOOK_MARKER, TOTEM_PRECOMMIT_END, TOTEM_PRECOMMIT_MARKER, TOTEM_PREPUSH_END, TOTEM_PREPUSH_MARKER, upgradePrePushHookIfNeeded, } from './install-hooks.js';
+// The default render options every pre-#2692 positional call implied
+// (mmnto-ai/totem#2692 C2 — the builders take a REQUIRED options object now, so
+// each site states the tier/totemDir/fallbackCmd it always assumed). Spread and
+// override the one field a case actually varies.
+const RENDER = {
+    tier: 'standard',
+    totemDir: '.totem',
+    fallbackCmd: 'pnpm dlx @mmnto/cli',
+};
 describe('detectTotemPrefix', () => {
     let tmpDir;
     beforeEach(() => {
@@ -152,76 +161,75 @@ describe('buildResolveBlock', () => {
 });
 describe('buildPreCommitHook', () => {
     it('contains the marker for idempotency', () => {
-        const hook = buildPreCommitHook();
+        const hook = buildPreCommitHook(RENDER);
         expect(hook).toContain(TOTEM_PRECOMMIT_MARKER);
     });
     it('blocks main and master branches', () => {
-        const hook = buildPreCommitHook();
+        const hook = buildPreCommitHook(RENDER);
         expect(hook).toContain('"main"');
         expect(hook).toContain('"master"');
     });
     it('prints a helpful error message with override instructions', () => {
-        const hook = buildPreCommitHook();
+        const hook = buildPreCommitHook(RENDER);
         expect(hook).toContain('git checkout -b feat/my-feature');
         expect(hook).toContain('git commit --no-verify');
     });
     it('starts with a shebang', () => {
-        const hook = buildPreCommitHook();
+        const hook = buildPreCommitHook(RENDER);
         expect(hook).toMatch(/^#!\/bin\/sh\n/);
     });
     it('exits with code 1 when on protected branch', () => {
-        const hook = buildPreCommitHook();
+        const hook = buildPreCommitHook(RENDER);
         expect(hook).toContain('exit 1');
     });
 });
 describe('buildPrePushHook', () => {
-    const FALLBACK = 'pnpm dlx @mmnto/cli';
     it('contains the marker for idempotency', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toContain(TOTEM_PREPUSH_MARKER);
     });
     it('starts with a shebang', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toMatch(/^#!\/bin\/sh\n/);
     });
     it('does not advertise --no-verify escape hatch', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).not.toContain('--no-verify');
     });
     it('contains verify-manifest check', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toContain('verify-manifest');
         expect(hook).toContain('compile manifest is stale');
     });
     it('contains $TOTEM_CMD lint', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toContain('$TOTEM_CMD lint');
     });
     // totem-context: hook-content assertion (not an orchestrator test, no LLM calls — default vitest timeout is sufficient)
     it('contains $TOTEM_CMD verify-badges (mmnto-ai/totem#1926)', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         // totem-context: substring match on hook script content (not secret masking) — toContain is correct here
         expect(hook).toContain('$TOTEM_CMD verify-badges');
     });
     // totem-context: hook-content assertion (not an orchestrator test, no LLM calls — default vitest timeout is sufficient)
     it('gates verify-badges on README.md existing', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toMatch(/-f "README\.md".*verify-badges/s);
     });
     // totem-context: hook-content assertion (not an orchestrator test, no LLM calls — default vitest timeout is sufficient)
     it('contains $TOTEM_CMD verify-lockfile-sync (mmnto-ai/totem#1961)', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         // totem-context: substring match on hook script content (not secret masking) — toContain is correct here
         expect(hook).toContain('$TOTEM_CMD verify-lockfile-sync');
     });
     // totem-context: hook-content assertion (not an orchestrator test, no LLM calls — default vitest timeout is sufficient)
     it('gates verify-lockfile-sync on pnpm-lock.yaml existing', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toMatch(/-f "pnpm-lock\.yaml".*verify-lockfile-sync/s);
     });
     // totem-context: hook-content assertion (not an orchestrator test, no LLM calls — default vitest timeout is sufficient)
     it('slots verify-lockfile-sync before claim-discipline in the pre-push sequence', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         // Assert presence with toContain (precise matcher); index comparison is
         // safe only because both substrings are guaranteed present by the
         // toContain assertions above.
@@ -235,12 +243,12 @@ describe('buildPrePushHook', () => {
     });
     // totem-context: hook-content assertion (not an orchestrator test, no LLM calls — default vitest timeout is sufficient)
     it('contains $TOTEM_CMD doctor --claim-discipline --strict (Proposal 279 Q3)', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toContain('$TOTEM_CMD doctor --claim-discipline --strict');
     });
     // totem-context: hook-content assertion (mmnto-ai/totem#2002 — diff-scope narrowing)
     it('contains --scope-to-diff on the claim-discipline invocation (mmnto-ai/totem#2002)', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         // The flag must appear on the same `doctor --claim-discipline` line so the
         // hook narrows the WWND scan to diff-touched files. Standing-gate full scan
         // produced N=8 false-positive bypasses in <24hr on a pre-existing surface
@@ -249,7 +257,7 @@ describe('buildPrePushHook', () => {
     });
     // totem-context: hook-content assertion (mmnto-ai/totem#2002 — bootstrap defensive degrade)
     it('defensively degrades --scope-to-diff when CLI predates 1.47.0 (cohort bootstrap safety)', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         // The hook MUST detect --scope-to-diff support via --help and fall back to
         // standing-scan when the resolved CLI doesn't carry the flag. Required so a
         // cohort agent whose global @mmnto/cli predates 1.47.0 doesn't fail commander
@@ -270,13 +278,13 @@ describe('buildPrePushHook', () => {
     });
     // totem-context: hook-content assertion (not an orchestrator test, no LLM calls — default vitest timeout is sufficient)
     it('gates claim-discipline on at-least-one in-scope public surface existing', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         // The gate fires when any of README.md, AGENTS.md, design-tenets.md, or docs/wiki/ exists
         expect(hook).toMatch(/-f "README\.md".*-f "AGENTS\.md".*-f "design-tenets\.md".*-d "docs\/wiki"/s);
     });
     // totem-context: hook-content assertion (not an orchestrator test, no LLM calls — default vitest timeout is sufficient)
     it('slots claim-discipline after verify-badges in the pre-push sequence', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         const verifyBadgesIdx = hook.indexOf('$TOTEM_CMD verify-badges');
         const claimDisciplineIdx = hook.indexOf('$TOTEM_CMD doctor --claim-discipline');
         expect(verifyBadgesIdx).toBeGreaterThan(-1);
@@ -285,36 +293,36 @@ describe('buildPrePushHook', () => {
     });
     // totem-context: hook-content assertion (not an orchestrator test, no LLM calls — default vitest timeout is sufficient)
     it('mentions TOTEM_GATE_BYPASS_JUSTIFICATION as the bypass mechanism (Proposal 279 Q3 standardized convention)', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toContain('TOTEM_GATE_BYPASS_JUSTIFICATION');
     });
     it('does NOT contain old flag-file references', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).not.toContain('.lint-passed');
         expect(hook).not.toContain('.shield-passed');
         expect(hook).not.toContain('.target-globs');
     });
     it('does NOT contain merge-base (no ancestry checks)', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).not.toContain('merge-base');
     });
     it('uses the resolve block', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toContain('TOTEM_CMD=');
         expect(hook).toContain('command -v totem');
     });
     it('uses POSIX-compatible syntax only', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         // Must use [ ] not [[ ]]
         expect(hook).not.toContain('[[');
         expect(hook).not.toContain(']]');
     });
     it('embeds the provided fallback command', () => {
-        const hook = buildPrePushHook('yarn dlx @mmnto/cli');
+        const hook = buildPrePushHook({ ...RENDER, fallbackCmd: 'yarn dlx @mmnto/cli' });
         expect(hook).toContain('yarn dlx @mmnto/cli');
     });
     it('includes format:check before push', () => {
-        const hook = buildPrePushHook(FALLBACK);
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toContain('format:check');
         expect(hook).toContain('Formatting check failed');
     });
@@ -330,7 +338,7 @@ describe('installGitHook', () => {
         cleanTmpDir(tmpDir);
     });
     it('creates a new hook file when none exists', () => {
-        const content = buildPreCommitHook();
+        const content = buildPreCommitHook(RENDER);
         const result = installGitHook(hooksDir, 'pre-commit', content, TOTEM_PRECOMMIT_MARKER);
         expect(result).toBe('installed');
         expect(fs.existsSync(path.join(hooksDir, 'pre-commit'))).toBe(true);
@@ -339,11 +347,11 @@ describe('installGitHook', () => {
     });
     it('creates parent directories as needed', () => {
         expect(fs.existsSync(hooksDir)).toBe(false);
-        installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER);
+        installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER);
         expect(fs.existsSync(hooksDir)).toBe(true);
     });
     it('returns exists when marker is already present (idempotent)', () => {
-        const content = buildPreCommitHook();
+        const content = buildPreCommitHook(RENDER);
         installGitHook(hooksDir, 'pre-commit', content, TOTEM_PRECOMMIT_MARKER);
         const result = installGitHook(hooksDir, 'pre-commit', content, TOTEM_PRECOMMIT_MARKER);
         expect(result).toBe('exists');
@@ -353,7 +361,7 @@ describe('installGitHook', () => {
         const hookPath = path.join(hooksDir, 'pre-commit');
         const userHook = '#!/bin/sh\necho "user hook"\n';
         fs.writeFileSync(hookPath, userHook);
-        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER);
+        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER);
         expect(result).toBe('appended');
         const written = fs.readFileSync(hookPath, 'utf-8');
         expect(written).toContain('echo "user hook"');
@@ -366,13 +374,13 @@ describe('installGitHook', () => {
         const hookPath = path.join(hooksDir, 'pre-push');
         const userHook = '#!/bin/sh\nrun_my_tests\n';
         fs.writeFileSync(hookPath, userHook);
-        installGitHook(hooksDir, 'pre-push', buildPrePushHook('pnpm dlx @mmnto/cli'), TOTEM_PREPUSH_MARKER);
+        installGitHook(hooksDir, 'pre-push', buildPrePushHook(RENDER), TOTEM_PREPUSH_MARKER);
         const written = fs.readFileSync(hookPath, 'utf-8');
         expect(written).toContain('run_my_tests');
         expect(written).toContain(TOTEM_PREPUSH_MARKER);
     });
     it('is idempotent — double install does not duplicate', () => {
-        const content = buildPrePushHook('pnpm dlx @mmnto/cli');
+        const content = buildPrePushHook(RENDER);
         installGitHook(hooksDir, 'pre-push', content, TOTEM_PREPUSH_MARKER);
         installGitHook(hooksDir, 'pre-push', content, TOTEM_PREPUSH_MARKER);
         const written = fs.readFileSync(path.join(hooksDir, 'pre-push'), 'utf-8');
@@ -384,7 +392,7 @@ describe('installGitHook', () => {
         const hookPath = path.join(hooksDir, 'pre-commit');
         const nodeHook = '#!/usr/bin/env node\nconsole.log("lint");\n'; // totem-ignore — test fixture, not real logging
         fs.writeFileSync(hookPath, nodeHook);
-        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER);
+        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER);
         expect(result).toBe('skipped-non-shell');
         const written = fs.readFileSync(hookPath, 'utf-8');
         expect(written).toBe(nodeHook); // File untouched
@@ -394,7 +402,7 @@ describe('installGitHook', () => {
         const hookPath = path.join(hooksDir, 'pre-push');
         const pythonHook = '#!/usr/bin/env python3\nimport subprocess\n';
         fs.writeFileSync(hookPath, pythonHook);
-        const result = installGitHook(hooksDir, 'pre-push', buildPrePushHook('pnpm dlx @mmnto/cli'), TOTEM_PREPUSH_MARKER);
+        const result = installGitHook(hooksDir, 'pre-push', buildPrePushHook(RENDER), TOTEM_PREPUSH_MARKER);
         expect(result).toBe('skipped-non-shell');
         const written = fs.readFileSync(hookPath, 'utf-8');
         expect(written).toBe(pythonHook); // File untouched
@@ -403,33 +411,33 @@ describe('installGitHook', () => {
         fs.mkdirSync(hooksDir, { recursive: true });
         const hookPath = path.join(hooksDir, 'pre-commit');
         fs.writeFileSync(hookPath, '#!/bin/sh\necho "existing"\n');
-        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER);
+        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER);
         expect(result).toBe('appended');
     });
     it('appends normally to bash hooks', () => {
         fs.mkdirSync(hooksDir, { recursive: true });
         const hookPath = path.join(hooksDir, 'pre-commit');
         fs.writeFileSync(hookPath, '#!/bin/bash\necho "existing"\n');
-        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER);
+        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER);
         expect(result).toBe('appended');
     });
     it('appends normally to env bash hooks', () => {
         fs.mkdirSync(hooksDir, { recursive: true });
         const hookPath = path.join(hooksDir, 'pre-commit');
         fs.writeFileSync(hookPath, '#!/usr/bin/env bash\necho "existing"\n');
-        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER);
+        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER);
         expect(result).toBe('appended');
     });
     it('appends to hooks without a shebang (plain text)', () => {
         fs.mkdirSync(hooksDir, { recursive: true });
         const hookPath = path.join(hooksDir, 'pre-commit');
         fs.writeFileSync(hookPath, 'echo "no shebang"\n');
-        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER);
+        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER);
         expect(result).toBe('appended');
     });
     it('handles pre-commit and pre-push independently', () => {
-        installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER);
-        installGitHook(hooksDir, 'pre-push', buildPrePushHook('pnpm dlx @mmnto/cli'), TOTEM_PREPUSH_MARKER);
+        installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER);
+        installGitHook(hooksDir, 'pre-push', buildPrePushHook(RENDER), TOTEM_PREPUSH_MARKER);
         expect(fs.existsSync(path.join(hooksDir, 'pre-commit'))).toBe(true);
         expect(fs.existsSync(path.join(hooksDir, 'pre-push'))).toBe(true);
         const preCommit = fs.readFileSync(path.join(hooksDir, 'pre-commit'), 'utf-8');
@@ -444,7 +452,7 @@ describe('installGitHook', () => {
         const hookPath = path.join(hooksDir, 'pre-push');
         // Write an old-format hook with the marker
         fs.writeFileSync(hookPath, `#!/bin/sh\n# ${TOTEM_PREPUSH_MARKER}\n$TOTEM_CMD lint\n`);
-        const result = installGitHook(hooksDir, 'pre-push', buildPrePushHook('pnpm dlx @mmnto/cli'), TOTEM_PREPUSH_MARKER, true);
+        const result = installGitHook(hooksDir, 'pre-push', buildPrePushHook(RENDER), TOTEM_PREPUSH_MARKER, true);
         expect(result).toBe('overwritten');
         const content = fs.readFileSync(hookPath, 'utf-8');
         expect(content).toContain('verify-manifest'); // new format
@@ -453,7 +461,7 @@ describe('installGitHook', () => {
     it('returns exists when on-disk content already matches canonical (idempotent)', () => {
         fs.mkdirSync(hooksDir, { recursive: true });
         const hookPath = path.join(hooksDir, 'pre-push');
-        const canonical = buildPrePushHook('pnpm dlx @mmnto/cli');
+        const canonical = buildPrePushHook(RENDER);
         fs.writeFileSync(hookPath, canonical);
         const result = installGitHook(hooksDir, 'pre-push', canonical, TOTEM_PREPUSH_MARKER);
         expect(result).toBe('exists');
@@ -464,7 +472,7 @@ describe('installGitHook', () => {
         // A totem-owned whole file frozen at an older generator's output — but it carries
         // the bounded end marker, so drift-repair may upgrade it in place without --force.
         fs.writeFileSync(hookPath, `#!/bin/sh\n# ${TOTEM_PREPUSH_MARKER}\n$TOTEM_CMD lint\n# ${TOTEM_PREPUSH_END}\n`);
-        const canonical = buildPrePushHook('pnpm dlx @mmnto/cli');
+        const canonical = buildPrePushHook(RENDER);
         const result = installGitHook(hooksDir, 'pre-push', canonical, TOTEM_PREPUSH_MARKER, false, TOTEM_PREPUSH_END);
         expect(result).toBe('overwritten');
         expect(fs.readFileSync(hookPath, 'utf-8')).toBe(canonical);
@@ -473,7 +481,7 @@ describe('installGitHook', () => {
         fs.mkdirSync(hooksDir, { recursive: true });
         const hookPath = path.join(hooksDir, 'pre-commit');
         fs.writeFileSync(hookPath, `#!/bin/sh\n# ${TOTEM_PRECOMMIT_MARKER}\nstale body\n# ${TOTEM_PRECOMMIT_END}\n`);
-        const canonical = buildPreCommitHook();
+        const canonical = buildPreCommitHook(RENDER);
         const result = installGitHook(hooksDir, 'pre-commit', canonical, TOTEM_PRECOMMIT_MARKER, false, TOTEM_PRECOMMIT_END);
         expect(result).toBe('overwritten');
         expect(fs.readFileSync(hookPath, 'utf-8')).toBe(canonical);
@@ -486,7 +494,7 @@ describe('installGitHook', () => {
         // marker → the region cannot be bounded → drift-repair declines (legacy path).
         const legacy = `#!/bin/sh\n# ${TOTEM_PRECOMMIT_MARKER}\nstale legacy body\n`;
         fs.writeFileSync(hookPath, legacy);
-        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER, false, TOTEM_PRECOMMIT_END);
+        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER, false, TOTEM_PRECOMMIT_END);
         expect(result).toBe('exists');
         // Left untouched — the legacy hook takes one `totem hook install --force`.
         expect(fs.readFileSync(hookPath, 'utf-8')).toBe(legacy);
@@ -498,7 +506,7 @@ describe('installGitHook', () => {
         // block is bounded by an end marker.
         const userThenTotem = `#!/bin/sh\nrun_my_tests\n# ${TOTEM_PREPUSH_MARKER}\nold content\n# ${TOTEM_PREPUSH_END}\n`;
         fs.writeFileSync(hookPath, userThenTotem);
-        const result = installGitHook(hooksDir, 'pre-push', buildPrePushHook('pnpm dlx @mmnto/cli'), TOTEM_PREPUSH_MARKER, false, TOTEM_PREPUSH_END);
+        const result = installGitHook(hooksDir, 'pre-push', buildPrePushHook(RENDER), TOTEM_PREPUSH_MARKER, false, TOTEM_PREPUSH_END);
         expect(result).toBe('exists');
         // Left untouched — the user's hook is preserved verbatim.
         expect(fs.readFileSync(hookPath, 'utf-8')).toBe(userThenTotem);
@@ -510,7 +518,7 @@ describe('installGitHook', () => {
         // whole-file overwrite would clobber it, so the end-marker guard must decline.
         const staleWithTrailingUser = `#!/bin/sh\n# ${TOTEM_PRECOMMIT_MARKER}\nstale body\n# ${TOTEM_PRECOMMIT_END}\necho "my pre-commit notice"\n`;
         fs.writeFileSync(hookPath, staleWithTrailingUser);
-        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER, false, TOTEM_PRECOMMIT_END);
+        const result = installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER, false, TOTEM_PRECOMMIT_END);
         expect(result).toBe('exists');
         expect(fs.readFileSync(hookPath, 'utf-8')).toBe(staleWithTrailingUser);
     });
@@ -519,7 +527,7 @@ describe('installGitHook', () => {
         const hookPath = path.join(hooksDir, 'pre-push');
         const staleWithTrailingUser = `#!/bin/sh\n# ${TOTEM_PREPUSH_MARKER}\nstale body\n# ${TOTEM_PREPUSH_END}\necho "my pre-push notice"\n`;
         fs.writeFileSync(hookPath, staleWithTrailingUser);
-        const result = installGitHook(hooksDir, 'pre-push', buildPrePushHook('pnpm dlx @mmnto/cli'), TOTEM_PREPUSH_MARKER, false, TOTEM_PREPUSH_END);
+        const result = installGitHook(hooksDir, 'pre-push', buildPrePushHook(RENDER), TOTEM_PREPUSH_MARKER, false, TOTEM_PREPUSH_END);
         expect(result).toBe('exists');
         expect(fs.readFileSync(hookPath, 'utf-8')).toBe(staleWithTrailingUser);
     });
@@ -530,7 +538,7 @@ describe('installGitHook', () => {
         // whole-file overwrite would clobber it, so the end-marker guard must decline.
         const staleWithTrailingUser = `#!/bin/sh\n# ${TOTEM_HOOK_MARKER}\nstale body\n# ${TOTEM_HOOK_END}\necho "my deploy notice"\n`;
         fs.writeFileSync(hookPath, staleWithTrailingUser);
-        const result = installGitHook(hooksDir, 'post-merge', buildHookContent('pnpm dlx @mmnto/cli'), TOTEM_HOOK_MARKER, false, TOTEM_HOOK_END);
+        const result = installGitHook(hooksDir, 'post-merge', buildHookContent(RENDER), TOTEM_HOOK_MARKER, false, TOTEM_HOOK_END);
         expect(result).toBe('exists');
         expect(fs.readFileSync(hookPath, 'utf-8')).toBe(staleWithTrailingUser);
     });
@@ -545,7 +553,7 @@ describe('generateHookHelpers', () => {
         cleanTmpDir(tmpDir);
     });
     it('creates .totem/hooks/ directory and writes all 4 .sh files', () => {
-        generateHookHelpers(tmpDir, 'pnpm dlx @mmnto/cli');
+        generateHookHelpers(tmpDir, RENDER);
         const hooksDir = path.join(tmpDir, '.totem', 'hooks');
         expect(fs.existsSync(path.join(hooksDir, 'post-merge.sh'))).toBe(true);
         expect(fs.existsSync(path.join(hooksDir, 'post-checkout.sh'))).toBe(true);
@@ -553,7 +561,7 @@ describe('generateHookHelpers', () => {
         expect(fs.existsSync(path.join(hooksDir, 'pre-push.sh'))).toBe(true);
     });
     it('generated scripts contain expected content', () => {
-        generateHookHelpers(tmpDir, 'pnpm dlx @mmnto/cli');
+        generateHookHelpers(tmpDir, RENDER);
         const hooksDir = path.join(tmpDir, '.totem', 'hooks');
         const postMerge = fs.readFileSync(path.join(hooksDir, 'post-merge.sh'), 'utf-8');
         expect(postMerge).toContain('command -v totem');
@@ -563,8 +571,8 @@ describe('generateHookHelpers', () => {
         expect(prePush).toContain('verify-manifest');
     });
     it('is idempotent — calling twice does not error', () => {
-        generateHookHelpers(tmpDir, 'pnpm dlx @mmnto/cli');
-        generateHookHelpers(tmpDir, 'pnpm dlx @mmnto/cli');
+        generateHookHelpers(tmpDir, RENDER);
+        generateHookHelpers(tmpDir, RENDER);
         const hooksDir = path.join(tmpDir, '.totem', 'hooks');
         expect(fs.existsSync(path.join(hooksDir, 'post-merge.sh'))).toBe(true);
     });
@@ -578,14 +586,14 @@ describe('installHooksNonInteractive', () => {
     afterEach(() => {
         cleanTmpDir(tmpDir);
     });
-    it('returns null when not a git repo', () => {
-        const result = installHooksNonInteractive(tmpDir);
+    it('returns null when not a git repo', async () => {
+        const result = await installHooksNonInteractive(tmpDir);
         expect(result).toBeNull();
     });
-    it('installs all four hooks in a git repo', () => {
+    it('installs all four hooks in a git repo', async () => {
         execSync('git init', { cwd: tmpDir, stdio: 'ignore' });
         fs.writeFileSync(path.join(tmpDir, 'pnpm-lock.yaml'), '');
-        const result = installHooksNonInteractive(tmpDir);
+        const result = await installHooksNonInteractive(tmpDir);
         expect(result).not.toBeNull();
         expect(result.preCommit).toBe('installed');
         expect(result.prePush).toBe('installed');
@@ -598,33 +606,33 @@ describe('installHooksNonInteractive', () => {
         expect(fs.existsSync(path.join(hooksDir, 'post-merge'))).toBe(true);
         expect(fs.existsSync(path.join(hooksDir, 'post-checkout'))).toBe(true);
     });
-    it('is idempotent — second call returns exists for all hooks', () => {
+    it('is idempotent — second call returns exists for all hooks', async () => {
         execSync('git init', { cwd: tmpDir, stdio: 'ignore' });
         fs.writeFileSync(path.join(tmpDir, 'pnpm-lock.yaml'), '');
-        installHooksNonInteractive(tmpDir);
-        const result = installHooksNonInteractive(tmpDir);
+        await installHooksNonInteractive(tmpDir);
+        const result = await installHooksNonInteractive(tmpDir);
         expect(result).not.toBeNull();
         expect(result.preCommit).toBe('exists');
         expect(result.prePush).toBe('exists');
         expect(result.postMerge).toBe('exists');
         expect(result.postCheckout).toBe('exists');
     });
-    it('returns null and generates helper scripts when hook manager is detected', () => {
+    it('returns null and generates helper scripts when hook manager is detected', async () => {
         execSync('git init', { cwd: tmpDir, stdio: 'ignore' });
         fs.mkdirSync(path.join(tmpDir, '.husky'), { recursive: true });
-        const result = installHooksNonInteractive(tmpDir);
+        const result = await installHooksNonInteractive(tmpDir);
         expect(result).toBeNull();
         // Verify helper scripts were generated
         const hooksDir = path.join(tmpDir, '.totem', 'hooks');
         expect(fs.existsSync(path.join(hooksDir, 'post-merge.sh'))).toBe(true);
         expect(fs.existsSync(path.join(hooksDir, 'pre-push.sh'))).toBe(true);
     });
-    it('installs hooks at git root when run from a subdirectory', () => {
+    it('installs hooks at git root when run from a subdirectory', async () => {
         execSync('git init', { cwd: tmpDir, stdio: 'ignore' });
         fs.writeFileSync(path.join(tmpDir, 'pnpm-lock.yaml'), '');
         const subDir = path.join(tmpDir, 'packages', 'cli');
         fs.mkdirSync(subDir, { recursive: true });
-        const result = installHooksNonInteractive(subDir);
+        const result = await installHooksNonInteractive(subDir);
         expect(result).not.toBeNull();
         expect(result.preCommit).toBe('installed');
         expect(result.prePush).toBe('installed');
@@ -638,31 +646,31 @@ describe('installHooksNonInteractive', () => {
         expect(fs.existsSync(path.join(hooksDir, 'post-checkout'))).toBe(true);
         expect(fs.existsSync(path.join(subDir, '.git'))).toBe(false);
     });
-    it('check passes from subdirectory after install', () => {
+    it('check passes from subdirectory after install', async () => {
         execSync('git init', { cwd: tmpDir, stdio: 'ignore' });
         fs.writeFileSync(path.join(tmpDir, 'pnpm-lock.yaml'), '');
         const subDir = path.join(tmpDir, 'packages', 'cli');
         fs.mkdirSync(subDir, { recursive: true });
-        installHooksNonInteractive(subDir);
+        await installHooksNonInteractive(subDir);
         expect(checkHooksInstalled(subDir)).toBe(true);
     });
-    it('appends to existing hooks without clobbering', () => {
+    it('appends to existing hooks without clobbering', async () => {
         execSync('git init', { cwd: tmpDir, stdio: 'ignore' });
         fs.writeFileSync(path.join(tmpDir, 'pnpm-lock.yaml'), '');
         fs.writeFileSync(path.join(tmpDir, '.git', 'hooks', 'pre-push'), '#!/bin/sh\nrun_my_tests\n');
-        const result = installHooksNonInteractive(tmpDir);
+        const result = await installHooksNonInteractive(tmpDir);
         expect(result.prePush).toBe('appended');
         const content = fs.readFileSync(path.join(tmpDir, '.git', 'hooks', 'pre-push'), 'utf-8');
         expect(content).toContain('run_my_tests');
         expect(content).toContain(TOTEM_PREPUSH_MARKER);
     });
-    it('force-overwrites all hooks when force is true', () => {
+    it('force-overwrites all hooks when force is true', async () => {
         execSync('git init', { cwd: tmpDir, stdio: 'ignore' });
         fs.writeFileSync(path.join(tmpDir, 'pnpm-lock.yaml'), '');
         // First install — creates hooks
-        installHooksNonInteractive(tmpDir);
+        await installHooksNonInteractive(tmpDir);
         // Second install with force — overwrites all hooks
-        const result = installHooksNonInteractive(tmpDir, true);
+        const result = await installHooksNonInteractive(tmpDir, true);
         expect(result).not.toBeNull();
         expect(result.preCommit).toBe('overwritten');
         expect(result.prePush).toBe('overwritten');
@@ -684,14 +692,14 @@ describe('checkHooksInstalled', () => {
     it('returns false when no hooks are installed', () => {
         expect(checkHooksInstalled(tmpDir)).toBe(false);
     });
-    it('returns true when all hooks are installed', () => {
-        installHooksNonInteractive(tmpDir);
+    it('returns true when all hooks are installed', async () => {
+        await installHooksNonInteractive(tmpDir);
         expect(checkHooksInstalled(tmpDir)).toBe(true);
     });
     it('returns false when only some hooks are installed', () => {
         const hooksDir = path.join(tmpDir, '.git', 'hooks');
         fs.mkdirSync(hooksDir, { recursive: true });
-        installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(), TOTEM_PRECOMMIT_MARKER);
+        installGitHook(hooksDir, 'pre-commit', buildPreCommitHook(RENDER), TOTEM_PRECOMMIT_MARKER);
         // Missing pre-push and post-merge
         expect(checkHooksInstalled(tmpDir)).toBe(false);
     });
@@ -716,8 +724,8 @@ describe('post-merge hook content', () => {
     afterEach(() => {
         cleanTmpDir(tmpDir);
     });
-    it('generates post-merge hook with git diff-tree lesson check', () => {
-        installHooksNonInteractive(tmpDir);
+    it('generates post-merge hook with git diff-tree lesson check', async () => {
+        await installHooksNonInteractive(tmpDir);
         const hookPath = path.join(tmpDir, '.git', 'hooks', 'post-merge');
         const content = fs.readFileSync(hookPath, 'utf-8');
         expect(content).toContain('ORIG_HEAD');
@@ -728,17 +736,17 @@ describe('post-merge hook content', () => {
         expect(content).toContain('[totem] post-merge hook');
         expect(content).toContain('[totem] end post-merge');
     });
-    it('passes quiet flag to sync command in post-merge hook', () => {
-        installHooksNonInteractive(tmpDir);
+    it('passes quiet flag to sync command in post-merge hook', async () => {
+        await installHooksNonInteractive(tmpDir);
         const hookPath = path.join(tmpDir, '.git', 'hooks', 'post-merge');
         const content = fs.readFileSync(hookPath, 'utf-8');
         expect(content).toContain('--quiet');
     });
-    it('preserves existing hooks when appending post-merge block', () => {
+    it('preserves existing hooks when appending post-merge block', async () => {
         const hooksDir = path.join(tmpDir, '.git', 'hooks');
         fs.mkdirSync(hooksDir, { recursive: true });
         fs.writeFileSync(path.join(hooksDir, 'post-merge'), '#!/bin/sh\necho "my custom hook"\n');
-        installHooksNonInteractive(tmpDir);
+        await installHooksNonInteractive(tmpDir);
         const content = fs.readFileSync(path.join(hooksDir, 'post-merge'), 'utf-8');
         expect(content).toContain('echo "my custom hook"');
         expect(content).toContain('[totem] post-merge hook');
@@ -757,8 +765,8 @@ describe('post-checkout hook content', () => {
     afterEach(() => {
         cleanTmpDir(tmpDir);
     });
-    it('generates post-checkout hook with branch switch guard', () => {
-        installHooksNonInteractive(tmpDir);
+    it('generates post-checkout hook with branch switch guard', async () => {
+        await installHooksNonInteractive(tmpDir);
         const hookPath = path.join(tmpDir, '.git', 'hooks', 'post-checkout');
         const content = fs.readFileSync(hookPath, 'utf-8');
         expect(content).toContain('$3');
@@ -767,18 +775,18 @@ describe('post-checkout hook content', () => {
         expect(content).toContain('[totem] end post-checkout');
     });
     it('handles null SHA for initial checkout', () => {
-        const hook = buildPostCheckoutHookContent('pnpm dlx @mmnto/cli');
+        const hook = buildPostCheckoutHookContent(RENDER);
         expect(hook).toContain('0000000000000000000000000000000000000000');
         expect(hook).toContain('.totem');
     });
-    it('uses quiet sync command', () => {
-        installHooksNonInteractive(tmpDir);
+    it('uses quiet sync command', async () => {
+        await installHooksNonInteractive(tmpDir);
         const hookPath = path.join(tmpDir, '.git', 'hooks', 'post-checkout');
         const content = fs.readFileSync(hookPath, 'utf-8');
         expect(content).toContain('--quiet');
     });
-    it('includes post-checkout in non-interactive install', () => {
-        const result = installHooksNonInteractive(tmpDir);
+    it('includes post-checkout in non-interactive install', async () => {
+        const result = await installHooksNonInteractive(tmpDir);
         expect(result).not.toBeNull();
         expect(result.postCheckout).toBe('installed');
     });
@@ -787,7 +795,7 @@ describe('post-checkout hook content', () => {
 // ─── totem-status refresh-gh wiring (mmnto-ai/totem#2556) ─
 describe('post-merge hook fires totem-status refresh-gh', () => {
     it('invokes refresh-gh presence-gated and backgrounded (mmnto-ai/totem-status#127 C3)', () => {
-        const hook = buildHookContent('pnpm dlx @mmnto/cli');
+        const hook = buildHookContent(RENDER);
         // Presence gate (absent binary = zero noise) AND primary-checkout gate: in a
         // linked worktree .git is a pointer FILE and a backgrounded child inheriting
         // the worktree cwd holds a Windows directory lock that breaks worktree removal.
@@ -799,7 +807,7 @@ describe('post-merge hook fires totem-status refresh-gh', () => {
         expect(hook.trimEnd().endsWith(`# ${TOTEM_HOOK_END}`)).toBe(true);
     });
     it('#2570: stamps each firing and hands the child the same log (observability leg)', () => {
-        const hook = buildHookContent('pnpm dlx @mmnto/cli');
+        const hook = buildHookContent(RENDER);
         // Repo-local log inside .git; the stamp carries the firing site, cwd, and
         // WHICH binary resolved (shell search order can be shadowed by a
         // checkout-local exe on Windows).
@@ -812,10 +820,40 @@ describe('post-merge hook fires totem-status refresh-gh', () => {
         // so the open failure of an unwritable log is itself silent (falsification
         // round, MAJOR 1).
         expect(hook).toContain('2>/dev/null >> "$TS_REFRESH_LOG"');
-        // The child appends to the SAME log so its success line lands after the
-        // stamp; a stamp with nothing after it = the child never finished.
+        // The children append to the SAME log so their output lands after the
+        // stamps. Narrowed once a second verb joined the block: child output is
+        // unlabelled and interleaves, so a silent tail attributes only to the LAST
+        // verb stamped — not per child.
         expect(hook).toContain('(totem-status refresh-gh >> "$TS_REFRESH_LOG" 2>&1 &)');
     });
+    // ── slice-two residual: refresh-obligation-store beside refresh-gh ──
+    // (mmnto-ai/totem-status#127; sibling of mmnto-ai/totem#2556.) The durable
+    // obligation store gets the same post-merge moment as the GH snapshot.
+    it('also fires refresh-obligation-store under the SAME gate and log (mmnto-ai/totem-status#127)', () => {
+        const hook = buildHookContent(RENDER);
+        // One gate, not two: both verbs live inside the single presence +
+        // primary-checkout `if`, so a worktree/non-adopter skips BOTH.
+        const gateIdx = hook.indexOf('if [ -d .git ] && command -v totem-status >/dev/null 2>&1; then');
+        expect(gateIdx).toBeGreaterThanOrEqual(0);
+        // Anchor on the EXECUTABLE form, not the banner prose above the gate: a
+        // mutant that relocates the invocation outside the gate but leaves the
+        // comment in place must fail here.
+        expect(hook.indexOf('(totem-status refresh-obligation-store')).toBeGreaterThan(gateIdx);
+        // …and it stays inside the block, ahead of the gate's closing `fi`.
+        expect(hook.indexOf('(totem-status refresh-obligation-store')).toBeLessThan(hook.indexOf('# Only sync when lessons changed'));
+        // Both arms of the log-writability branch mirror the refresh-gh pair: the
+        // logged form, and the blind fallback when the log cannot be opened.
+        expect(hook).toContain('(totem-status refresh-obligation-store >> "$TS_REFRESH_LOG" 2>&1 &)');
+        expect(hook).toContain('(totem-status refresh-obligation-store >/dev/null 2>&1 &)');
+        // The stamp NAMES the verb, so the log records which verbs fired and in
+        // what order (it does not restore per-child reap attribution — child
+        // output is unlabelled).
+        expect(hook).toContain('post-merge spawn cwd=%s bin=%s verb=%s');
+        expect(hook).toContain('"$(command -v totem-status | tr -d \'[:cntrl:]\')" refresh-gh');
+        expect(hook).toContain('"$(command -v totem-status | tr -d \'[:cntrl:]\')" refresh-obligation-store');
+        // The bounded owned region stays intact after the addition.
+        expect(hook.trimEnd().endsWith(`# ${TOTEM_HOOK_END}`)).toBe(true);
+    });
 });
 // Behavioral coverage of BOTH gate branches (falsification-leg round 1: the string
 // assertions above are satisfiable without the behavior). POSIX-only: the stub
@@ -830,23 +868,38 @@ describe.skipIf(process.platform === 'win32')('post-merge refresh-gh behavior (P
         binDir = path.join(tmpDir, 'stub-bin');
         fs.mkdirSync(binDir);
         markerPath = path.join(tmpDir, 'refresh-fired.marker');
-        fs.writeFileSync(path.join(binDir, 'totem-status'), `#!/bin/sh\necho "$1" > "${markerPath}"\n`, { mode: 0o755 });
+        // APPEND, not truncate: the gate now fires TWO verbs from one block and the
+        // backgrounded children land in whatever order they finish — a `>` stub
+        // would race them into a last-writer-wins single line.
+        fs.writeFileSync(path.join(binDir, 'totem-status'), `#!/bin/sh\necho "$1" >> "${markerPath}"\n`, { mode: 0o755 });
     });
     afterEach(() => {
         cleanTmpDir(tmpDir);
     });
-    /** Wait for the marker to exist AND carry content — existence alone races
-     *  the stub's open-truncate-then-write window (observed as a CI flake:
-     *  `expected '' to be 'refresh-gh'`). */
-    function markerReady() {
+    /** The verbs the stub sidecar has been invoked with so far, sorted. Reading
+     *  CONTENT (not existence) still guards the stub's open-then-write window
+     *  (observed as a CI flake: `expected '' to be 'refresh-gh'`). */
+    function firedVerbs() {
         try {
-            return fs.existsSync(markerPath) && fs.readFileSync(markerPath, 'utf-8').trim() !== '';
-            // totem-context: intentional false on a read race (marker mid-write) — the poll loop retries
+            if (!fs.existsSync(markerPath))
+                return [];
+            return fs
+                .readFileSync(markerPath, 'utf-8')
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0)
+                .sort();
+            // totem-context: intentional [] on a read race (marker mid-write) — the poll loop retries
         }
         catch {
-            return false;
+            return [];
         }
     }
+    /** Both verbs must land: refresh-gh AND the slice-two refresh-obligation-store. */
+    const BOTH_VERBS = ['refresh-gh', 'refresh-obligation-store'];
+    function markerReady() {
+        return firedVerbs().length === BOTH_VERBS.length;
+    }
     async function markerAppears(timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
@@ -860,14 +913,15 @@ describe.skipIf(process.platform === 'win32')('post-merge refresh-gh behavior (P
         const repo = path.join(tmpDir, 'repo');
         fs.mkdirSync(path.join(repo, '.git'), { recursive: true });
         const hookPath = path.join(repo, 'post-merge');
-        fs.writeFileSync(hookPath, buildHookContent('pnpm dlx @mmnto/cli'), { mode: 0o755 });
+        fs.writeFileSync(hookPath, buildHookContent(RENDER), { mode: 0o755 });
         execSync('sh ./post-merge', {
             cwd: repo,
             env: { ...process.env, PATH: `${binDir}:${process.env.PATH ?? ''}` },
             stdio: 'ignore',
         });
         expect(await markerAppears(5000)).toBe(true);
-        expect(fs.readFileSync(markerPath, 'utf-8').trim()).toBe('refresh-gh');
+        // BOTH verbs fired from the one gate, and nothing else did.
+        expect(firedVerbs()).toEqual(BOTH_VERBS);
         // #2570 observability leg: the firing left a stamp in the repo-local
         // .git log before the child ran, and bin= carries the RESOLVED path.
         const logPath = path.join(repo, '.git', 'totem-status-refresh-hook.log');
@@ -875,6 +929,10 @@ describe.skipIf(process.platform === 'win32')('post-merge refresh-gh behavior (P
         const logText = fs.readFileSync(logPath, 'utf-8');
         expect(logText).toContain('post-merge spawn cwd=');
         expect(logText).toMatch(/bin=\S*totem-status/);
+        // Each stamp NAMES its verb, so the log records which verbs fired and in
+        // what order — the attribution the unlabelled child output cannot give.
+        expect(logText).toContain('verb=refresh-gh');
+        expect(logText).toContain('verb=refresh-obligation-store');
     });
     it('#2570: an unwritable log falls back to blind firing with zero stderr noise', { timeout: 15000 }, async () => {
         const repo = path.join(tmpDir, 'repo');
@@ -885,7 +943,7 @@ describe.skipIf(process.platform === 'win32')('post-merge refresh-gh behavior (P
         // append; falsification round, MAJOR 1).
         fs.mkdirSync(path.join(repo, '.git', 'totem-status-refresh-hook.log'), { recursive: true });
         const hookPath = path.join(repo, 'post-merge');
-        fs.writeFileSync(hookPath, buildHookContent('pnpm dlx @mmnto/cli'), { mode: 0o755 });
+        fs.writeFileSync(hookPath, buildHookContent(RENDER), { mode: 0o755 });
         const result = spawnSync('sh', ['./post-merge'], {
             cwd: repo,
             env: { ...process.env, PATH: `${binDir}:${process.env.PATH ?? ''}` },
@@ -894,7 +952,8 @@ describe.skipIf(process.platform === 'win32')('post-merge refresh-gh behavior (P
         expect(result.status).toBe(0);
         expect(result.stderr ?? '').not.toContain('totem-status-refresh-hook.log');
         expect(await markerAppears(5000)).toBe(true);
-        expect(fs.readFileSync(markerPath, 'utf-8').trim()).toBe('refresh-gh');
+        // The blind fallback carries BOTH verbs, not just the first.
+        expect(firedVerbs()).toEqual(BOTH_VERBS);
     });
     it('skips the sidecar when .git is not a directory (worktree/non-git guard)', { timeout: 15000 }, async () => {
         const repo = path.join(tmpDir, 'repo');
@@ -902,25 +961,28 @@ describe.skipIf(process.platform === 'win32')('post-merge refresh-gh behavior (P
         // Linked-worktree shape: .git is a pointer FILE, not a directory.
         fs.writeFileSync(path.join(repo, '.git'), 'gitdir: /elsewhere/.git/worktrees/x\n');
         const hookPath = path.join(repo, 'post-merge');
-        fs.writeFileSync(hookPath, buildHookContent('pnpm dlx @mmnto/cli'), { mode: 0o755 });
+        fs.writeFileSync(hookPath, buildHookContent(RENDER), { mode: 0o755 });
         execSync('sh ./post-merge', {
             cwd: repo,
             env: { ...process.env, PATH: `${binDir}:${process.env.PATH ?? ''}` },
             stdio: 'ignore',
         });
         expect(await markerAppears(500)).toBe(false);
+        // The gate covers BOTH verbs — a partial leak (either one firing) is a
+        // failure here, not a pass by way of "fewer than two".
+        expect(firedVerbs()).toEqual([]);
     });
 });
 describe('sync-log redirect resolves the git dir (worktree-safe)', () => {
     it('post-merge hook derives the log path from git rev-parse --git-dir', () => {
-        const hook = buildHookContent('pnpm dlx @mmnto/cli');
+        const hook = buildHookContent(RENDER);
         expect(hook).toContain('GIT_DIR_RESOLVED=$(git rev-parse --git-dir 2>/dev/null || echo .git)');
         expect(hook).toContain('> "$GIT_DIR_RESOLVED/totem-sync.log"');
         // The hardcoded `.git/`-as-directory redirect must be gone (ENOTDIR in a worktree).
         expect(hook).not.toContain('> .git/totem-sync.log');
     });
     it('post-checkout hook derives the log path from git rev-parse --git-dir on both branches', () => {
-        const hook = buildPostCheckoutHookContent('pnpm dlx @mmnto/cli');
+        const hook = buildPostCheckoutHookContent(RENDER);
         expect(hook).toContain('GIT_DIR_RESOLVED=$(git rev-parse --git-dir 2>/dev/null || echo .git)');
         // Both the null-SHA and the branch-diff redirect use the resolved dir.
         expect(hook.match(/> "\$GIT_DIR_RESOLVED\/totem-sync\.log"/g)).toHaveLength(2);
@@ -934,13 +996,19 @@ describe('upgradePrePushHookIfNeeded', () => {
         tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'totem-hooks-upgrade-'));
         execSync('git init', { cwd: tmpDir, stdio: 'ignore' });
         fs.writeFileSync(path.join(tmpDir, 'pnpm-lock.yaml'), '');
+        // Pin the repo-local render options: since mmnto-ai/totem#2692 the upgrade
+        // path resolves `hooks.tier` from config, and a config-less temp repo would
+        // fall through to the developer's global `~/.totem/` profile — a global
+        // `hooks.tier: strict` would then break the standard-tier expectation below
+        // (CodeRabbit on mmnto-ai/totem#2701).
+        fs.writeFileSync(path.join(tmpDir, 'totem.yaml'), 'targets:\n  - glob: "docs/*.md"\n    type: lesson\n    strategy: markdown-heading\nhooks:\n  tier: standard\n', 'utf-8');
     });
     afterEach(() => {
         cleanTmpDir(tmpDir);
     });
     /**
      * Helper: extract the totem block from a hook file and compare it against
-     * the canonical output of buildPrePushHook('pnpm dlx @mmnto/cli') (shebang stripped, trimmed).
+     * the canonical output of buildPrePushHook(RENDER) (shebang stripped, trimmed).
      * Catches stale shell fragments or splice boundary bugs that toContain would miss.
      * The stateless format is now bounded by the pre-push end marker, so the block is the
      * span from the start-marker comment through the end-marker comment line inclusive —
@@ -958,11 +1026,11 @@ describe('upgradePrePushHookIfNeeded', () => {
     }
     /** Canonical totem block: shebang stripped, trimmed — the expected upgrade output. */
     function expectedTotemBlock() {
-        return buildPrePushHook(getFallbackCommand(tmpDir))
+        return buildPrePushHook({ ...RENDER, fallbackCmd: getFallbackCommand(tmpDir) })
             .replace(/^#!\/bin\/sh\n/, '')
             .trim();
     }
-    it('upgrades old command-executing hook to stateless format', () => {
+    it('upgrades old command-executing hook to stateless format', async () => {
         // Install an old-style hook that executes $TOTEM_CMD lint
         const hooksDir = path.join(tmpDir, '.git', 'hooks');
         fs.mkdirSync(hooksDir, { recursive: true });
@@ -978,7 +1046,7 @@ if [ -f ".totem/compiled-rules.json" ]; then
 fi
 `;
         fs.writeFileSync(path.join(hooksDir, 'pre-push'), oldHook);
-        const upgraded = upgradePrePushHookIfNeeded(tmpDir);
+        const upgraded = await upgradePrePushHookIfNeeded(tmpDir);
         expect(upgraded).toBe(true);
         const content = fs.readFileSync(path.join(hooksDir, 'pre-push'), 'utf-8');
         expect(content).toContain('verify-manifest');
@@ -990,41 +1058,41 @@ fi
         const actual = extractTotemBlock(content);
         expect(actual).toBe(expectedTotemBlock());
     });
-    it('skips hook without totem marker', () => {
+    it('skips hook without totem marker', async () => {
         const hooksDir = path.join(tmpDir, '.git', 'hooks');
         fs.mkdirSync(hooksDir, { recursive: true });
         const userHook = '#!/bin/sh\necho "user hook"\n';
         fs.writeFileSync(path.join(hooksDir, 'pre-push'), userHook);
-        const upgraded = upgradePrePushHookIfNeeded(tmpDir);
+        const upgraded = await upgradePrePushHookIfNeeded(tmpDir);
         expect(upgraded).toBe(false);
         const content = fs.readFileSync(path.join(hooksDir, 'pre-push'), 'utf-8');
         expect(content).toBe(userHook); // File untouched
     });
-    it('skips hook that already uses stateless format', () => {
+    it('skips hook that already uses stateless format', async () => {
         // Install the current-version hook via non-interactive installer
-        installHooksNonInteractive(tmpDir);
+        await installHooksNonInteractive(tmpDir);
         const hooksDir = path.join(tmpDir, '.git', 'hooks');
         const beforeContent = fs.readFileSync(path.join(hooksDir, 'pre-push'), 'utf-8');
-        const upgraded = upgradePrePushHookIfNeeded(tmpDir);
+        const upgraded = await upgradePrePushHookIfNeeded(tmpDir);
         expect(upgraded).toBe(false);
         const afterContent = fs.readFileSync(path.join(hooksDir, 'pre-push'), 'utf-8');
         expect(afterContent).toBe(beforeContent); // File untouched
     });
-    it('returns false when no pre-push hook exists', () => {
-        const upgraded = upgradePrePushHookIfNeeded(tmpDir);
+    it('returns false when no pre-push hook exists', async () => {
+        const upgraded = await upgradePrePushHookIfNeeded(tmpDir);
         expect(upgraded).toBe(false);
     });
-    it('returns false when not a git repo', () => {
+    it('returns false when not a git repo', async () => {
         const nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), 'totem-no-git-'));
         try {
-            const upgraded = upgradePrePushHookIfNeeded(nonGitDir);
+            const upgraded = await upgradePrePushHookIfNeeded(nonGitDir);
             expect(upgraded).toBe(false);
         }
         finally {
             cleanTmpDir(nonGitDir);
         }
     });
-    it('preserves user-appended content when upgrading', () => {
+    it('preserves user-appended content when upgrading', async () => {
         const hooksDir = path.join(tmpDir, '.git', 'hooks');
         fs.mkdirSync(hooksDir, { recursive: true });
         // Simulate an old totem hook with user content appended after it
@@ -1039,7 +1107,7 @@ fi
 `;
         const userAppended = '\n# My custom deploy notification\ncurl -X POST https://hooks.example.com/deploy\n';
         fs.writeFileSync(path.join(hooksDir, 'pre-push'), oldTotemBlock + userAppended);
-        const upgraded = upgradePrePushHookIfNeeded(tmpDir);
+        const upgraded = await upgradePrePushHookIfNeeded(tmpDir);
         expect(upgraded).toBe(true);
         const content = fs.readFileSync(path.join(hooksDir, 'pre-push'), 'utf-8');
         // New totem block should use stateless format
@@ -1053,7 +1121,7 @@ fi
         const actual = extractTotemBlock(content);
         expect(actual).toBe(expectedTotemBlock());
     });
-    it('preserves user-appended if/fi blocks without corrupting them', () => {
+    it('preserves user-appended if/fi blocks without corrupting them', async () => {
         const hooksDir = path.join(tmpDir, '.git', 'hooks');
         fs.mkdirSync(hooksDir, { recursive: true });
         // Old totem block (needs upgrade) PLUS user content that contains its own if/fi structures
@@ -1084,7 +1152,7 @@ if [ -n "$SLACK_WEBHOOK" ]; then
 fi
 `;
         fs.writeFileSync(path.join(hooksDir, 'pre-push'), oldTotemBlock + userIfFiBlock);
-        const upgraded = upgradePrePushHookIfNeeded(tmpDir);
+        const upgraded = await upgradePrePushHookIfNeeded(tmpDir);
         expect(upgraded).toBe(true);
         const content = fs.readFileSync(path.join(hooksDir, 'pre-push'), 'utf-8');
         // Totem block must match canonical output exactly
@@ -1102,7 +1170,7 @@ fi
         const userBlockStart = content.indexOf('# Custom deploy guard');
         expect(userBlockStart).toBeGreaterThan(totemBlockEnd);
     });
-    it('leaves no stale fi or orphaned shell fragments after upgrade', () => {
+    it('leaves no stale fi or orphaned shell fragments after upgrade', async () => {
         const hooksDir = path.join(tmpDir, '.git', 'hooks');
         fs.mkdirSync(hooksDir, { recursive: true });
         const oldHook = `#!/bin/sh
@@ -1117,7 +1185,7 @@ if [ -f ".totem/compiled-rules.json" ]; then
 fi
 `;
         fs.writeFileSync(path.join(hooksDir, 'pre-push'), oldHook);
-        upgradePrePushHookIfNeeded(tmpDir);
+        await upgradePrePushHookIfNeeded(tmpDir);
         const content = fs.readFileSync(path.join(hooksDir, 'pre-push'), 'utf-8');
         // Count if/fi balance: every `if` must have a matching `fi`.
         // Inline `if ... fi` on a single line are self-balanced and excluded from both counts.
@@ -1133,7 +1201,7 @@ fi
         const actual = extractTotemBlock(content);
         expect(actual).toBe(expectedTotemBlock());
     });
-    it('upgrades old flag-checking hook to stateless format', () => {
+    it('upgrades old flag-checking hook to stateless format', async () => {
         const hooksDir = path.join(tmpDir, '.git', 'hooks');
         fs.mkdirSync(hooksDir, { recursive: true });
         // Simulate the previous flag-checking format that used .lint-passed
@@ -1154,7 +1222,7 @@ if [ -f ".totem/compiled-rules.json" ]; then
 fi
 `;
         fs.writeFileSync(path.join(hooksDir, 'pre-push'), oldHook);
-        const upgraded = upgradePrePushHookIfNeeded(tmpDir);
+        const upgraded = await upgradePrePushHookIfNeeded(tmpDir);
         expect(upgraded).toBe(true);
         const content = fs.readFileSync(path.join(hooksDir, 'pre-push'), 'utf-8');
         expect(content).toContain('verify-manifest');
@@ -1164,7 +1232,7 @@ fi
         const actual = extractTotemBlock(content);
         expect(actual).toBe(expectedTotemBlock());
     });
-    it('upgrades hook with auto-refresh and $TOTEM_CMD to stateless format', () => {
+    it('upgrades hook with auto-refresh and $TOTEM_CMD to stateless format', async () => {
         const hooksDir = path.join(tmpDir, '.git', 'hooks');
         fs.mkdirSync(hooksDir, { recursive: true });
         // Simulate a hook with the auto-refresh logic still using $TOTEM_CMD
@@ -1194,7 +1262,7 @@ if [ -f ".totem/compiled-rules.json" ]; then
 fi
 `;
         fs.writeFileSync(path.join(hooksDir, 'pre-push'), oldHook);
-        const upgraded = upgradePrePushHookIfNeeded(tmpDir);
+        const upgraded = await upgradePrePushHookIfNeeded(tmpDir);
         expect(upgraded).toBe(true);
         const content = fs.readFileSync(path.join(hooksDir, 'pre-push'), 'utf-8');
         expect(content).toContain('verify-manifest');
@@ -1209,7 +1277,7 @@ fi
 // ─── Enforcement tier: agent detection & strict mode ──
 describe('buildPreCommitHook agent detection', () => {
     it('includes agent detection snippet', () => {
-        const hook = buildPreCommitHook();
+        const hook = buildPreCommitHook(RENDER);
         expect(hook).toContain('is_agent=0');
         expect(hook).toContain('is_agent=1');
         expect(hook).toContain('CLAUDE_CODE_AGENT');
@@ -1218,52 +1286,270 @@ describe('buildPreCommitHook agent detection', () => {
         // GEMINI_API_KEY intentionally excluded — human devs export it for Totem's embedding provider
     });
     it('includes TOTEM_HOOK_TIER variable', () => {
-        const hook = buildPreCommitHook();
+        const hook = buildPreCommitHook(RENDER);
         expect(hook).toContain('TOTEM_HOOK_TIER="standard"');
     });
     it('sets TOTEM_HOOK_TIER to strict when tier is strict', () => {
-        const hook = buildPreCommitHook('strict');
+        const hook = buildPreCommitHook({ ...RENDER, tier: 'strict' });
         expect(hook).toContain('TOTEM_HOOK_TIER="strict"');
     });
 });
 describe('buildPreCommitHook with strict tier', () => {
-    it('includes spec-completed check', () => {
-        const hook = buildPreCommitHook('strict');
-        expect(hook).toContain('.spec-completed');
+    it('gates on spec evidence and never on the retired hand-set marker', () => {
+        const hook = buildPreCommitHook({ ...RENDER, tier: 'strict' });
+        // The former `.totem/cache/.spec-completed` sentinel (mmnto-ai/totem#2690)
+        // may be NAMED in a comment that says it is not honored, but no test-able
+        // path may read it.
+        expect(hook).not.toMatch(/-f\s+"?\.totem\/cache\/\.spec-completed/);
         expect(hook).toContain("Run 'totem spec <issue>' before committing (strict mode)");
     });
     it('gates spec check on agent detection or strict tier', () => {
-        const hook = buildPreCommitHook('strict');
+        const hook = buildPreCommitHook({ ...RENDER, tier: 'strict' });
         expect(hook).toContain('$is_agent');
         expect(hook).toContain('$TOTEM_HOOK_TIER');
     });
+    it('gates on the totem spec run artifact, JSON-aware — the only evidence', () => {
+        const hook = buildPreCommitHook({ ...RENDER, tier: 'strict' });
+        expect(hook).toContain('.totem/artifacts/runs');
+        expect(hook).toContain('admission.runMetadata.caller');
+        expect(hook).toContain('spec evidence:');
+        expect(hook).not.toContain('(legacy marker)');
+    });
+});
+// The strict block EXECUTED under sh (mmnto-ai/totem#2690): the string checks
+// above pin the text; these pin the behavior the gate exists for. `git init` +
+// a feature branch so the protected-branch block does not fire; the agent
+// env var arms the strict tier the way an agent commit does.
+describe('buildPreCommitHook strict evidence — executed under sh (mmnto-ai/totem#2690)', () => {
+    const shellOk = spawnSync('sh', ['-c', 'command -v node >/dev/null 2>&1'], { encoding: 'utf-8' }).status === 0;
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'totem-hook-evidence-'));
+        execSync('git init -q', { cwd: tmpDir, stdio: 'ignore' });
+        execSync('git checkout -q -b feat/evidence', { cwd: tmpDir, stdio: 'ignore' });
+        fs.writeFileSync(path.join(tmpDir, 'pre-commit'), buildPreCommitHook(RENDER));
+    });
+    afterEach(() => {
+        cleanTmpDir(tmpDir);
+    });
+    function runHook() {
+        const r = spawnSync('sh', ['./pre-commit'], {
+            cwd: tmpDir,
+            encoding: 'utf-8',
+            env: { ...process.env, CLAUDE_CODE_AGENT: '1' },
+        });
+        return { status: r.status, stdout: r.stdout };
+    }
+    function writeRun(name, artifact) {
+        const dir = path.join(tmpDir, '.totem', 'artifacts', 'runs');
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, name), typeof artifact === 'string' ? artifact : JSON.stringify(artifact, null, 2));
+    }
+    // A `node` shim that fails: first on PATH, so the hook's reader cannot run.
+    // Exercises the reader-failure arm without touching the real runtime.
+    function shimNodeExiting(status) {
+        const shimDir = path.join(tmpDir, 'node-shim');
+        fs.mkdirSync(shimDir, { recursive: true });
+        fs.writeFileSync(path.join(shimDir, 'node'), `#!/bin/sh\nexit ${status}\n`, { mode: 0o755 });
+        return {
+            ...process.env,
+            CLAUDE_CODE_AGENT: '1',
+            PATH: `${shimDir}${path.delimiter}${process.env.PATH ?? ''}`,
+        };
+    }
+    function runHookWith(env) {
+        const r = spawnSync('sh', ['./pre-commit'], { cwd: tmpDir, encoding: 'utf-8', env });
+        return { status: r.status, stdout: r.stdout };
+    }
+    it.skipIf(!shellOk)('reports a reader that cannot run DISTINCTLY from missing evidence, and still fails closed', () => {
+        const r = runHookWith(shimNodeExiting(5));
+        expect(r.status).toBe(1);
+        expect(r.stdout).toContain('[Totem] BLOCKED: the spec-evidence reader could not run (node exit status 5');
+        expect(r.stdout).not.toContain('no totem spec run artifact');
+    });
+    it.skipIf(!shellOk)('a hand-set marker does not rescue a reader that cannot run — still the distinct failure, still closed', () => {
+        fs.mkdirSync(path.join(tmpDir, '.totem', 'cache'), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, '.totem', 'cache', '.spec-completed'), '');
+        const r = runHookWith(shimNodeExiting(127));
+        expect(r.status).toBe(1);
+        expect(r.stdout).toContain('the spec-evidence reader could not run (node exit status 127');
+        expect(r.stdout).not.toContain('legacy');
+    });
+    it.skipIf(!shellOk)('blocks when this checkout carries no evidence at all', () => {
+        const r = runHook();
+        expect(r.status).toBe(1);
+        expect(r.stdout).toContain("[Totem] BLOCKED: Run 'totem spec <issue>' before committing (strict mode)");
+        expect(r.stdout).toContain('no totem spec run artifact under .totem/artifacts/runs/');
+    });
+    it.skipIf(!shellOk)('passes on a spec run artifact and prints the evidence line with its age', () => {
+        writeRun('a.json', {
+            admission: { runMetadata: { caller: 'spec' } },
+            createdAt: new Date().toISOString(),
+        });
+        const r = runHook();
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain('[Totem] spec evidence: .totem/artifacts/runs/a.json (');
+        expect(r.stdout).toContain('0 days old');
+    });
+    it.skipIf(!shellOk)('does NOT pass on a review artifact that merely CARRIES a caller:spec object below the top level (the substring hazard)', () => {
+        // A substring read of the run store would match this file: the key
+        // spelling appears verbatim, as a carried OBJECT under inputBundle (the
+        // shape a review over run metadata produces). Only the TOP-LEVEL
+        // admission.runMetadata.caller is evidence. (Carried TEXT — a prompt that
+        // quotes the key — is JSON-escaped on disk and never matches either read;
+        // the carried-object form is the real hazard, so it is the control.)
+        writeRun('r.json', {
+            admission: { runMetadata: { caller: 'review' } },
+            inputBundle: { runMetadata: { caller: 'spec' } },
+            createdAt: new Date().toISOString(),
+        });
+        const onDisk = fs.readFileSync(path.join(tmpDir, '.totem/artifacts/runs/r.json'), 'utf-8');
+        // Mutation check on the control itself: the naive pattern WOULD match.
+        expect(/"caller": *"spec"/.test(onDisk)).toBe(true);
+        const r = runHook();
+        expect(r.status).toBe(1);
+        expect(r.stdout).toContain('BLOCKED');
+    });
+    it.skipIf(!shellOk)('ignores the retired hand-set marker — a marker alone is BLOCKED', () => {
+        // No CLI path ever wrote `.totem/cache/.spec-completed`; honoring it would be
+        // compatibility with a hand hack, not with a user (operator ruling
+        // 2026-08-29, mmnto-ai/totem#2690).
+        fs.mkdirSync(path.join(tmpDir, '.totem', 'cache'), { recursive: true });
+        fs.writeFileSync(path.join(tmpDir, '.totem', 'cache', '.spec-completed'), '');
+        const r = runHook();
+        expect(r.status).toBe(1);
+        expect(r.stdout).toContain('no totem spec run artifact under .totem/artifacts/runs/');
+        expect(r.stdout).not.toContain('spec evidence:');
+    });
+    it.skipIf(!shellOk)('skips a torn (unparseable) artifact and still passes on a valid one beside it', () => {
+        writeRun('torn.json', '{"admission": {"runMetadata": {"caller": "spec"');
+        writeRun('ok.json', {
+            admission: { runMetadata: { caller: 'spec' } },
+            createdAt: new Date().toISOString(),
+        });
+        const r = runHook();
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain('.totem/artifacts/runs/ok.json');
+    });
+    it.skipIf(!shellOk)('blocks when the only artifact is torn', () => {
+        writeRun('torn.json', '{"admission": {"runMetadata": {"caller": "spec"');
+        const r = runHook();
+        expect(r.status).toBe(1);
+    });
+    it.skipIf(!shellOk)('names the NEWEST spec artifact by its own createdAt', () => {
+        writeRun('old.json', {
+            admission: { runMetadata: { caller: 'spec' } },
+            createdAt: '2026-01-01T00:00:00.000Z',
+        });
+        writeRun('new.json', {
+            admission: { runMetadata: { caller: 'spec' } },
+            createdAt: new Date().toISOString(),
+        });
+        const r = runHook();
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain('.totem/artifacts/runs/new.json');
+        expect(r.stdout).not.toContain('old.json');
+    });
+});
+// The mmnto-ai/totem#2692 keystone, EXECUTED: under a custom `totemDir` the
+// hook's reader and `totem spec`'s writer must name the SAME tree. The fixture
+// writes where the WRITER writes (`<totemDir>/artifacts/runs`, the
+// `path.join(configRoot, config.totemDir)/artifacts/runs` the run store uses) and
+// the hook is rendered at that same totemDir — so a pass here is the two halves
+// agreeing, and the control below is the pre-fix behavior (evidence under
+// `.totem/` while the hook reads `knowledge/`) still failing closed.
+describe('buildPreCommitHook strict evidence under a CUSTOM totemDir — executed under sh (mmnto-ai/totem#2692)', () => {
+    const shellOk = spawnSync('sh', ['-c', 'command -v node >/dev/null 2>&1'], { encoding: 'utf-8' }).status === 0;
+    const CUSTOM_TOTEM_DIR = 'knowledge';
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'totem-hook-customdir-'));
+        execSync('git init -q', { cwd: tmpDir, stdio: 'ignore' });
+        execSync('git checkout -q -b feat/evidence', { cwd: tmpDir, stdio: 'ignore' });
+        fs.writeFileSync(path.join(tmpDir, 'pre-commit'), buildPreCommitHook({ ...RENDER, totemDir: CUSTOM_TOTEM_DIR }));
+    });
+    afterEach(() => {
+        cleanTmpDir(tmpDir);
+    });
+    function runHook() {
+        const r = spawnSync('sh', ['./pre-commit'], {
+            cwd: tmpDir,
+            encoding: 'utf-8',
+            env: { ...process.env, CLAUDE_CODE_AGENT: '1' },
+        });
+        return { status: r.status, stdout: r.stdout };
+    }
+    /** Write a run artifact where the WRITER writes it, for an arbitrary totemDir. */
+    function writeRunUnder(totemDir, name, artifact) {
+        const dir = path.join(tmpDir, ...totemDir.split('/'), 'artifacts', 'runs');
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, name), JSON.stringify(artifact, null, 2));
+    }
+    const specArtifact = () => ({
+        admission: { runMetadata: { caller: 'spec' } },
+        createdAt: new Date().toISOString(),
+    });
+    it.skipIf(!shellOk)('PASSES on evidence written under the configured totemDir', () => {
+        writeRunUnder(CUSTOM_TOTEM_DIR, 'a.json', specArtifact());
+        const r = runHook();
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain(`[Totem] spec evidence: ${CUSTOM_TOTEM_DIR}/artifacts/runs/a.json (`);
+    });
+    it.skipIf(!shellOk)('the pre-fix control: evidence under .totem/ does NOT satisfy a hook rendered for knowledge/', () => {
+        // This is the mmnto-ai/totem#2692 defect, inverted: before the fix the hook
+        // ALWAYS read `.totem/artifacts/runs` while the writer used the configured
+        // dir, so the gate failed closed forever. With the hook rendered at the
+        // configured dir, evidence in the WRONG tree is correctly not evidence.
+        writeRunUnder('.totem', 'a.json', specArtifact());
+        const r = runHook();
+        expect(r.status).toBe(1);
+        expect(r.stdout).toContain(`no totem spec run artifact under ${CUSTOM_TOTEM_DIR}/artifacts/runs/`);
+    });
+    it.skipIf(!shellOk)('blocks with a message naming the configured directory', () => {
+        const r = runHook();
+        expect(r.status).toBe(1);
+        expect(r.stdout).toContain("[Totem] BLOCKED: Run 'totem spec <issue>' before committing (strict mode)");
+        expect(r.stdout).toContain(`under ${CUSTOM_TOTEM_DIR}/artifacts/runs/`);
+        expect(r.stdout).not.toContain('.totem');
+    });
+    it.skipIf(!shellOk)('a nested totemDir survives the same round trip', () => {
+        const nested = 'var/totem-state';
+        fs.writeFileSync(path.join(tmpDir, 'pre-commit'), buildPreCommitHook({ ...RENDER, totemDir: nested }));
+        writeRunUnder(nested, 'a.json', specArtifact());
+        const r = runHook();
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain(`[Totem] spec evidence: ${nested}/artifacts/runs/a.json (`);
+    });
 });
 describe('buildPreCommitHook with standard tier', () => {
-    it('includes spec-completed check guarded by agent/tier condition', () => {
-        const hook = buildPreCommitHook('standard');
-        expect(hook).toContain('.spec-completed');
+    it('includes the spec-evidence check guarded by agent/tier condition', () => {
+        const hook = buildPreCommitHook(RENDER);
+        expect(hook).toContain('.totem/artifacts/runs');
         expect(hook).toContain('is_agent');
         expect(hook).toContain('TOTEM_HOOK_TIER="standard"');
     });
-    it('defaults to standard tier when no tier specified', () => {
-        const hook = buildPreCommitHook();
+    // Pre-mmnto-ai/totem#2692 this read "defaults to standard tier when no tier
+    // specified". There is no default any more — the options object is required and
+    // the RESOLVER supplies 'standard' — so the surviving intent is that the
+    // standard-tier render still names the run store the resolver hands it.
+    it('renders the run store at the options it was given', () => {
+        const hook = buildPreCommitHook(RENDER);
         expect(hook).toContain('TOTEM_HOOK_TIER="standard"');
-        expect(hook).toContain('.spec-completed');
+        expect(hook).toContain('.totem/artifacts/runs');
     });
 });
 describe('buildPrePushHook with strict tier', () => {
-    const FALLBACK = 'pnpm dlx @mmnto/cli';
     it('includes shield gate', () => {
-        const hook = buildPrePushHook(FALLBACK, 'strict');
+        const hook = buildPrePushHook({ ...RENDER, tier: 'strict' });
         expect(hook).toContain('review');
         expect(hook).toContain('shield gate (strict mode)');
     });
     it('includes TOTEM_HOOK_TIER set to strict', () => {
-        const hook = buildPrePushHook(FALLBACK, 'strict');
+        const hook = buildPrePushHook({ ...RENDER, tier: 'strict' });
         expect(hook).toContain('TOTEM_HOOK_TIER="strict"');
     });
     it('includes agent detection snippet', () => {
-        const hook = buildPrePushHook(FALLBACK, 'strict');
+        const hook = buildPrePushHook({ ...RENDER, tier: 'strict' });
         expect(hook).toContain('is_agent=0');
         expect(hook).toContain('CLAUDE_CODE_AGENT');
     });
@@ -1271,12 +1557,12 @@ describe('buildPrePushHook with strict tier', () => {
     // shieldBlock alongside the existing `totem review` gate. Repo-state
     // checks (like checkAgentsMdCanonical) now block push when they fail.
     it('includes $TOTEM_CMD doctor --strict in the shield block', () => {
-        const hook = buildPrePushHook(FALLBACK, 'strict');
+        const hook = buildPrePushHook({ ...RENDER, tier: 'strict' });
         expect(hook).toContain('$TOTEM_CMD doctor --strict');
         expect(hook).toContain('doctor --strict (repo-state gate)');
     });
     it('gates doctor --strict on the agent/strict guard (does NOT fire unconditionally)', () => {
-        const hook = buildPrePushHook(FALLBACK, 'strict');
+        const hook = buildPrePushHook({ ...RENDER, tier: 'strict' });
         // Find the position of the doctor --strict invocation and the surrounding
         // guard; assert the invocation lives INSIDE the agent-or-tier block.
         const guardIdx = hook.indexOf('if [ "$is_agent" = "1" ] || [ "$TOTEM_HOOK_TIER" = "strict" ]');
@@ -1288,20 +1574,22 @@ describe('buildPrePushHook with strict tier', () => {
     });
 });
 describe('buildPrePushHook with standard tier', () => {
-    const FALLBACK = 'pnpm dlx @mmnto/cli';
     it('includes shield gate guarded by agent/tier condition', () => {
-        const hook = buildPrePushHook(FALLBACK, 'standard');
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toContain('shield gate');
         expect(hook).toContain('is_agent');
         expect(hook).toContain('TOTEM_HOOK_TIER="standard"');
     });
-    it('defaults to standard tier when no tier specified', () => {
-        const hook = buildPrePushHook(FALLBACK);
+    // Pre-mmnto-ai/totem#2692 this read "defaults to standard tier when no tier
+    // specified" — the builders take a REQUIRED options object now, so the
+    // surviving intent is that a standard-tier render stamps the standard tier.
+    it('stamps the standard tier it was given', () => {
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toContain('TOTEM_HOOK_TIER="standard"');
         expect(hook).toContain('shield gate');
     });
     it('still includes agent detection', () => {
-        const hook = buildPrePushHook(FALLBACK, 'standard');
+        const hook = buildPrePushHook(RENDER);
         expect(hook).toContain('is_agent=0');
     });
     // mmnto-ai/totem#1908 — even in standard tier, the doctor --strict line
@@ -1310,7 +1598,7 @@ describe('buildPrePushHook with standard tier', () => {
     // operators bypass it because their `is_agent=0` and `TOTEM_HOOK_TIER` is
     // standard, so the guard branch never enters.
     it('emits doctor --strict gated by agent/strict guard (no unconditional fire in standard tier)', () => {
-        const hook = buildPrePushHook(FALLBACK, 'standard');
+        const hook = buildPrePushHook(RENDER);
         const guardIdx = hook.indexOf('if [ "$is_agent" = "1" ] || [ "$TOTEM_HOOK_TIER" = "strict" ]');
         const doctorIdx = hook.indexOf('$TOTEM_CMD doctor --strict');
         const fiCloseIdx = hook.indexOf('fi', guardIdx);
@@ -1321,7 +1609,7 @@ describe('buildPrePushHook with standard tier', () => {
 });
 describe('agent detection uses POSIX syntax', () => {
     it('pre-commit hook has no bashisms', () => {
-        const hook = buildPreCommitHook('strict');
+        const hook = buildPreCommitHook({ ...RENDER, tier: 'strict' });
         // Must use [ ] not [[ ]]
         expect(hook).not.toContain('[[');
         expect(hook).not.toContain(']]');
@@ -1331,7 +1619,7 @@ describe('agent detection uses POSIX syntax', () => {
         expect(hook).toMatch(/^#!\/bin\/sh\n/);
     });
     it('pre-push hook has no bashisms', () => {
-        const hook = buildPrePushHook('pnpm dlx @mmnto/cli', 'strict');
+        const hook = buildPrePushHook({ ...RENDER, tier: 'strict' });
         // Must use [ ] not [[ ]]
         expect(hook).not.toContain('[[');
         expect(hook).not.toContain(']]');