gsd-pi 2.41.0 → 2.42.0-dev.eedc83f

package/src/resources/extensions/gsd/git-service.ts

@@ -9,8 +9,8 @@
  */
 
 import { execFileSync, execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -486,11 +486,80 @@ export class GitServiceImpl {
     // git add -A already skips it and the exclusions are harmless no-ops.
     const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
     nativeAddAllWithExclusions(this.basePath, allExclusions);
+
+    // Force-add .gsd/milestones/ when .gsd is a symlink (#2104).
+    // When .gsd is a symlink (external state projects), ensureGitignore adds
+    // `.gsd` to .gitignore. The nativeAddAllWithExclusions call above falls
+    // back to plain `git add -A` (symlink pathspec rejection), which respects
+    // .gitignore and silently skips new .gsd/milestones/ files.
+    //
+    // `git add -f` also fails with "beyond a symbolic link", so we use
+    // `git hash-object -w` + `git update-index --add --cacheinfo` to bypass
+    // the symlink restriction entirely. This stages each milestone artifact
+    // individually by hashing the file content and updating the index directly.
+    const gsdPath = join(this.basePath, ".gsd");
+    const milestonesDir = join(gsdPath, "milestones");
+    try {
+      if (
+        existsSync(gsdPath) &&
+        lstatSync(gsdPath).isSymbolicLink() &&
+        existsSync(milestonesDir)
+      ) {
+        this._forceAddMilestoneArtifacts(milestonesDir);
+      }
+    } catch {
+      // Non-fatal: if force-add fails, the commit proceeds without these files.
+      // This matches existing behavior where milestone artifacts were silently
+      // omitted — but now we at least attempt to include them.
+    }
   }
 
   /** Tracks whether runtime file cleanup has run this session. */
   private _runtimeFilesCleanedUp = false;
 
+  /**
+   * Recursively collect all files under a directory.
+   * Returns paths relative to `basePath` (e.g. ".gsd/milestones/M009/SUMMARY.md").
+   */
+  private _collectFiles(dir: string): string[] {
+    const files: string[] = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...this._collectFiles(full));
+      } else if (entry.isFile()) {
+        files.push(relative(this.basePath, full));
+      }
+    }
+    return files;
+  }
+
+  /**
+   * Stage milestone artifacts through a symlinked .gsd directory (#2104).
+   *
+   * `git add` (even with `-f`) refuses to stage files "beyond a symbolic link".
+   * This method bypasses that restriction by hashing each file with
+   * `git hash-object -w` and inserting the blob into the index with
+   * `git update-index --add --cacheinfo 100644 <hash> <path>`.
+   */
+  private _forceAddMilestoneArtifacts(milestonesDir: string): void {
+    const files = this._collectFiles(milestonesDir);
+    for (const filePath of files) {
+      const hash = execFileSync("git", ["hash-object", "-w", filePath], {
+        cwd: this.basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: GIT_NO_PROMPT_ENV,
+      }).trim();
+      execFileSync("git", ["update-index", "--add", "--cacheinfo", "100644", hash, filePath], {
+        cwd: this.basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: GIT_NO_PROMPT_ENV,
+      });
+    }
+  }
+
   /**
    * Stage files (smart staging) and commit.
    * Returns the commit message string on success, or null if nothing to commit.
@@ -683,10 +752,11 @@ export function createDraftPR(
   body: string,
 ): string | null {
   try {
-    const result = execSync(
-      `gh pr create --draft --title ${JSON.stringify(title)} --body ${JSON.stringify(body)}`,
-      { cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV },
-    );
+    const result = execFileSync("gh", [
+      "pr", "create", "--draft",
+      "--title", title,
+      "--body", body,
+    ], { cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV });
     return result.trim();
   } catch {
     return null;

package/src/resources/extensions/gsd/graph.ts

@@ -0,0 +1,312 @@
+/**
+ * graph.ts — Pure data module for GRAPH.yaml workflow step tracking.
+ *
+ * Provides types and functions for reading, writing, and querying the
+ * step graph that drives CustomWorkflowEngine. Zero engine dependencies.
+ *
+ * GRAPH.yaml lives in a run directory and tracks step statuses
+ * (pending → active → complete) with optional dependency edges.
+ *
+ * Observability:
+ * - readGraph/writeGraph use YAML on disk — human-readable, diffable,
+ *   inspectable with `cat` or any YAML viewer.
+ * - Each GraphStep has status, startedAt, finishedAt fields visible in GRAPH.yaml.
+ * - writeGraph uses atomic write (tmp + rename) for crash safety.
+ * - All operations are immutable — callers always get a new graph object.
+ */
+
+import { parse, stringify } from "yaml";
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import type { WorkflowDefinition } from "./definition-loader.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────
+
+export interface GraphStep {
+  /** Unique step identifier within the workflow. */
+  id: string;
+  /** Human-readable step title. */
+  title: string;
+  /** Current status: pending → active → complete → expanded (iterate parent). */
+  status: "pending" | "active" | "complete" | "expanded";
+  /** The prompt to dispatch for this step. */
+  prompt: string;
+  /** IDs of steps that must be "complete" before this step can run. */
+  dependsOn: string[];
+  /** For iteration instances: ID of the parent step that was expanded. */
+  parentStepId?: string;
+  /** ISO timestamp when the step started executing. */
+  startedAt?: string;
+  /** ISO timestamp when the step finished executing. */
+  finishedAt?: string;
+}
+
+export interface WorkflowGraph {
+  /** Ordered list of steps in the workflow. */
+  steps: GraphStep[];
+  /** Workflow metadata. */
+  metadata: {
+    name: string;
+    createdAt: string;
+  };
+}
+
+// ─── YAML schema mapping ─────────────────────────────────────────────────
+
+const GRAPH_FILENAME = "GRAPH.yaml";
+
+/**
+ * Internal YAML shape — uses snake_case for YAML keys.
+ * Converted to/from the camelCase TypeScript types on read/write.
+ */
+interface YamlStep {
+  id: string;
+  title: string;
+  status: string;
+  prompt: string;
+  depends_on?: string[];
+  parent_step_id?: string;
+  started_at?: string;
+  finished_at?: string;
+}
+
+interface YamlGraph {
+  steps: YamlStep[];
+  metadata: { name: string; created_at: string };
+}
+
+// ─── Functions ───────────────────────────────────────────────────────────
+
+/**
+ * Read and parse GRAPH.yaml from a run directory.
+ *
+ * @param runDir — directory containing GRAPH.yaml
+ * @returns Parsed workflow graph
+ * @throws Error if file doesn't exist or YAML is malformed
+ */
+export function readGraph(runDir: string): WorkflowGraph {
+  const filePath = join(runDir, GRAPH_FILENAME);
+  if (!existsSync(filePath)) {
+    throw new Error(`GRAPH.yaml not found: ${filePath}`);
+  }
+  const raw = readFileSync(filePath, "utf-8");
+  const yaml = parse(raw) as YamlGraph;
+
+  if (!yaml?.steps || !Array.isArray(yaml.steps)) {
+    throw new Error(`Invalid GRAPH.yaml: missing or invalid 'steps' array in ${filePath}`);
+  }
+
+  return {
+    steps: yaml.steps.map((s) => ({
+      id: s.id,
+      title: s.title,
+      status: s.status as GraphStep["status"],
+      prompt: s.prompt,
+      dependsOn: s.depends_on ?? [],
+      ...(s.parent_step_id != null ? { parentStepId: s.parent_step_id } : {}),
+      ...(s.started_at != null ? { startedAt: s.started_at } : {}),
+      ...(s.finished_at != null ? { finishedAt: s.finished_at } : {}),
+    })),
+    metadata: {
+      name: yaml.metadata?.name ?? "unnamed",
+      createdAt: yaml.metadata?.created_at ?? new Date().toISOString(),
+    },
+  };
+}
+
+/**
+ * Write a workflow graph to GRAPH.yaml in a run directory.
+ * Creates the directory if it doesn't exist. Write is atomic (write + rename).
+ *
+ * @param runDir — directory to write GRAPH.yaml into
+ * @param graph — the workflow graph to serialize
+ */
+export function writeGraph(runDir: string, graph: WorkflowGraph): void {
+  if (!existsSync(runDir)) {
+    mkdirSync(runDir, { recursive: true });
+  }
+
+  const yamlData: YamlGraph = {
+    steps: graph.steps.map((s) => ({
+      id: s.id,
+      title: s.title,
+      status: s.status,
+      prompt: s.prompt,
+      depends_on: s.dependsOn.length > 0 ? s.dependsOn : undefined,
+      parent_step_id: s.parentStepId ?? undefined,
+      started_at: s.startedAt ?? undefined,
+      finished_at: s.finishedAt ?? undefined,
+    })) as YamlStep[],
+    metadata: {
+      name: graph.metadata.name,
+      created_at: graph.metadata.createdAt,
+    },
+  };
+
+  const filePath = join(runDir, GRAPH_FILENAME);
+  const tmpPath = filePath + ".tmp";
+  const content = stringify(yamlData);
+  writeFileSync(tmpPath, content, "utf-8");
+  // Atomic rename for crash safety
+  renameSync(tmpPath, filePath);
+}
+
+/**
+ * Get the next pending step whose dependencies are all complete.
+ *
+ * Returns the first step (in array order) with status "pending" where
+ * every step in its `dependsOn` list has status "complete".
+ *
+ * @param graph — the workflow graph to query
+ * @returns The next dispatchable step, or null if none available
+ */
+export function getNextPendingStep(graph: WorkflowGraph): GraphStep | null {
+  const statusMap = new Map(graph.steps.map((s) => [s.id, s.status]));
+
+  for (const step of graph.steps) {
+    if (step.status !== "pending") continue;
+    const depsComplete = step.dependsOn.every(
+      (depId) => statusMap.get(depId) === "complete",
+    );
+    if (depsComplete) return step;
+  }
+
+  return null;
+}
+
+/**
+ * Return a new graph with the specified step marked as "complete".
+ * Immutable — does not mutate the input graph.
+ *
+ * @param graph — the current workflow graph
+ * @param stepId — ID of the step to mark complete
+ * @returns New graph with the step's status set to "complete"
+ * @throws Error if stepId is not found in the graph
+ */
+export function markStepComplete(
+  graph: WorkflowGraph,
+  stepId: string,
+): WorkflowGraph {
+  const found = graph.steps.some((s) => s.id === stepId);
+  if (!found) {
+    throw new Error(`Step not found: ${stepId}`);
+  }
+
+  return {
+    ...graph,
+    steps: graph.steps.map((s) =>
+      s.id === stepId
+        ? { ...s, status: "complete" as const, finishedAt: new Date().toISOString() }
+        : s,
+    ),
+  };
+}
+
+// ─── Iteration expansion ─────────────────────────────────────────────────
+
+/**
+ * Expand an iterate step into concrete instances. Pure and deterministic —
+ * identical inputs always produce identical output.
+ *
+ * Given a parent step with status "pending" and an array of matched items,
+ * creates one instance step per item, marks the parent as "expanded", and
+ * rewrites any downstream dependsOn references from the parent ID to the
+ * full set of instance IDs.
+ *
+ * @param graph — the current workflow graph (not mutated)
+ * @param stepId — ID of the iterate step to expand
+ * @param items — matched items from the source artifact
+ * @param promptTemplate — template with {{item}} placeholders
+ * @returns New WorkflowGraph with instances inserted and deps rewritten
+ * @throws Error if stepId not found or step is not pending
+ */
+export function expandIteration(
+  graph: WorkflowGraph,
+  stepId: string,
+  items: string[],
+  promptTemplate: string,
+): WorkflowGraph {
+  const parentIndex = graph.steps.findIndex((s) => s.id === stepId);
+  if (parentIndex === -1) {
+    throw new Error(`expandIteration: step not found: ${stepId}`);
+  }
+  const parentStep = graph.steps[parentIndex];
+  if (parentStep.status !== "pending") {
+    throw new Error(
+      `expandIteration: step "${stepId}" has status "${parentStep.status}", expected "pending"`,
+    );
+  }
+
+  // Create instance steps
+  const instanceIds: string[] = [];
+  const instances: GraphStep[] = items.map((item, i) => {
+    const instanceId = `${stepId}--${String(i + 1).padStart(3, "0")}`;
+    instanceIds.push(instanceId);
+    return {
+      id: instanceId,
+      title: `${parentStep.title}: ${item}`,
+      status: "pending" as const,
+      prompt: promptTemplate.replace(/\{\{item\}\}/g, () => item),
+      dependsOn: [...parentStep.dependsOn],
+      parentStepId: stepId,
+    };
+  });
+
+  // Build new steps array: copy everything, mark parent as expanded,
+  // insert instances right after the parent, rewrite downstream deps.
+  const newSteps: GraphStep[] = [];
+  for (let i = 0; i < graph.steps.length; i++) {
+    if (i === parentIndex) {
+      // Mark parent as expanded
+      newSteps.push({ ...parentStep, status: "expanded" as const });
+      // Insert instances immediately after parent
+      newSteps.push(...instances);
+    } else {
+      const step = graph.steps[i];
+      // Rewrite dependsOn: replace parent ID with all instance IDs
+      const hasDep = step.dependsOn.includes(stepId);
+      if (hasDep) {
+        const rewritten = step.dependsOn.flatMap((dep) =>
+          dep === stepId ? instanceIds : [dep],
+        );
+        newSteps.push({ ...step, dependsOn: rewritten });
+      } else {
+        newSteps.push(step);
+      }
+    }
+  }
+
+  return {
+    ...graph,
+    steps: newSteps,
+  };
+}
+
+// ─── Definition → Graph conversion ──────────────────────────────────────
+
+/**
+ * Convert a parsed WorkflowDefinition into a WorkflowGraph with all
+ * steps in "pending" status. Used by run-manager to generate the initial
+ * GRAPH.yaml for a new run.
+ *
+ * @param def — a validated WorkflowDefinition from definition-loader
+ * @returns WorkflowGraph with pending steps and metadata from the definition
+ */
+export function initializeGraph(def: WorkflowDefinition): WorkflowGraph {
+  return {
+    steps: def.steps.map((s) => ({
+      id: s.id,
+      title: s.name,
+      status: "pending" as const,
+      prompt: s.prompt,
+      dependsOn: s.requires ?? [],
+    })),
+    metadata: {
+      name: def.name,
+      createdAt: new Date().toISOString(),
+    },
+  };
+}
+
+/** @deprecated Use initializeGraph instead. Kept for backward compatibility. */
+export { initializeGraph as graphFromDefinition };

package/src/resources/extensions/gsd/gsd-db.ts

@@ -168,7 +168,7 @@ function openRawDb(path: string): unknown {
 
 // ─── Schema ────────────────────────────────────────────────────────────────
 
-const SCHEMA_VERSION = 3;
+const SCHEMA_VERSION = 4;
 
 function initSchema(db: DbAdapter, fileBacked: boolean): void {
   // WAL mode for file-backed databases (must be outside transaction)
@@ -195,6 +195,7 @@ function initSchema(db: DbAdapter, fileBacked: boolean): void {
         choice TEXT NOT NULL DEFAULT '',
         rationale TEXT NOT NULL DEFAULT '',
         revisable TEXT NOT NULL DEFAULT '',
+        made_by TEXT NOT NULL DEFAULT 'agent',
         superseded_by TEXT DEFAULT NULL
       )
     `);
@@ -360,6 +361,22 @@ function migrateSchema(db: DbAdapter): void {
       ).run({ ":version": 3, ":applied_at": new Date().toISOString() });
     }
 
+    // v3 → v4: add made_by column to decisions table
+    if (currentVersion < 4) {
+      // Add made_by column — default 'agent' for existing rows (pre-attribution decisions)
+      db.exec(`ALTER TABLE decisions ADD COLUMN made_by TEXT NOT NULL DEFAULT 'agent'`);
+
+      // Recreate views to pick up new columns (SQLite expands SELECT * at view creation time)
+      db.exec("DROP VIEW IF EXISTS active_decisions");
+      db.exec(
+        "CREATE VIEW active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL",
+      );
+
+      db.prepare(
+        "INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)",
+      ).run({ ":version": 4, ":applied_at": new Date().toISOString() });
+    }
+
     db.exec("COMMIT");
   } catch (err) {
     db.exec("ROLLBACK");
@@ -471,8 +488,8 @@ export function insertDecision(d: Omit<Decision, "seq">): void {
     throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
   currentDb
     .prepare(
-      `INSERT INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, superseded_by)
-     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :superseded_by)`,
+      `INSERT INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
+     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :made_by, :superseded_by)`,
     )
     .run({
       ":id": d.id,
@@ -482,6 +499,7 @@ export function insertDecision(d: Omit<Decision, "seq">): void {
       ":choice": d.choice,
       ":rationale": d.rationale,
       ":revisable": d.revisable,
+      ":made_by": d.made_by ?? "agent",
       ":superseded_by": d.superseded_by,
     });
 }
@@ -502,6 +520,7 @@ export function getDecisionById(id: string): Decision | null {
     choice: row["choice"] as string,
     rationale: row["rationale"] as string,
     revisable: row["revisable"] as string,
+    made_by: (row["made_by"] as string as import("./types.js").DecisionMadeBy) ?? "agent",
     superseded_by: (row["superseded_by"] as string) ?? null,
   };
 }
@@ -521,6 +540,7 @@ export function getActiveDecisions(): Decision[] {
     choice: row["choice"] as string,
     rationale: row["rationale"] as string,
     revisable: row["revisable"] as string,
+    made_by: (row["made_by"] as string as import("./types.js").DecisionMadeBy) ?? "agent",
     superseded_by: null,
   }));
 }
@@ -644,8 +664,8 @@ export function upsertDecision(d: Omit<Decision, "seq">): void {
     throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
   currentDb
     .prepare(
-      `INSERT OR REPLACE INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, superseded_by)
-     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :superseded_by)`,
+      `INSERT OR REPLACE INTO decisions (id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
+     VALUES (:id, :when_context, :scope, :decision, :choice, :rationale, :revisable, :made_by, :superseded_by)`,
     )
     .run({
       ":id": d.id,
@@ -655,6 +675,7 @@ export function upsertDecision(d: Omit<Decision, "seq">): void {
       ":choice": d.choice,
       ":rationale": d.rationale,
       ":revisable": d.revisable,
+      ":made_by": d.made_by ?? "agent",
       ":superseded_by": d.superseded_by ?? null,
     });
 }
@@ -783,9 +804,15 @@ export function reconcileWorktreeDb(
   try {
     adapter.exec(`ATTACH DATABASE '${worktreeDbPath}' AS wt`);
     try {
+      // Check if attached wt database has the made_by column (legacy v3 worktrees won't)
+      const wtInfo = adapter.prepare("PRAGMA wt.table_info('decisions')").all();
+      const hasMadeBy = wtInfo.some((col) => col["name"] === "made_by");
+
       const decConf = adapter
         .prepare(
-          `SELECT m.id FROM decisions m INNER JOIN wt.decisions w ON m.id = w.id WHERE m.decision != w.decision OR m.choice != w.choice OR m.rationale != w.rationale OR m.superseded_by IS NOT w.superseded_by`,
+          `SELECT m.id FROM decisions m INNER JOIN wt.decisions w ON m.id = w.id WHERE m.decision != w.decision OR m.choice != w.choice OR m.rationale != w.rationale OR ${
+            hasMadeBy ? "m.made_by != w.made_by" : "'agent' != 'agent'"
+          } OR m.superseded_by IS NOT w.superseded_by`,
         )
         .all();
       for (const row of decConf)
@@ -808,10 +835,12 @@ export function reconcileWorktreeDb(
           .prepare(
             `
           INSERT OR REPLACE INTO decisions (
-            id, when_context, scope, decision, choice, rationale, revisable, superseded_by
+            id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by
           )
           SELECT
-            id, when_context, scope, decision, choice, rationale, revisable, superseded_by
+            id, when_context, scope, decision, choice, rationale, revisable, ${
+              hasMadeBy ? "made_by" : "'agent'"
+            }, superseded_by
           FROM wt.decisions
         `,
           )

package/src/resources/extensions/gsd/guided-flow-queue.ts

@@ -170,7 +170,7 @@ export async function showQueueAdd(
   const existingContext = await buildExistingMilestonesContext(basePath, milestoneIds, state);
 
   // ── Determine next milestone ID ─────────────────────────────────────
-  // Note: the LLM will use the gsd_generate_milestone_id tool to get IDs
+  // Note: the LLM will use the gsd_milestone_generate_id tool to get IDs
   // at creation time, but we still mention the next ID in the preamble
   // for context about where the sequence is.
   const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;

package/src/resources/extensions/gsd/guided-flow.ts

@@ -26,6 +26,7 @@ import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync, unlinkSync } from "node:fs";
 import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
 import { nativeIsRepo, nativeInit } from "./native-git-bridge.js";
+import { isInheritedRepo } from "./repo-identity.js";
 import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { detectProjectState } from "./detection.js";
@@ -54,7 +55,7 @@ import { getErrorMessage } from "./error-utils.js";
 
 /**
  * Generate the next milestone ID, accounting for reserved IDs, and reserve it.
- * Ensures any preview ID shown in the UI matches what `gsd_generate_milestone_id`
+ * Ensures any preview ID shown in the UI matches what `gsd_milestone_generate_id`
  * will later return.
  */
 function nextMilestoneIdReserved(existingIds: string[], uniqueEnabled: boolean): string {
@@ -346,7 +347,7 @@ function buildHeadlessDiscussPrompt(nextId: string, seedContext: string, _basePa
  * Ensures git repo, .gsd/ structure, gitignore, and preferences all exist.
  */
 function bootstrapGsdProject(basePath: string): void {
-  if (!nativeIsRepo(basePath)) {
+  if (!nativeIsRepo(basePath) || isInheritedRepo(basePath)) {
     const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
     nativeInit(basePath, mainBranch);
   }
@@ -870,7 +871,10 @@ export async function showSmartEntry(
   }
 
   // ── Ensure git repo exists — GSD needs it for worktree isolation ──────
-  if (!nativeIsRepo(basePath)) {
+  // Also handle inherited repos: if basePath is a subdirectory of another
+  // git repo that has no .gsd, create a fresh repo to prevent cross-project
+  // state leaks (#1639).
+  if (!nativeIsRepo(basePath) || isInheritedRepo(basePath)) {
     const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
     nativeInit(basePath, mainBranch);
   }