gsd-pi 2.74.0-dev.6e23363 → 2.74.0-dev.b2838e6

package/packages/mcp-server/dist/workflow-tools.js

@@ -1,7 +1,8 @@
 /**
  * Workflow MCP tools — exposes the core GSD mutation/read handlers over MCP.
  */
-import { isAbsolute, relative, resolve } from "node:path";
+import { existsSync, realpathSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { z } from "zod";
 let workflowToolExecutorsPromise = null;
@@ -15,25 +16,99 @@ function isWithinRoot(candidatePath, rootPath) {
     const rel = relative(rootPath, candidatePath);
     return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
 }
+/**
+ * Resolve the symlink target of `<allowedRoot>/.gsd` when it points into the
+ * external state layout (`~/.gsd/projects/<hash>/`). Returns the realpath of
+ * that target so callers can accept worktree paths that live under
+ * `<external-state>/worktrees/<MID>/`. Returns null when `.gsd` is absent or
+ * resolution fails — the caller should fall back to the direct containment
+ * check in that case.
+ */
+function resolveExternalStateRoot(allowedRoot) {
+    try {
+        return realpathSync(join(allowedRoot, ".gsd"));
+    }
+    catch {
+        return null;
+    }
+}
 function validateProjectDir(projectDir, env = process.env) {
     if (!isAbsolute(projectDir)) {
         throw new Error(`projectDir must be an absolute path. Received: ${projectDir}`);
     }
     const resolvedProjectDir = resolve(projectDir);
     const allowedRoot = getAllowedProjectRoot(env);
-    if (allowedRoot && !isWithinRoot(resolvedProjectDir, allowedRoot)) {
-        throw new Error(`projectDir must stay within the configured workflow project root. Received: ${resolvedProjectDir}; allowed root: ${allowedRoot}`);
+    if (!allowedRoot)
+        return resolvedProjectDir;
+    if (isWithinRoot(resolvedProjectDir, allowedRoot))
+        return resolvedProjectDir;
+    // External state layout: `<allowedRoot>/.gsd` may be a symlink into
+    // `~/.gsd/projects/<hash>/`, and auto-worktrees live under
+    // `~/.gsd/projects/<hash>/worktrees/<MID>/`. Accept candidates that are
+    // under the realpath of `<allowedRoot>/.gsd` — they belong to this project
+    // even though their absolute path is outside allowedRoot (#issue-a44).
+    const externalRoot = resolveExternalStateRoot(allowedRoot);
+    if (externalRoot && isWithinRoot(resolvedProjectDir, externalRoot)) {
+        return resolvedProjectDir;
     }
-    return resolvedProjectDir;
+    throw new Error(`projectDir must stay within the configured workflow project root. Received: ${resolvedProjectDir}; allowed root: ${allowedRoot}`);
 }
 function parseToolArgs(schema, args) {
     return schema.parse(args);
 }
+/**
+ * Extract a milestone ID from parsed tool args, trying common field names.
+ * Returns null when no field is present or the value is not a string.
+ */
+function extractMilestoneId(parsed) {
+    const candidates = [parsed.milestoneId, parsed.milestone_id, parsed.mid];
+    for (const c of candidates) {
+        if (typeof c === "string" && c.trim() !== "")
+            return c.trim();
+    }
+    return null;
+}
+/**
+ * If an auto-worktree exists for the given milestone under
+ * `<projectRoot>/.gsd/worktrees/<milestoneId>/`, return that path as the
+ * basePath the tool should write against. Returns null when no worktree
+ * exists for this milestone, leaving the caller to use the project root.
+ *
+ * This unbreaks the external-state layout where the MCP server's process.cwd()
+ * is the project root (set at Claude Code launch) but auto-mode is actually
+ * working inside a per-milestone worktree. Without this, tool writes go to
+ * the shared project `.gsd/` and auto-mode's verifyExpectedArtifact (which
+ * uses the worktree `.gsd/`) fails, triggering a guaranteed retry per unit.
+ */
+function resolveActiveWorktreeBasePath(projectRoot, milestoneId) {
+    if (!milestoneId)
+        return null;
+    const wtPath = join(projectRoot, ".gsd", "worktrees", milestoneId);
+    if (!existsSync(wtPath))
+        return null;
+    // Sanity check: a real git worktree has a `.git` file with a gitdir pointer.
+    // Bare directories without it shouldn't hijack the write path.
+    if (!existsSync(join(wtPath, ".git")))
+        return null;
+    return wtPath;
+}
 function parseWorkflowArgs(schema, args) {
     const parsed = parseToolArgs(schema, args);
+    // Step 1: figure out the project root. The agent shouldn't need to pass
+    // projectDir — default to process.cwd() which the MCP server inherited from
+    // Claude Code (launched at the project root).
+    const projectRootCandidate = parsed.projectDir ?? process.cwd();
+    const projectRoot = validateProjectDir(projectRootCandidate);
+    // Step 2: if this tool call is scoped to a milestone that has an active
+    // auto-worktree, re-route writes to the worktree's .gsd rather than the
+    // project's shared .gsd. auto-mode's verifyExpectedArtifact runs against
+    // the worktree, and a mismatch here causes every unit to retry once.
+    const milestoneId = extractMilestoneId(parsed);
+    const worktreeBasePath = resolveActiveWorktreeBasePath(projectRoot, milestoneId);
+    const effectiveBasePath = worktreeBasePath ?? projectRoot;
     return {
         ...parsed,
-        projectDir: validateProjectDir(parsed.projectDir),
+        projectDir: effectiveBasePath,
     };
 }
 function isWorkflowToolExecutors(value) {
@@ -303,7 +378,14 @@ async function ensureMilestoneDbRow(milestoneId) {
         // Ignore pre-existing rows or transient DB availability issues.
     }
 }
-const projectDirParam = z.string().describe("Absolute path to the project directory within the configured workflow root");
+// projectDir is optional. When omitted, the server uses process.cwd(). This
+// prevents the agent from burning tokens reasoning about which absolute path
+// to pass (git root vs worktree vs symlink-resolved external state layout) —
+// the server already knows where it is running.
+const projectDirParam = z
+    .string()
+    .optional()
+    .describe("Optional. Omit this field — the server defaults to its current working directory, which is already the correct project or worktree root.");
 const planMilestoneParams = {
     projectDir: projectDirParam,
     milestoneId: z.string().describe("Milestone ID (e.g. M001)"),