fix(workflow): detect nested git worktree in new-project bootstrap (#3491)

The `has_git` boolean returned by `init new-project` and `init ingest-docs`
was derived from a shallow `pathExists(cwd, '.git')` check, so a subdirectory
of an existing repo reported `has_git: false`. The workflow then ran
`git init`, creating a nested `.git` inside the outer worktree and silently
diverting subsequent `gsd-sdk commit` calls into the nested repo.

Replace the shallow check with `git rev-parse --is-inside-work-tree`
semantics in both CJS (`get-shit-done/bin/lib/init.cjs`) and TS
(`sdk/src/query/init.ts`, `sdk/src/query/init-complex.ts`) handlers via a new
shared `gitWorktreeInfoInternal` helper, and expose `git_worktree_root` +
`in_nested_subdir` so the workflows can refuse `git init` inside an existing
worktree and warn that planning files will track to the outer repo.

Regression test: `tests/bug-3491-nested-git-worktree.test.cjs`.

Fixes #3491

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tests/bug-3491-nested-git-worktree.test.cjs

@@ -0,0 +1,180 @@
+// allow-test-rule: source-text-is-the-product
+// Bug #3491 — new-project workflow creates nested .git in subdirectory when
+// parent already has git repo.
+//
+// The workflow's `has_git` boolean was derived from `pathExists(cwd, '.git')`
+// — a shallow check that only sees a `.git` entry directly in the current
+// directory. Subdirectories of an existing git worktree therefore reported
+// `has_git: false`, causing the workflow's `git init` step to create a nested
+// `.git` inside the outer repo's worktree. Subsequent gsd-sdk commits then
+// targeted the nested repo instead of the outer one, silently dropping all
+// planning artefacts from the outer repo's history.
+//
+// This test asserts the corrected semantics, mirroring `git rev-parse
+// --is-inside-work-tree`:
+//
+//   - `has_git: true` is reported whenever the cwd is inside a git worktree,
+//     even when no `.git` entry is in cwd itself.
+//   - The init payload surfaces `git_worktree_root` and `in_nested_subdir` so
+//     the workflow can warn the user and skip `git init`.
+//   - The workflow markdown's `git init` step is gated on
+//     `in_nested_subdir: false`, never unconditional under `has_git: false`.
+
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execSync } = require('node:child_process');
+
+const { runGsdTools, cleanup } = require('./helpers.cjs');
+
+const WORKFLOW_PATH = path.join(
+  __dirname,
+  '..',
+  'get-shit-done',
+  'workflows',
+  'new-project.md',
+);
+
+// ─── Helper: create outer git repo with a nested workstream subdir ─────────
+
+function createOuterRepoWithSubdir(prefix = 'bug-3491-') {
+  const outer = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  // macOS /tmp -> /private/tmp; resolve to the canonical path so comparisons
+  // against `git rev-parse --show-toplevel` succeed regardless of symlink.
+  const outerReal = fs.realpathSync(outer);
+  execSync('git init', { cwd: outerReal, stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { cwd: outerReal, stdio: 'pipe' });
+  execSync('git config user.name "Test"', { cwd: outerReal, stdio: 'pipe' });
+  execSync('git config commit.gpgsign false', { cwd: outerReal, stdio: 'pipe' });
+  fs.writeFileSync(path.join(outerReal, 'README.md'), '# outer\n');
+  execSync('git add -A', { cwd: outerReal, stdio: 'pipe' });
+  execSync('git commit -m "initial"', { cwd: outerReal, stdio: 'pipe' });
+
+  const subdir = path.join(outerReal, 'workstreams', 'my-project');
+  fs.mkdirSync(subdir, { recursive: true });
+  return { outer: outerReal, subdir };
+}
+
+// ─── Behavioural tests against the live `init new-project` handler ─────────
+
+test('bug-3491: init new-project reports has_git: true inside parent git worktree', () => {
+  const { outer, subdir } = createOuterRepoWithSubdir();
+  try {
+    const result = runGsdTools('init new-project', subdir);
+    assert.ok(result.success, `init new-project failed: ${result.error}`);
+
+    const payload = JSON.parse(result.output);
+
+    // Core fix: shallow `.git in cwd` check was wrong — we are inside the
+    // outer worktree, so the workflow MUST see has_git: true.
+    assert.strictEqual(
+      payload.has_git,
+      true,
+      'expected has_git=true when cwd is inside an existing git worktree (parent .git)',
+    );
+
+    // The workflow needs the worktree root and a nesting flag to decide
+    // whether to skip `git init` and emit a friendly warning.
+    assert.strictEqual(
+      payload.git_worktree_root,
+      outer,
+      `expected git_worktree_root to be the outer repo (${outer}), got: ${payload.git_worktree_root}`,
+    );
+    assert.strictEqual(
+      payload.in_nested_subdir,
+      true,
+      'expected in_nested_subdir=true when cwd is a subdirectory of the worktree root',
+    );
+  } finally {
+    cleanup(outer);
+  }
+});
+
+test('bug-3491: init new-project reports has_git: true at worktree root with in_nested_subdir: false', () => {
+  const { outer } = createOuterRepoWithSubdir();
+  try {
+    const result = runGsdTools('init new-project', outer);
+    assert.ok(result.success, `init new-project failed: ${result.error}`);
+
+    const payload = JSON.parse(result.output);
+    assert.strictEqual(payload.has_git, true, 'has_git must be true at the worktree root');
+    assert.strictEqual(payload.git_worktree_root, outer);
+    assert.strictEqual(
+      payload.in_nested_subdir,
+      false,
+      'at the worktree root, in_nested_subdir must be false',
+    );
+  } finally {
+    cleanup(outer);
+  }
+});
+
+test('bug-3491: init new-project reports has_git: false outside any git worktree', () => {
+  const tmp = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'bug-3491-bare-')));
+  try {
+    const result = runGsdTools('init new-project', tmp);
+    assert.ok(result.success, `init new-project failed: ${result.error}`);
+    const payload = JSON.parse(result.output);
+    assert.strictEqual(payload.has_git, false);
+    assert.strictEqual(payload.in_nested_subdir, false);
+    assert.strictEqual(payload.git_worktree_root, null);
+  } finally {
+    cleanup(tmp);
+  }
+});
+
+test('bug-3491: init ingest-docs mirrors the same has_git semantics', () => {
+  // ingest-docs.md has the same shallow check and the same nested-init risk.
+  const { outer, subdir } = createOuterRepoWithSubdir('bug-3491-ingest-');
+  try {
+    const result = runGsdTools('init ingest-docs', subdir);
+    assert.ok(result.success, `init ingest-docs failed: ${result.error}`);
+    const payload = JSON.parse(result.output);
+    assert.strictEqual(
+      payload.has_git,
+      true,
+      'init ingest-docs must also detect parent worktree (#3491 related path)',
+    );
+    assert.strictEqual(payload.git_worktree_root, outer);
+    assert.strictEqual(payload.in_nested_subdir, true);
+  } finally {
+    cleanup(outer);
+  }
+});
+
+// ─── Workflow-text test: the deployed `new-project.md` must gate `git init` ─
+
+test('bug-3491: new-project.md gates `git init` on in_nested_subdir, not just has_git', () => {
+  const content = fs.readFileSync(WORKFLOW_PATH, 'utf-8');
+
+  // The pre-fix workflow had the literal sequence:
+  //
+  //   **If `has_git` is false:** Initialize git:
+  //   ```bash
+  //   git init
+  //   ```
+  //
+  // …which fires for any subdirectory of an existing repo. The fix must
+  // either gate the init on `in_nested_subdir`/worktree-root semantics or
+  // drop the unconditional `git init` block entirely.
+  const unconditionalInitPattern =
+    /\*\*If `has_git` is false:\*\* Initialize git:\s*\n+```bash\s*\ngit init\s*\n```/;
+  assert.ok(
+    !unconditionalInitPattern.test(content),
+    'new-project.md must not run `git init` unconditionally on has_git=false (#3491). ' +
+      'Gate it on `in_nested_subdir === false` so the workflow refuses to create ' +
+      'a nested .git inside an existing worktree.',
+  );
+
+  // The fixed workflow MUST mention the new field so reviewers can see the
+  // gating exists. (Workflow markdown IS the deployed product — testing it
+  // as text is the only end-to-end signal we have.)
+  assert.ok(
+    /in_nested_subdir/.test(content),
+    'new-project.md must reference `in_nested_subdir` after the #3491 fix',
+  );
+});

tests/prompt-injection-scan.test.cjs

@@ -52,6 +52,7 @@ const SCAN_EXTS = new Set(['.md', '.cjs', '.js', '.json']);
 const ALLOWLIST = new Set([
   'get-shit-done/bin/lib/security.cjs',        // The security module itself
   'get-shit-done/workflows/discuss-phase.md',  // Large workflow (~50K) with power mode + i18n
+  'get-shit-done/workflows/new-project.md',     // Large workflow (~50K) — agent install, runtime detect, brownfield map, #3491 worktree gating
   'get-shit-done/workflows/execute-phase.md',  // Large orchestration workflow (~51K) with wave execution + code-review gate
   'get-shit-done/workflows/plan-phase.md',      // Large orchestration workflow (~51K) with TDD mode integration
   'hooks/gsd-prompt-guard.js',                  // The prompt guard hook