gsd-pi 2.41.0-dev.cac69f9 → 2.42.0-dev.1df898f

package/src/resources/extensions/gsd/tests/worktree-health-dispatch.test.ts

@@ -7,7 +7,7 @@
  * rather than hard-coding package.json / src/ only.
  */
 
-import test from "node:test";
+import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
@@ -67,112 +67,69 @@ test("PROJECT_FILES is exported and contains expected multi-ecosystem entries",
   assert.ok(PROJECT_FILES.includes("Package.swift"), "includes Swift marker");
 });
 
-test("health check passes for Rust project (Cargo.toml, no package.json)", () => {
-  const dir = createGitRepo();
-  try {
+describe("health check with git repo", () => {
+  let dir: string;
+  beforeEach(() => { dir = createGitRepo(); });
+  afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
+
+  test("health check passes for Rust project (Cargo.toml, no package.json)", () => {
     writeFileSync(join(dir, "Cargo.toml"), "[package]\nname = \"test\"\n");
     mkdirSync(join(dir, "crates"), { recursive: true });
     assert.ok(wouldPassHealthCheck(dir, existsSync), "Rust project should pass health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("health check passes for Go project (go.mod, no package.json)", () => {
-  const dir = createGitRepo();
-  try {
+  test("health check passes for Go project (go.mod, no package.json)", () => {
     writeFileSync(join(dir, "go.mod"), "module example.com/test\n\ngo 1.21\n");
     assert.ok(wouldPassHealthCheck(dir, existsSync), "Go project should pass health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("health check passes for Python project (pyproject.toml, no package.json)", () => {
-  const dir = createGitRepo();
-  try {
+  test("health check passes for Python project (pyproject.toml, no package.json)", () => {
     writeFileSync(join(dir, "pyproject.toml"), "[project]\nname = \"test\"\n");
     assert.ok(wouldPassHealthCheck(dir, existsSync), "Python project should pass health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("health check passes for Java project (pom.xml, no package.json)", () => {
-  const dir = createGitRepo();
-  try {
+  test("health check passes for Java project (pom.xml, no package.json)", () => {
     writeFileSync(join(dir, "pom.xml"), "<project></project>\n");
     assert.ok(wouldPassHealthCheck(dir, existsSync), "Java project should pass health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("health check passes for Swift project (Package.swift, no package.json)", () => {
-  const dir = createGitRepo();
-  try {
+  test("health check passes for Swift project (Package.swift, no package.json)", () => {
     writeFileSync(join(dir, "Package.swift"), "// swift-tools-version:5.7\n");
     assert.ok(wouldPassHealthCheck(dir, existsSync), "Swift project should pass health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("health check passes for C/C++ project (CMakeLists.txt, no package.json)", () => {
-  const dir = createGitRepo();
-  try {
+  test("health check passes for C/C++ project (CMakeLists.txt, no package.json)", () => {
     writeFileSync(join(dir, "CMakeLists.txt"), "cmake_minimum_required(VERSION 3.20)\n");
     assert.ok(wouldPassHealthCheck(dir, existsSync), "C/C++ project should pass health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("health check passes for Elixir project (mix.exs, no package.json)", () => {
-  const dir = createGitRepo();
-  try {
+  test("health check passes for Elixir project (mix.exs, no package.json)", () => {
     writeFileSync(join(dir, "mix.exs"), "defmodule Test.MixProject do\nend\n");
     assert.ok(wouldPassHealthCheck(dir, existsSync), "Elixir project should pass health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("health check passes for JS project (package.json, backward compat)", () => {
-  const dir = createGitRepo();
-  try {
+  test("health check passes for JS project (package.json, backward compat)", () => {
     writeFileSync(join(dir, "package.json"), '{"name":"test"}\n');
     assert.ok(wouldPassHealthCheck(dir, existsSync), "JS project should pass health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
+  });
 
-test("health check passes for src/-only project (backward compat)", () => {
-  const dir = createGitRepo();
-  try {
+  test("health check passes for src/-only project (backward compat)", () => {
     mkdirSync(join(dir, "src"), { recursive: true });
     assert.ok(wouldPassHealthCheck(dir, existsSync), "src/-only project should pass health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
+  });
+
+  test("health check fails for empty git repo with no project files", () => {
+    assert.ok(!wouldPassHealthCheck(dir, existsSync), "empty git repo should fail health check");
+  });
 });
 
-test("health check fails for directory with no .git", () => {
-  const dir = mkdtempSync(join(tmpdir(), "wt-dispatch-test-nogit-"));
-  try {
+describe("health check without git repo", () => {
+  let dir: string;
+  beforeEach(() => { dir = mkdtempSync(join(tmpdir(), "wt-dispatch-test-nogit-")); });
+  afterEach(() => { rmSync(dir, { recursive: true, force: true }); });
+
+  test("health check fails for directory with no .git", () => {
     writeFileSync(join(dir, "Cargo.toml"), "[package]\nname = \"test\"\n");
     assert.ok(!wouldPassHealthCheck(dir, existsSync), "no-git directory should fail health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("health check fails for empty git repo with no project files", () => {
-  const dir = createGitRepo();
-  try {
-    assert.ok(!wouldPassHealthCheck(dir, existsSync), "empty git repo should fail health check");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
+  });
 });

package/src/resources/extensions/gsd/tests/worktree-manager.test.ts

@@ -1,4 +1,4 @@
-import test from "node:test";
+import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
@@ -73,9 +73,12 @@ test("worktreeBranchName formats branch name", () => {
 
 // ─── createWorktree ───────────────────────────────────────────────────────────
 
-test("createWorktree creates worktree with correct metadata", () => {
-  const base = makeBaseRepo();
-  try {
+describe("createWorktree", () => {
+  let base: string;
+  beforeEach(() => { base = makeBaseRepo(); });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("creates worktree with correct metadata", () => {
     const info = createWorktree(base, "feature-x");
     assert.strictEqual(info.name, "feature-x", "name should match");
     assert.strictEqual(info.branch, "worktree/feature-x", "branch should be prefixed");
@@ -88,80 +91,82 @@ test("createWorktree creates worktree with correct metadata", () => {
     );
     const branches = run("git branch", base);
     assert.ok(branches.includes("worktree/feature-x"), "branch should be created in base repo");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
+  });
 
-test("createWorktree rejects duplicate name", () => {
-  const { base } = makeRepoWithWorktree("feature-x");
-  try {
+  test("rejects invalid name", () => {
     assert.throws(
-      () => createWorktree(base, "feature-x"),
+      () => createWorktree(base, "bad name!"),
       (err: Error) => {
         assert.ok(
-          err.message.includes("already exists"),
-          `expected "already exists" in error, got: ${err.message}`,
+          err.message.includes("Invalid worktree name"),
+          `expected "Invalid worktree name" in error, got: ${err.message}`,
         );
         return true;
       },
-      "should throw on duplicate worktree name",
+      "should throw on invalid worktree name",
     );
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
+  });
 });
 
-test("createWorktree rejects invalid name", () => {
-  const base = makeBaseRepo();
-  try {
+describe("createWorktree — duplicate rejection", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithWorktree("feature-x");
+    base = repo.base;
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("rejects duplicate name", () => {
     assert.throws(
-      () => createWorktree(base, "bad name!"),
+      () => createWorktree(base, "feature-x"),
       (err: Error) => {
         assert.ok(
-          err.message.includes("Invalid worktree name"),
-          `expected "Invalid worktree name" in error, got: ${err.message}`,
+          err.message.includes("already exists"),
+          `expected "already exists" in error, got: ${err.message}`,
         );
         return true;
       },
-      "should throw on invalid worktree name",
+      "should throw on duplicate worktree name",
     );
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
+  });
 });
 
 // ─── listWorktrees ────────────────────────────────────────────────────────────
 
-test("listWorktrees returns active worktrees", () => {
-  const { base } = makeRepoWithWorktree("feature-x");
-  try {
+describe("listWorktrees", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithWorktree("feature-x");
+    base = repo.base;
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("returns active worktrees", () => {
     const list = listWorktrees(base);
     assert.strictEqual(list.length, 1, "should list exactly one worktree");
     assert.strictEqual(list[0]!.name, "feature-x", "name should match");
     assert.strictEqual(list[0]!.branch, "worktree/feature-x", "branch should match");
     assert.ok(list[0]!.exists, "exists flag should be true");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
+  });
 
-test("listWorktrees returns empty after removal", () => {
-  const { base } = makeRepoWithWorktree("feature-x");
-  try {
+  test("returns empty after removal", () => {
     removeWorktree(base, "feature-x");
     const list = listWorktrees(base);
     assert.strictEqual(list.length, 0, "should have no worktrees after removal");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
+  });
 });
 
 // ─── diffWorktreeGSD ─────────────────────────────────────────────────────────
 
-test("diffWorktreeGSD detects added and modified GSD files", () => {
-  const { base } = makeRepoWithChanges("feature-x");
-  try {
+describe("diffWorktreeGSD and getWorktreeGSDDiff", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithChanges("feature-x");
+    base = repo.base;
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("detects added and modified GSD files", () => {
     const diff = diffWorktreeGSD(base, "feature-x");
     assert.ok(diff.added.length > 0, "should have added files");
     assert.ok(
@@ -174,58 +179,60 @@ test("diffWorktreeGSD detects added and modified GSD files", () => {
       "M001 roadmap should be in modified files",
     );
     assert.strictEqual(diff.removed.length, 0, "should have no removed files");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
-
-// ─── getWorktreeGSDDiff ───────────────────────────────────────────────────────
+  });
 
-test("getWorktreeGSDDiff returns patch content", () => {
-  const { base } = makeRepoWithChanges("feature-x");
-  try {
+  test("returns patch content", () => {
     const fullDiff = getWorktreeGSDDiff(base, "feature-x");
     assert.ok(fullDiff.includes("M002"), "diff should mention M002");
     assert.ok(fullDiff.includes("updated"), "diff should mention the update");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
+  });
 });
 
 // ─── getWorktreeLog ───────────────────────────────────────────────────────────
 
-test("getWorktreeLog shows commits", () => {
-  const { base } = makeRepoWithChanges("feature-x");
-  try {
+describe("getWorktreeLog", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithChanges("feature-x");
+    base = repo.base;
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("shows commits", () => {
     const log = getWorktreeLog(base, "feature-x");
     assert.ok(log.includes("add M002"), "log should include the commit message");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
+  });
 });
 
 // ─── removeWorktree ───────────────────────────────────────────────────────────
 
-test("removeWorktree removes directory and branch", () => {
-  const { base, wtPath } = makeRepoWithWorktree("feature-x");
-  try {
+describe("removeWorktree", () => {
+  let base: string;
+  let wtPath: string;
+  beforeEach(() => {
+    const repo = makeRepoWithWorktree("feature-x");
+    base = repo.base;
+    wtPath = repo.wtPath;
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("removes directory and branch", () => {
     removeWorktree(base, "feature-x", { deleteBranch: true });
     assert.ok(!existsSync(wtPath), "worktree directory should be gone");
     const branches = run("git branch", base);
     assert.ok(!branches.includes("worktree/feature-x"), "branch should be deleted");
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
+  });
 });
 
-test("removeWorktree on missing worktree does not throw", () => {
-  const base = makeBaseRepo();
-  try {
+describe("removeWorktree — missing worktree", () => {
+  let base: string;
+  beforeEach(() => { base = makeBaseRepo(); });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("on missing worktree does not throw", () => {
     assert.doesNotThrow(
       () => removeWorktree(base, "nonexistent"),
       "should not throw when worktree does not exist",
     );
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
+  });
 });

package/src/resources/extensions/gsd/tests/worktree-resolver.test.ts

@@ -139,11 +139,10 @@ function makeDeps(
     captureIntegrationBranch: (
       basePath: string,
       mid: string | undefined,
-      opts?: { commitDocs?: boolean },
     ) => {
       calls.push({
         fn: "captureIntegrationBranch",
-        args: [basePath, mid, opts],
+        args: [basePath, mid],
       });
     },
     ...overrides,

package/src/resources/extensions/gsd/workflow-engine.ts

@@ -0,0 +1,38 @@
+/**
+ * workflow-engine.ts — WorkflowEngine interface.
+ *
+ * Defines the contract every engine implementation must satisfy.
+ * Imports only from the leaf-node engine-types.
+ */
+
+import type {
+  EngineState,
+  EngineDispatchAction,
+  CompletedStep,
+  ReconcileResult,
+  DisplayMetadata,
+} from "./engine-types.js";
+
+/** A pluggable workflow engine that drives the auto-loop. */
+export interface WorkflowEngine {
+  /** Unique identifier for this engine (e.g. "dev", "custom"). */
+  readonly engineId: string;
+
+  /** Derive the current engine state from the project on disk. */
+  deriveState(basePath: string): Promise<EngineState>;
+
+  /** Decide what the loop should do next given current state. */
+  resolveDispatch(
+    state: EngineState,
+    context: { basePath: string },
+  ): Promise<EngineDispatchAction>;
+
+  /** Reconcile state after a step has been executed. */
+  reconcile(
+    state: EngineState,
+    completedStep: CompletedStep,
+  ): Promise<ReconcileResult>;
+
+  /** Return UI-facing metadata for progress display. */
+  getDisplayMetadata(state: EngineState): DisplayMetadata;
+}

package/src/resources/extensions/gsd/worktree-resolver.ts

@@ -63,7 +63,6 @@ export interface WorktreeResolverDeps {
   captureIntegrationBranch: (
     basePath: string,
     mid: string,
-    opts?: { commitDocs?: boolean },
   ) => void;
 }
 
@@ -410,10 +409,10 @@ export class WorktreeResolver {
       });
       // Surface a clear, actionable error. The worktree and milestone branch are
       // intentionally preserved — nothing has been deleted. The user can retry
-      // /complete-milestone or merge manually once the underlying issue is fixed
+      // /gsd dispatch complete-milestone or merge manually once the underlying issue is fixed
       // (e.g. checkout to wrong branch, unresolved conflicts). (#1668)
       ctx.notify(
-        `Milestone merge failed: ${msg}. Your worktree and milestone branch are preserved — retry /complete-milestone or merge manually.`,
+        `Milestone merge failed: ${msg}. Your worktree and milestone branch are preserved — retry /gsd dispatch complete-milestone or merge manually.`,
         "warning",
       );
 

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

@@ -57,13 +57,13 @@ export function setActiveMilestoneId(basePath: string, milestoneId: string | nul
  * record when the user starts from a different branch (#300). Always a no-op
  * if on a GSD slice branch.
  */
-export function captureIntegrationBranch(basePath: string, milestoneId: string, options?: { commitDocs?: boolean }): void {
+export function captureIntegrationBranch(basePath: string, milestoneId: string): void {
   // In a worktree, the base branch is implicit (worktree/<name>).
   // Writing it to META.json would leave stale metadata after merge back to main.
   if (detectWorktreeName(basePath)) return;
   const svc = getService(basePath);
   const current = svc.getCurrentBranch();
-  writeIntegrationBranch(basePath, milestoneId, current, options);
+  writeIntegrationBranch(basePath, milestoneId, current);
 }
 
 // ─── Pure Utility Functions (unchanged) ────────────────────────────────────

package/src/resources/extensions/mcp-client/index.ts

@@ -149,7 +149,11 @@ async function getOrConnect(name: string, signal?: AbortSignal): Promise<Client>
 			stderr: "pipe",
 		});
 	} else if (config.transport === "http" && config.url) {
-		transport = new StreamableHTTPClientTransport(new URL(config.url));
+		const resolvedUrl = config.url.replace(
+			/\$\{([^}]+)\}/g,
+			(_, name) => process.env[name] ?? "",
+		);
+		transport = new StreamableHTTPClientTransport(new URL(resolvedUrl));
 	} else {
 		throw new Error(`Server "${name}" has unsupported transport: ${config.transport}`);
 	}

package/src/resources/extensions/search-the-web/tool-search.ts

@@ -398,16 +398,16 @@ export function registerSearchTool(pi: ExtensionAPI) {
       // with brief interruptions every MAX_CONSECUTIVE_DUPES+1 calls.
       if (cacheKey === lastSearchKey) {
         consecutiveDupeCount++;
-        if (consecutiveDupeCount >= MAX_CONSECUTIVE_DUPES) {
+        if (consecutiveDupeCount > MAX_CONSECUTIVE_DUPES) {
           return {
-            content: [{ type: "text" as const, text: `⚠️ Search loop detected: the query "${params.query}" has been searched ${consecutiveDupeCount + 1} times consecutively with identical results. The information you need is already in the previous search results above. Stop searching and use those results to proceed with your task.` }],
+            content: [{ type: "text" as const, text: `⚠️ Search loop detected: the query "${params.query}" has been searched ${consecutiveDupeCount} times consecutively with identical results. The information you need is already in the previous search results above. Stop searching and use those results to proceed with your task.` }],
             isError: true,
             details: { errorKind: "search_loop", error: "Consecutive duplicate search detected" } satisfies Partial<SearchDetails>,
           };
         }
       } else {
         lastSearchKey = cacheKey;
-        consecutiveDupeCount = 0;
+        consecutiveDupeCount = 1;
       }
 
       const cached = searchCache.get(cacheKey);

package/src/resources/skills/create-workflow/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: create-workflow
+description: Conversational guide for creating valid YAML workflow definitions. Use when asked to "create a workflow", "new workflow definition", "build a workflow", "workflow YAML", "define workflow steps", or "workflow from template".
+---
+
+<essential_principles>
+You are a workflow definition author. You help users create valid V1 YAML workflow definitions that the GSD workflow engine can execute.
+
+**V1 Schema Basics:**
+
+- Every definition requires `version: 1`, a non-empty `name`, and at least one step in `steps[]`.
+- Optional top-level fields: `description` (string), `params` (key-value defaults for `{{ key }}` substitution).
+- Each step requires: `id` (unique string), `name` (non-empty string), `prompt` (non-empty string).
+- Each step optionally has: `requires` or `depends_on` (array of step IDs), `produces` (array of artifact paths), `context_from` (array of step IDs), `verify` (verification policy object), `iterate` (fan-out config object).
+- YAML uses **snake_case** keys: `depends_on`, `context_from`. The engine converts to camelCase internally.
+
+**Validation Rules:**
+
+- Step IDs must be unique across the workflow.
+- Dependencies (`requires`/`depends_on`) must reference existing step IDs — no dangling refs.
+- A step cannot depend on itself.
+- The dependency graph must be acyclic (no circular dependencies).
+- `produces` paths must not contain `..` (path traversal rejected).
+- `iterate.source` must not contain `..` (path traversal rejected).
+- `iterate.pattern` must be a valid regex with at least one capture group.
+
+**Four Verification Policies:**
+
+1. `content-heuristic` — Checks artifact content. Optional: `minSize` (number), `pattern` (string).
+2. `shell-command` — Runs a shell command. Required: `command` (non-empty string).
+3. `prompt-verify` — Asks an LLM to verify. Required: `prompt` (non-empty string).
+4. `human-review` — Pauses for human approval. No extra fields required.
+
+**Parameter Substitution:**
+
+- Define defaults in top-level `params: { key: "default_value" }`.
+- Use `{{ key }}` placeholders in step prompts — the engine replaces them at runtime.
+- CLI overrides take precedence over definition defaults.
+- Parameter values must not contain `..` (path traversal guard).
+- Any unresolved `{{ key }}` after substitution causes an error.
+
+**Path Traversal Guard:**
+
+- The engine rejects any `produces` path or `iterate.source` containing `..`.
+- Parameter values are also checked for `..` during substitution.
+
+**Output Location:**
+
+- Finished definitions go in `.gsd/workflow-defs/<name>.yaml`.
+- After writing, tell the user to validate with `/gsd workflow validate <name>`.
+</essential_principles>
+
+<routing>
+Determine the user's intent and route to the appropriate workflow:
+
+**"I want to create a workflow from scratch" / "new workflow" / "build a workflow":**
+→ Read `workflows/create-from-scratch.md` and follow it.
+
+**"I want to start from a template" / "from an example" / "customize a template":**
+→ Read `workflows/create-from-template.md` and follow it.
+
+**"Help me understand the schema" / "what fields are available?":**
+→ Read `references/yaml-schema-v1.md` and explain the relevant parts.
+
+**"How does verification work?" / "verify policies":**
+→ Read `references/verification-policies.md` and explain.
+
+**"How do I use context_from / iterate / params?":**
+→ Read `references/feature-patterns.md` and explain the relevant feature.
+
+**If intent is unclear, ask one clarifying question:**
+- "Do you want to create a workflow from scratch, or start from an existing template?"
+- Then route based on the answer.
+</routing>
+
+<reference_index>
+Read these files when you need detailed schema knowledge during workflow authoring:
+
+- `references/yaml-schema-v1.md` — Complete field-by-field V1 schema reference. Read when you need to explain any field's type, constraints, or defaults.
+- `references/verification-policies.md` — All four verify policies with complete YAML examples. Read when helping the user choose or configure verification for a step.
+- `references/feature-patterns.md` — Usage patterns for `context_from`, `iterate`, and `params` with complete YAML examples. Read when the user wants context chaining, fan-out iteration, or parameterized workflows.
+</reference_index>
+
+<templates_index>
+Available templates in `templates/`:
+
+- `workflow-definition.yaml` — Blank scaffold with all fields shown as comments. Copy and fill for a quick start.
+- `blog-post-pipeline.yaml` — Linear chain with params and content-heuristic verification.
+- `code-audit.yaml` — Iterate-based fan-out with shell-command verification.
+- `release-checklist.yaml` — Diamond dependency graph with human-review verification.
+</templates_index>
+
+<output_conventions>
+When assembling the final YAML:
+
+1. Use 2-space indentation consistently.
+2. Quote string values that contain special YAML characters (`:`, `{`, `}`, `[`, `]`, `#`).
+3. Always include `version: 1` as the first field.
+4. Order top-level fields: `version`, `name`, `description`, `params`, `steps`.
+5. Order step fields: `id`, `name`, `prompt`, `requires`, `produces`, `context_from`, `verify`, `iterate`.
+6. Write the file to `.gsd/workflow-defs/<name>.yaml`.
+7. After writing, tell the user: "Run `/gsd workflow validate <name>` to check the definition."
+</output_conventions>