Fix interview.mjs CLI deadlocking on its own import cycle

`interview.mjs check` exited 13 ("unsettled top-level await") in every repo,
canon included, so the pending-adoption note could never print anywhere.
Refs #580.

The cycle closes only when this module is the entry point: its top-level
`await check(...)` holds evaluation open, check() calls loadPacks(), discovery
dynamically imports every pack's skills/<skill>/checks.mjs, and
adopt-claudinite/checks.mjs imports interviewState straight back from the module
still being evaluated. That import can never resolve, so the await never
settles. Not gated on the pack being declared — scanSkillChecks runs at
discovery, before activation is consulted.

Starting the work after evaluation completes leaves the same cycle harmless: the
re-import resolves against a finished module. Kept fail-soft, since the
orchestrator treats a failed step as a missing note rather than a crash.

The bug shipped because every existing test imports the pure helpers directly,
and the cycle only closes in the CLI. The regression tests spawn it as a child
process and assert the note reaches stdout, not merely that the exit code is
0 — a process exiting clean having printed nothing is this bug's own signature.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RVkfwBVJWV7tdk25KjNpdL

Author: claude

packs-tests/grow_with_claudinite/skills/adopt-claudinite/interview.test.mjs

@@ -1,10 +1,14 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 import { makeRepo, cleanup } from '../../../../engine-tests/helpers.mjs';
 import { loadConfig } from '../../../../engine/checks/helpers/repo-context.mjs';
 import { loadPacks } from '../../../../engine/pack_loader/pack-registry.mjs';
 import { packQuestions, interviewState, renderPending } from '../../../../packs/grow_with_claudinite/skills/adopt-claudinite/interview.mjs';
 
+const CLI = fileURLToPath(new URL('../../../../packs/grow_with_claudinite/skills/adopt-claudinite/interview.mjs', import.meta.url));
+
 const pack = (over = {}) => ({
   id: 'p',
   questions: [{ id: 'q1', prompt: 'P1?' }, { id: 'q2', prompt: 'P2?', distill: 'D2' }],
@@ -98,3 +102,44 @@ test('integration: declaring barriers pends its goals question until the entry a
     assert.deepEqual(interviewState(packs, loadConfig(answered)).pending, []);
   } finally { cleanup(unanswered); cleanup(answered); }
 });
+
+// The CLI, run as a CHILD PROCESS — the only context where this module's import
+// cycle closes, and so the only shape that can catch it. Every test above
+// imports the pure helpers directly, which is exactly why the cycle shipped: it
+// deadlocked `interview.mjs check` in every repo (Node exits 13, "unsettled
+// top-level await") while the pure-function coverage stayed green. Asserting the
+// note reaches stdout, not merely that the exit code is 0, is deliberate — a
+// process that exits clean having printed nothing is the bug's own signature.
+test('CLI: `check` prints the pending note and exits clean (its import cycle must not deadlock)', () => {
+  const repo = makeRepo({ base: { '.claudinite-checks.json': JSON.stringify({ packs: ['barriers'] }) } });
+  try {
+    const r = spawnSync(process.execPath, [CLI, 'check'], {
+      encoding: 'utf8',
+      env: { ...process.env, CLAUDE_PROJECT_DIR: repo },
+    });
+    assert.equal(r.status, 0, `exited ${r.status}\nstderr: ${r.stderr}`);
+    assert.doesNotMatch(r.stderr, /unsettled top-level await/, 'the CLI deadlocked on its own import cycle');
+    assert.match(r.stdout, /Pack adoption interview pending/);
+    assert.match(r.stdout, /- barriers \/ goals:/);
+  } finally { cleanup(repo); }
+});
+
+test('CLI: a repo with nothing pending prints nothing and exits clean', () => {
+  const repo = makeRepo({ base: { '.claudinite-checks.json': JSON.stringify({
+    packs: [{ id: 'barriers', answers: { goals: 'n/a — none wanted' } }],
+  }) } });
+  try {
+    const r = spawnSync(process.execPath, [CLI, 'check'], {
+      encoding: 'utf8',
+      env: { ...process.env, CLAUDE_PROJECT_DIR: repo },
+    });
+    assert.equal(r.status, 0, `exited ${r.status}\nstderr: ${r.stderr}`);
+    assert.equal(r.stdout, '');
+  } finally { cleanup(repo); }
+});
+
+test('CLI: an unknown subcommand still reports usage and exits 2', () => {
+  const r = spawnSync(process.execPath, [CLI, 'nope'], { encoding: 'utf8' });
+  assert.equal(r.status, 2);
+  assert.match(r.stderr, /usage: interview\.mjs check/);
+});

packs/grow_with_claudinite/skills/adopt-claudinite/interview.mjs

@@ -107,11 +107,25 @@ async function check(projectRoot) {
 }
 
 // CLI — but importable (the tests and the runner import the pure helpers above).
+//
+// NEVER `await check(...)` here. This module sits in a cycle that closes only
+// when it is the ENTRY point: check() calls loadPacks(), whose discovery
+// dynamically imports every pack's skills/<skill>/checks.mjs, and both
+// adopt-claudinite/checks.mjs and adopt-pack/checks.mjs import `interviewState`
+// from this file. A top-level await holds this module's evaluation open, so that
+// re-import can never resolve, the await never settles, and Node exits 13
+// without running the check at all — silently, since the orchestrator treats a
+// failed step as fail-soft. Starting the work AFTER evaluation completes leaves
+// the same cycle harmless: the re-import resolves against a finished module.
 if (import.meta.url === pathToFileURL(process.argv[1] || '').href) {
   const cmd = process.argv[2];
   const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.cwd();
   if (cmd === 'check') {
-    await check(projectRoot); // fails soft upstream — the orchestrator tolerates a step failure
+    // Fails soft upstream — the orchestrator tolerates a step failure, so a
+    // broken check must degrade to a missing note, never to a crash.
+    check(projectRoot).catch((e) => {
+      process.stderr.write(`interview check failed: ${e.message}\n`);
+    });
   } else {
     process.stderr.write('usage: interview.mjs check\n');
     process.exit(2);