feat(3553): Project-Root Resolution Module via generator (Phase 4 of #3524)

Phase 4 of the CJS↔SDK hard-seam migration (parent #3524).
Eliminates the `findProjectRoot` duplication that lived at
bin/lib/core.cjs:74-140 and sdk/src/query/helpers.ts:497-590,
the drift carrier behind historical bugs #1362 and #2561.

- sdk/src/project-root/index.ts — source of truth (120 lines,
  pure-with-sync-fs). Exports findProjectRoot(startDir: string)
  and FIND_PROJECT_ROOT_MAX_DEPTH constant.
- sdk/src/project-root/index.test.ts — 13 vitest pinning fixtures
  covering all four heuristics, the #1362 guard, malformed
  config fallback, empty sub_repos, deep nesting, and depth-limit
  enforcement.
- sdk/scripts/gen-project-root.mjs — generator. Captures
  function body via Function.prototype.toString() from compiled
  sdk/dist/. Emits CJS preamble for destructured node:fs /
  node:path / node:os imports.
- sdk/scripts/check-project-root-fresh.mjs — freshness check.
  Imports the generator function directly (Phase 3's cleaner
  pattern).
- get-shit-done/bin/lib/project-root.generated.cjs — generator-
  emitted CJS mirror.
- tests/project-root-generator.test.cjs — 11 parity assertions
  comparing SDK source and generated CJS for every fixture.

- sdk/src/query/helpers.ts: -127 lines. The 94-line inline
  findProjectRoot plus the FIND_PROJECT_ROOT_MAX_DEPTH constant
  (originally at line 471) replaced by a single re-export:
  `export { findProjectRoot } from '../project-root/index.js';`
  Removed unused `parse as parsePath` import.
- get-shit-done/bin/lib/core.cjs: -83 lines net. The 67-line
  inline findProjectRoot replaced by a single
  `require('./project-root.generated.cjs')`. The detectSubRepos
  helper at lines 40-56 stays (used by loadConfig migration).

- sdk/package.json: gen:project-root + check:project-root-fresh
  scripts.
- package.json: proxy for the freshness check.
- .githooks/pre-commit: drift block.
- .github/workflows/test.yml: drift check step after the
  state-document drift step.
- CONTEXT.md: Project-Root Resolution Module entry.
- docs/INVENTORY.md, docs/INVENTORY-MANIFEST.json:
  +1 module count, +1 row.

- Full suite: 9226/9226 pass (baseline 9215 + 11 new parity
  fixtures).
- SDK vitest: 1804/1804 pass.
- Reader shrink: -127 SDK + -83 CJS = 210 lines of duplication
  deleted across the two Readers. New shared Module is 120 lines.

1. Depth limit canonicalization. CJS findProjectRoot previously
   had no explicit walk-up bound (walked until dir === root or
   homedir). The new Module uses FIND_PROJECT_ROOT_MAX_DEPTH = 10,
   matching the SDK's pre-existing value. Only affects paths
   nested more than 10 levels deep from a .planning/ root — a
   pathological case in practice. None of the existing 22 CJS
   findProjectRoot tests covered this; the new parity test does.
2. platformReadSync → readFileSync. The old CJS findProjectRoot
   used the platformReadSync wrapper from
   shell-command-projection.cjs for reading .planning/config.json,
   which returns null on read failure. The Module uses raw
   readFileSync, which throws — caught by the surrounding
   try/catch that already swallowed errors. Functionally
   equivalent for the existing code path; no test exercises the
   null-return semantic.

Closes #3553.

sdk/scripts/check-project-root-fresh.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+/**
+ * Freshness check for project-root.generated.cjs.
+ *
+ * Regenerates the expected CJS content in-memory (without writing to disk) and
+ * compares it to the committed file. Exits 0 if they match, 1 if stale.
+ *
+ * Uses Phase 3's cleaner pattern: imports buildProjectRootCjs() from the
+ * generator directly rather than duplicating the build logic.
+ *
+ * Run: node sdk/scripts/check-project-root-fresh.mjs
+ * (Requires sdk/dist to be built first — `npm run build` in sdk/.)
+ */
+
+import { readFile } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+// Import the generator function directly (avoids duplicating logic).
+const { buildProjectRootCjs } = await import('./gen-project-root.mjs');
+
+const expected = await buildProjectRootCjs();
+
+const committedPath = resolve(here, '..', '..', 'get-shit-done', 'bin', 'lib', 'project-root.generated.cjs');
+const committed = await readFile(committedPath, 'utf-8');
+
+if (expected === committed) {
+  console.log('project-root.generated.cjs is fresh');
+  process.exit(0);
+} else {
+  console.error('project-root.generated.cjs is STALE.');
+  console.error('Regenerate: cd sdk && npm run gen:project-root');
+  process.exit(1);
+}

sdk/scripts/gen-project-root.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+/**
+ * Generator for the Project-Root Resolution Module CJS artifact.
+ *
+ * Imports the compiled ESM output from sdk/dist/project-root/index.js,
+ * captures findProjectRoot via Function.prototype.toString(), then emits
+ * get-shit-done/bin/lib/project-root.generated.cjs.
+ *
+ * Run: cd sdk && npm run gen:project-root
+ * Freshness check: node sdk/scripts/check-project-root-fresh.mjs
+ */
+
+import { writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+const BANNER = `'use strict';
+
+/**
+ * GENERATED FILE — DO NOT EDIT.
+ *
+ * Source: sdk/src/project-root/index.ts
+ * Regenerate: cd sdk && npm run gen:project-root
+ *
+ * Project-Root Resolution Module — resolves a project root from a starting
+ * directory by walking the ancestor chain and applying four heuristics:
+ *   (0) own .planning/ guard (#1362)
+ *   (1) parent .planning/config.json sub_repos
+ *   (2) legacy multiRepo: true + ancestor .git
+ *   (3) .git heuristic with parent .planning/
+ * Bounded by FIND_PROJECT_ROOT_MAX_DEPTH ancestors. Sync I/O.
+ */
+
+`;
+
+/**
+ * Build the CJS content string. Exported so the freshness-check script can
+ * import this function directly (Phase 3's cleaner pattern) instead of
+ * duplicating the logic.
+ */
+export async function buildProjectRootCjs() {
+  const distUrl = new URL('../dist/project-root/index.js', import.meta.url);
+  const { findProjectRoot, FIND_PROJECT_ROOT_MAX_DEPTH } = await import(distUrl.href);
+
+  const findProjectRootBody = findProjectRoot.toString();
+
+  // The compiled ESM uses destructured named imports:
+  //   import { dirname, resolve, sep, relative, parse as parsePath } from 'node:path';
+  //   import { existsSync, readFileSync, statSync } from 'node:fs';
+  //   import { homedir } from 'node:os';
+  //
+  // In CJS we provide these as module-level constants so the function body
+  // can reference them as closed-over variables (same technique used in
+  // Phase 3 gen-workstream-inventory-builder.mjs for relative/sep/etc.).
+  const preamble = [
+    `const fs = require('fs');`,
+    `const path = require('path');`,
+    `const os = require('os');`,
+    `const { existsSync, readFileSync, statSync } = fs;`,
+    `const { dirname, resolve, sep, relative, parse: parsePath } = path;`,
+    `const { homedir } = os;`,
+    `const FIND_PROJECT_ROOT_MAX_DEPTH = ${FIND_PROJECT_ROOT_MAX_DEPTH};`,
+  ].join('\n');
+
+  const parts = [
+    BANNER.trimEnd(),
+    '',
+    preamble,
+    '',
+    findProjectRootBody,
+    '',
+    `module.exports = { findProjectRoot };`,
+    '',
+  ];
+
+  return parts.join('\n');
+}
+
+async function main() {
+  const content = await buildProjectRootCjs();
+  const outPath = fileURLToPath(
+    new URL('../../get-shit-done/bin/lib/project-root.generated.cjs', import.meta.url),
+  );
+  await writeFile(outPath, content, 'utf-8');
+  console.log(`Written: ${outPath}`);
+}
+
+// Only run main() when this file is the entry point, not when imported.
+const scriptPath = fileURLToPath(import.meta.url);
+const entryPath = process.argv[1] ? new URL(process.argv[1], 'file://').pathname : '';
+if (scriptPath === entryPath || process.argv[1] === scriptPath) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}