gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.fd2382b9f

package/src/resources/extensions/gsd/commands-workflow-templates.ts

@@ -22,6 +22,7 @@ import { gsdRoot } from "./paths.js";
 import { createGitService, runGit } from "./git-service.js";
 import { isAutoActive, isAutoPaused } from "./auto.js";
 import { getErrorMessage } from "./error-utils.js";
+import { resolvePlugin, type WorkflowPlugin } from "./workflow-plugins.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -348,8 +349,18 @@ export async function handleStart(
   const basePath = process.cwd();
   const date = new Date().toISOString().split("T")[0];
 
-  // Load the workflow template content
-  const workflowContent = loadWorkflowTemplate(templateId);
+  // Load the workflow template content — prefer a project/global plugin
+  // override if one exists (same name, .md format).
+  let workflowContent: string | null = null;
+  const pluginOverride = resolvePlugin(basePath, templateId);
+  if (pluginOverride && pluginOverride.source !== "bundled" && pluginOverride.format === "md") {
+    try {
+      workflowContent = readFileSync(pluginOverride.path, "utf-8");
+    } catch { /* fall through to bundled */ }
+  }
+  if (workflowContent == null) {
+    workflowContent = loadWorkflowTemplate(templateId);
+  }
   if (!workflowContent) {
     ctx.ui.notify(
       `Template "${templateId}" is registered but its workflow file (${template.file}) hasn't been created yet.`,
@@ -541,3 +552,119 @@ export function getTemplateCompletions(prefix: string): Array<{ value: string; l
     return [];
   }
 }
+
+// ─── Shared markdown-phase dispatcher (used by /gsd workflow <name>) ────────
+
+/**
+ * Dispatch a markdown-phase workflow plugin. Mirrors `handleStart`'s execution
+ * branch for resolved templates, but accepts a pre-resolved plugin (from the
+ * unified plugin resolver).
+ *
+ * Writes STATE.json into an artifact dir, creates a git branch, and dispatches
+ * the `workflow-start` prompt.
+ */
+export function dispatchMarkdownPhasePlugin(
+  plugin: WorkflowPlugin,
+  description: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): void {
+  if (plugin.meta.mode !== "markdown-phase") return;
+
+  if (isAutoActive()) {
+    ctx.ui.notify(
+      "Cannot start a markdown-phase workflow while auto-mode is running.\n" +
+      "Run /gsd pause first.",
+      "warning",
+    );
+    return;
+  }
+
+  const templateId = plugin.name;
+  const basePath = process.cwd();
+  const date = new Date().toISOString().split("T")[0];
+  let workflowContent: string;
+  try {
+    workflowContent = readFileSync(plugin.path, "utf-8");
+  } catch (err) {
+    ctx.ui.notify(
+      `Failed to read template: ${err instanceof Error ? err.message : String(err)}`,
+      "error",
+    );
+    return;
+  }
+
+  // Create artifact directory.
+  let artifactDir = "";
+  if (plugin.meta.artifactDir) {
+    const slug = slugify(description || templateId);
+    const prefix = datePrefix();
+    const num = getNextWorkflowNum(join(basePath, plugin.meta.artifactDir));
+    artifactDir = `${plugin.meta.artifactDir}${prefix}-${num}-${slug}`;
+    mkdirSync(join(basePath, artifactDir), { recursive: true });
+  }
+
+  // Create git branch unless isolation: none.
+  const git = createGitService(basePath);
+  const skipBranch = git.prefs.isolation === "none";
+  const slug = slugify(description || templateId);
+  const branchName = `gsd/${templateId}/${slug}`;
+  let branchCreated = false;
+
+  if (!skipBranch) {
+    try {
+      const current = git.getCurrentBranch();
+      if (current !== branchName) {
+        try { git.autoCommit("workflow-template", templateId, []); } catch { /* nothing to commit */ }
+        runGit(basePath, ["checkout", "-b", branchName]);
+        branchCreated = true;
+      }
+    } catch (err) {
+      ctx.ui.notify(
+        `Could not create branch ${branchName}: ${getErrorMessage(err)}. Working on current branch.`,
+        "warning",
+      );
+    }
+  }
+
+  const actualBranch = branchCreated ? branchName : git.getCurrentBranch();
+
+  // Write STATE.json.
+  if (artifactDir && plugin.meta.phases && plugin.meta.phases.length > 0) {
+    writeWorkflowState(
+      join(basePath, artifactDir),
+      templateId,
+      plugin.meta.displayName,
+      plugin.meta.phases,
+      description,
+      actualBranch,
+    );
+  }
+
+  const infoLines = [
+    `Starting workflow: ${plugin.meta.displayName}`,
+    `Phases: ${(plugin.meta.phases ?? []).join(" → ")}`,
+  ];
+  if (artifactDir) infoLines.push(`Artifacts: ${artifactDir}`);
+  infoLines.push(`Branch: ${actualBranch}`);
+  ctx.ui.notify(infoLines.join("\n"), "info");
+
+  const prompt = loadPrompt("workflow-start", {
+    templateId,
+    templateName: plugin.meta.displayName,
+    templateDescription: plugin.meta.description ?? "",
+    phases: (plugin.meta.phases ?? []).join(" → "),
+    complexity: plugin.meta.complexity ?? "medium",
+    artifactDir: artifactDir || "(none)",
+    branch: actualBranch,
+    description: description || "(none provided)",
+    issueRef: "(none)",
+    date,
+    workflowContent,
+  });
+
+  pi.sendMessage(
+    { customType: "gsd-workflow-template", content: prompt, display: false },
+    { triggerTurn: true },
+  );
+}

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

@@ -26,6 +26,7 @@ import {
   readGraph,
   writeGraph,
   getNextPendingStep,
+  markStepActive,
   markStepComplete,
   expandIteration,
   type WorkflowGraph,
@@ -90,78 +91,102 @@ export class CustomWorkflowEngine implements WorkflowEngine {
     state: EngineState,
     _context: { basePath: string },
   ): Promise<EngineDispatchAction> {
-    let graph = state.raw as WorkflowGraph;
-    let next = getNextPendingStep(graph);
-
-    if (!next) {
-      return {
-        action: "stop",
-        reason: "All steps complete",
-        level: "info",
-      };
-    }
-
-    // Check frozen DEFINITION.yaml for iterate config on this step
-    const def = readFrozenDefinition(this.runDir);
-    const stepDef = def.steps.find((s: StepDefinition) => s.id === next!.id);
-
-    if (stepDef?.iterate) {
-      const iterate = stepDef.iterate;
-
-      // Read source artifact
-      const sourcePath = join(this.runDir, iterate.source);
-      let sourceContent: string;
-      try {
-        sourceContent = readFileSync(sourcePath, "utf-8");
-      } catch {
-        throw new Error(
-          `Iterate source artifact not found: ${sourcePath} (step "${next.id}", source: "${iterate.source}")`,
-        );
-      }
+    const graphPath = join(this.runDir, "GRAPH.yaml");
 
-      // Extract items via regex with global+multiline flags.
-      // Guard against ReDoS: if matching takes too long on large inputs, bail.
-      const regex = new RegExp(iterate.pattern, "gm");
-      const items: string[] = [];
-      const matchStart = Date.now();
-      let match: RegExpExecArray | null;
-      while ((match = regex.exec(sourceContent)) !== null) {
-        if (match[1] !== undefined) items.push(match[1]);
-        if (Date.now() - matchStart > 5_000) {
-          throw new Error(
-            `Iterate pattern "${iterate.pattern}" exceeded 5s timeout on step "${next.id}" — possible ReDoS`,
-          );
-        }
+    return await withFileLock(graphPath, () => {
+      let graph = readGraph(this.runDir);
+      const active = graph.steps.find((step) => step.status === "active");
+      if (active) {
+        return {
+          action: "dispatch" as const,
+          step: {
+            unitType: "custom-step",
+            unitId: `${graph.metadata.name}/${active.id}`,
+            prompt: injectContext(this.runDir, active.id, active.prompt),
+          },
+        };
       }
 
-      // Expand the graph
-      const expandedGraph = expandIteration(graph, next.id, items, next.prompt);
-      writeGraph(this.runDir, expandedGraph);
-      graph = expandedGraph;
-
-      // Re-query for first instance step
-      next = getNextPendingStep(expandedGraph);
+      let next = getNextPendingStep(graph);
 
       if (!next) {
         return {
           action: "stop",
-          reason: "Iterate expansion produced no instances",
+          reason: "All steps complete",
           level: "info",
         };
       }
-    }
 
-    // Enrich prompt with context from prior step artifacts
-    const enrichedPrompt = injectContext(this.runDir, next.id, next.prompt);
+      // Check frozen DEFINITION.yaml for iterate config on this step
+      const def = readFrozenDefinition(this.runDir);
+      const stepDef = def.steps.find((s: StepDefinition) => s.id === next!.id);
 
-    return {
-      action: "dispatch",
-      step: {
-        unitType: "custom-step",
-        unitId: `${graph.metadata.name}/${next.id}`,
-        prompt: enrichedPrompt,
-      },
-    };
+      if (stepDef?.iterate) {
+        const iterate = stepDef.iterate;
+
+        // Read source artifact
+        const sourcePath = join(this.runDir, iterate.source);
+        let sourceContent: string;
+        try {
+          sourceContent = readFileSync(sourcePath, "utf-8");
+        } catch {
+          throw new Error(
+            `Iterate source artifact not found: ${sourcePath} (step "${next.id}", source: "${iterate.source}")`,
+          );
+        }
+
+        // Extract items via regex with global+multiline flags.
+        // Guard against ReDoS: if matching takes too long on large inputs, bail.
+        const regex = new RegExp(iterate.pattern, "gm");
+        const items: string[] = [];
+        const matchStart = Date.now();
+        let match: RegExpExecArray | null;
+        while ((match = regex.exec(sourceContent)) !== null) {
+          if (match[1] !== undefined) items.push(match[1]);
+          if (Date.now() - matchStart > 5_000) {
+            throw new Error(
+              `Iterate pattern "${iterate.pattern}" exceeded 5s timeout on step "${next.id}" — possible ReDoS`,
+            );
+          }
+        }
+
+        // Expand the graph
+        const expandedGraph = expandIteration(graph, next.id, items, next.prompt);
+        writeGraph(this.runDir, expandedGraph);
+        graph = expandedGraph;
+
+        // Re-query for first instance step
+        next = getNextPendingStep(expandedGraph);
+
+        if (!next) {
+          return {
+            action: "stop",
+            reason: "Iterate expansion produced no instances",
+            level: "info",
+          };
+        }
+      }
+
+      const activeGraph = markStepActive(graph, next.id);
+      writeGraph(this.runDir, activeGraph);
+
+      const activeStep = activeGraph.steps.find((s) => s.id === next.id);
+      if (!activeStep) {
+        throw new Error(`Active step not found after GRAPH.yaml update: ${next.id}`);
+      }
+
+      // Enrich prompt with context from prior step artifacts
+      const enrichedPrompt = injectContext(this.runDir, activeStep.id, activeStep.prompt);
+
+      return {
+        action: "dispatch" as const,
+        step: {
+          unitType: "custom-step",
+          unitId: `${activeGraph.metadata.name}/${activeStep.id}`,
+          prompt: enrichedPrompt,
+        },
+      };
+    });
   }
 
   /**

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

@@ -373,6 +373,8 @@ export interface SaveDecisionFields {
   revisable?: string;
   when_context?: string;
   made_by?: import('./types.js').DecisionMadeBy;
+  /** ADR-011 Phase 2: origin of the decision — "discussion" (default), "planning", "escalation". */
+  source?: string;
 }
 
 /**
@@ -415,6 +417,7 @@ export async function saveDecisionToDb(
         rationale: fields.rationale,
         revisable: fields.revisable ?? 'Yes',
         made_by: fields.made_by ?? 'agent',
+        source: fields.source ?? 'discussion',
         superseded_by: null,
       });