@opengsd/gsd-pi 1.1.1-dev.b2556262 → 1.2.0-dev.0b870afa

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

@@ -106,37 +106,51 @@ function extractMilestoneId(parsed) {
  * the shared project `.gsd/` and auto-mode's verifyExpectedArtifact (which
  * uses the worktree `.gsd/`) fails, triggering a guaranteed retry per unit.
  */
+/**
+ * Containers a GSD worktree may live in: canonical .gsd-worktrees/ first,
+ * legacy .gsd/worktrees/ second. Boundary copy of `worktreesDirs` in
+ * src/resources/extensions/gsd/worktree-placement.ts — the MCP server cannot
+ * statically import the extension tree. Keep the two lists synchronized.
+ */
+function worktreeContainers(projectRoot) {
+    return [join(projectRoot, ".gsd-worktrees"), join(projectRoot, ".gsd", "worktrees")];
+}
 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;
+    for (const container of worktreeContainers(projectRoot)) {
+        const wtPath = join(container, milestoneId);
+        if (!existsSync(wtPath))
+            continue;
+        // 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")))
+            continue;
+        return wtPath;
+    }
+    return null;
 }
 /**
  * Fallback when the tool call has no milestoneId: if exactly one auto-worktree
- * exists under `<projectRoot>/.gsd/worktrees/`, treat it as the active one.
+ * exists across the project's worktree containers, treat it as the active one.
  * Multiple worktrees → ambiguous, return null and let writes go to project root.
  */
 function resolveSoleActiveWorktree(projectRoot) {
-    const worktreesDir = join(projectRoot, ".gsd", "worktrees");
-    if (!existsSync(worktreesDir))
-        return null;
-    let entries;
-    try {
-        entries = readdirSync(worktreesDir);
-    }
-    catch {
-        return null;
+    const live = [];
+    for (const worktreesDir of worktreeContainers(projectRoot)) {
+        if (!existsSync(worktreesDir))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(worktreesDir);
+        }
+        catch {
+            continue;
+        }
+        live.push(...entries
+            .map((name) => join(worktreesDir, name))
+            .filter((p) => existsSync(join(p, ".git"))));
     }
-    const live = entries
-        .map((name) => join(worktreesDir, name))
-        .filter((p) => existsSync(join(p, ".git")));
     if (live.length !== 1)
         return null;
     return live[0];
@@ -366,6 +380,17 @@ async function getWorkflowToolExecutors() {
     }
     return workflowToolExecutorsPromise;
 }
+/**
+ * Eagerly load and shape-check the workflow executor and write-gate bridges.
+ * The stdio CLI awaits this at startup so a broken bridge fails the spawn
+ * with an actionable error instead of presenting an available-looking tool
+ * surface that errors on the first call. Shares the cached promises the tool
+ * handlers use, so a successful warm-up also removes first-call import latency.
+ */
+export async function warmWorkflowToolBridges() {
+    await getWorkflowToolExecutors();
+    await getWorkflowWriteGateModule();
+}
 async function getWorkflowWriteGateModule() {
     if (!workflowWriteGatePromise) {
         workflowWriteGatePromise = (async () => {
@@ -733,6 +758,71 @@ const projectDirParam = z
     .optional()
     .describe("Optional. Omit this field — the server defaults to its current working directory, which is already the correct project or worktree root.");
 const unknownRecord = z.record(z.string(), z.unknown());
+/** Split "id — detail" / "id - detail" pairs used by legacy string payloads. */
+function splitPair(value) {
+    const match = value.match(/^(.+?)\s*(?:—|-)\s+(.+)$/);
+    return match ? [match[1].trim(), match[2].trim()] : [value.trim(), ""];
+}
+/** Accept string or string[] at runtime; emit array-only JSON Schema (no anyOf). */
+const optionalStringOrStringArray = () => z.preprocess((value) => (value == null ? value : Array.isArray(value) ? value : [value]), z.array(z.string()).optional());
+function optionalStructuredStringArray(itemSchema, coerceString) {
+    return z.preprocess((value) => {
+        if (value == null)
+            return value;
+        if (!Array.isArray(value))
+            return value;
+        return value.map((item) => (typeof item === "string" ? coerceString(item) : item));
+    }, z.array(itemSchema).optional());
+}
+const requirementAdvancedItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const [id, how] = splitPair(value);
+    return { id, how };
+}, z.object({ id: z.string(), how: z.string() }));
+const requirementValidatedItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const [id, proof] = splitPair(value);
+    return { id, proof };
+}, z.object({ id: z.string(), proof: z.string() }));
+const requirementInvalidatedItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const [id, what] = splitPair(value);
+    return { id, what };
+}, z.object({ id: z.string(), what: z.string() }));
+const filesModifiedItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const [path, description] = splitPair(value);
+    return { path, description };
+}, z.object({ path: z.string(), description: z.string() }));
+const requiresItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const [slice, provides] = splitPair(value);
+    return { slice, provides };
+}, z.object({ slice: z.string(), provides: z.string() }));
+// Accept either a string (legacy command-only form) or the structured object.
+// Mirrors `normalizeVerificationEvidence` in the executor: strings are coerced
+// into the canonical object shape before Zod validates, so the emitted JSON
+// Schema stays a single object type (no anyOf/oneOf) for Moonshot/Kimi.
+const verificationEvidenceItemSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    return {
+        command: value,
+        exitCode: -1,
+        verdict: "unknown (coerced from string)",
+        durationMs: 0,
+    };
+}, z.object({
+    command: z.string(),
+    exitCode: z.number(),
+    verdict: z.string(),
+    durationMs: z.number(),
+}));
 const nonEmptyString = (field) => z.string().trim().min(1, `${field} must be a non-empty string`);
 // Optional non-empty string: accepts omitted/undefined but rejects "" or
 // whitespace. Mirrors executor guards of the form
@@ -973,41 +1063,42 @@ const sliceCompleteParams = {
     sliceTitle: z.string().describe("Title of the slice"),
     oneLiner: z.string().describe("One-line summary of what the slice accomplished"),
     narrative: z.string().describe("Detailed narrative of what happened across all tasks"),
-    verification: z.string().describe("What was verified across all tasks"),
+    verification: z.string().optional().describe("What was verified across all tasks — if omitted, summary records verification as passed without detail."),
     uatContent: z.string().describe("UAT test content (markdown body)"),
     deviations: z.string().optional(),
     knownLimitations: z.string().optional(),
     followUps: z.string().optional(),
-    keyFiles: z.union([z.array(z.string()), z.string()]).optional(),
-    keyDecisions: z.union([z.array(z.string()), z.string()]).optional(),
-    patternsEstablished: z.union([z.array(z.string()), z.string()]).optional(),
-    observabilitySurfaces: z.union([z.array(z.string()), z.string()]).optional(),
-    provides: z.union([z.array(z.string()), z.string()]).optional(),
-    requirementsSurfaced: z.union([z.array(z.string()), z.string()]).optional(),
-    drillDownPaths: z.union([z.array(z.string()), z.string()]).optional(),
-    affects: z.union([z.array(z.string()), z.string()]).optional(),
-    requirementsAdvanced: z.array(z.union([
-        z.object({ id: z.string(), how: z.string() }),
-        z.string(),
-    ])).optional(),
-    requirementsValidated: z.array(z.union([
-        z.object({ id: z.string(), proof: z.string() }),
-        z.string(),
-    ])).optional(),
-    requirementsInvalidated: z.array(z.union([
-        z.object({ id: z.string(), what: z.string() }),
-        z.string(),
-    ])).optional(),
-    filesModified: z.array(z.union([
-        z.object({ path: z.string(), description: z.string() }),
-        z.string(),
-    ])).optional(),
-    requires: z.array(z.union([
-        z.object({ slice: z.string(), provides: z.string() }),
-        z.string(),
-    ])).optional(),
+    keyFiles: optionalStringOrStringArray(),
+    keyDecisions: optionalStringOrStringArray(),
+    patternsEstablished: optionalStringOrStringArray(),
+    observabilitySurfaces: optionalStringOrStringArray(),
+    provides: optionalStringOrStringArray(),
+    requirementsSurfaced: optionalStringOrStringArray(),
+    drillDownPaths: optionalStringOrStringArray(),
+    affects: optionalStringOrStringArray(),
+    requirementsAdvanced: optionalStructuredStringArray(requirementAdvancedItemSchema, (value) => {
+        const [id, how] = splitPair(value);
+        return { id, how };
+    }),
+    requirementsValidated: optionalStructuredStringArray(requirementValidatedItemSchema, (value) => {
+        const [id, proof] = splitPair(value);
+        return { id, proof };
+    }),
+    requirementsInvalidated: optionalStructuredStringArray(requirementInvalidatedItemSchema, (value) => {
+        const [id, what] = splitPair(value);
+        return { id, what };
+    }),
+    filesModified: optionalStructuredStringArray(filesModifiedItemSchema, (value) => {
+        const [path, description] = splitPair(value);
+        return { path, description };
+    }),
+    requires: optionalStructuredStringArray(requiresItemSchema, (value) => {
+        const [slice, provides] = splitPair(value);
+        return { slice, provides };
+    }),
 };
 const sliceCompleteSchema = z.object(sliceCompleteParams);
+export const _sliceCompleteSchemaForTest = sliceCompleteSchema;
 const summarySaveParams = {
     projectDir: projectDirParam,
     milestone_id: z.string().optional().describe("Milestone ID (e.g. M001). Omit only for root-level PROJECT/PROJECT-DRAFT/REQUIREMENTS/REQUIREMENTS-DRAFT artifacts."),
@@ -1118,15 +1209,7 @@ const taskCompleteParams = {
         recommendationRationale: z.string().describe("Why the recommendation — 1-2 sentences."),
         continueWithDefault: z.boolean().describe("When true, the recommendation is recorded as the default, but auto-mode still pauses until the user resolves via /gsd escalate resolve."),
     }).optional().describe("ADR-011 Phase 2: optional escalation payload. Only honored when phases.mid_execution_escalation is true."),
-    verificationEvidence: z.array(z.union([
-        z.object({
-            command: z.string(),
-            exitCode: z.number(),
-            verdict: z.string(),
-            durationMs: z.number(),
-        }),
-        z.string(),
-    ])).optional().describe("Verification evidence entries"),
+    verificationEvidence: z.array(verificationEvidenceItemSchema).optional().describe("Verification evidence entries"),
 };
 const taskCompleteSchema = z.object(taskCompleteParams);
 const taskReopenParams = {
@@ -1251,7 +1334,11 @@ const uatResultSaveParams = {
     checks: z.array(uatCheckSchema).min(1).describe("Structured check results"),
     presentation: uatPresentationSchema.describe("Tool-presentation evidence"),
     notes: z.string().optional().describe("Overall verdict rationale"),
-    attempt: z.union([z.number().int().min(1), z.literal("auto")]).optional().describe("Attempt number or auto"),
+    // Accept number (e.g. 1) or string (e.g. "1", "auto") and coerce to string
+    // before validation, so the emitted JSON Schema stays a single primitive type
+    // (no anyOf/oneOf) for Moonshot/Kimi. The executor still treats "auto" and
+    // numeric strings as previously.
+    attempt: z.preprocess((value) => (typeof value === "number" ? String(value) : value), z.string().optional()).describe("Attempt number or auto"),
     previousAttemptId: z.string().optional(),
 };
 const uatResultSaveSchema = z.object(uatResultSaveParams);