@oisincoveney/pipeline 1.3.0 → 1.3.1

package/dist/index.js

@@ -35809,6 +35809,8 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options2 = {})
       return [
         "exec",
         "--json",
+        "-C",
+        worktreePath,
         ...optionalModelArgs(harness, options2.runner, options2.actor),
         ...mcpArgs,
         ...skillArgs,
@@ -35817,9 +35819,7 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options2 = {})
         "--config",
         'approval_policy="never"',
         "--skip-git-repo-check",
-        prompt,
-        "-C",
-        worktreePath
+        prompt
       ];
     case "opencode":
       return contextFile ? [
@@ -36404,8 +36404,11 @@ var SCAFFOLD_FILES = {
 `),
   ".pipeline/prompts/inspector.md": [
     "You are the read-only inspection phase for the pipeline.",
-    "Inspect first-party source, tests, docs, and task context.",
-    "Report the repository structure, available checks, important files, and notable risks.",
+    "Use a bounded inspection: run at most 8 discovery commands and read at most 12 small, high-signal files.",
+    "Prefer `pwd`, `rg --files -g '!*node_modules*' -g '!dist/**' -g '!build/**' | head -200`, package/workspace manifests, mise/turbo config, and test config files.",
+    "When reading paths with shell metacharacters such as brackets, quote the whole path.",
+    "Do not recursively inspect route trees or generated output.",
+    "Report the app structure, available checks, important files, and notable risks from the sampled evidence.",
     "Do not modify files.",
     ""
   ].join(`
@@ -36932,17 +36935,29 @@ async function runPipelineFromConfig(options2) {
     plan,
     task: options2.task,
     workflowId,
-    worktreePath
+    worktreePath,
+    ...options2.reporter ? { reporter: options2.reporter } : {}
   };
   const nodes = [];
+  emit(context, {
+    nodeIds: plan.topologicalOrder.map((node) => node.id),
+    type: "workflow.start",
+    workflowId
+  });
   const startHook = await dispatchHooks(context, "workflow.start");
   if (startHook) {
-    return failedRuntimeResult(context, nodes, startHook);
+    const result2 = failedRuntimeResult(context, nodes, startHook);
+    emit(context, {
+      outcome: result2.outcome,
+      type: "workflow.finish",
+      workflowId
+    });
+    return result2;
   }
   for (const batch of plan.parallelBatches) {
     const results = await Promise.all(batch.map((node) => executeNode(node, context)));
     nodes.push(...results);
-    const failed = results.find((result) => result.status === "failed");
+    const failed = results.find((result2) => result2.status === "failed");
     if (failed) {
       const failure = {
         evidence: failed.evidence,
@@ -36952,16 +36967,28 @@ async function runPipelineFromConfig(options2) {
       };
       await dispatchHooks(context, "workflow.failure", failure);
       await dispatchHooks(context, "workflow.complete", failure);
-      return failedRuntimeResult(context, nodes, failure);
+      const result2 = failedRuntimeResult(context, nodes, failure);
+      emit(context, {
+        outcome: result2.outcome,
+        type: "workflow.finish",
+        workflowId
+      });
+      return result2;
     }
   }
   const successHook = await dispatchHooks(context, "workflow.success");
   const completeHook = await dispatchHooks(context, "workflow.complete");
   const hookFailure = successHook ?? completeHook;
   if (hookFailure) {
-    return failedRuntimeResult(context, nodes, hookFailure);
+    const result2 = failedRuntimeResult(context, nodes, hookFailure);
+    emit(context, {
+      outcome: result2.outcome,
+      type: "workflow.finish",
+      workflowId
+    });
+    return result2;
   }
-  return {
+  const result = {
     agentInvocations: context.agentInvocations,
     failureDetails: [],
     gates: context.gates,
@@ -36970,6 +36997,12 @@ async function runPipelineFromConfig(options2) {
     outcome: "PASS",
     plan
   };
+  emit(context, {
+    outcome: result.outcome,
+    type: "workflow.finish",
+    workflowId
+  });
+  return result;
 }
 function failedRuntimeResult(context, nodes, failure) {
   return {
@@ -36990,9 +37023,12 @@ async function executeNode(node, context) {
     output: ""
   };
   for (let attempt = 1;attempt <= maxAttempts; attempt += 1) {
+    emitNodeStart(context, node, attempt);
     const startHook = await dispatchHooks(context, "node.start", undefined, node);
     if (startHook) {
-      return nodeFailure(node.id, attempt, startHook.evidence, last.output);
+      const result2 = nodeFailure(node.id, attempt, startHook.evidence, last.output);
+      emitNodeFinish(context, result2);
+      return result2;
     }
     last = await executeNodeAttempt(node, context);
     context.lastOutputByNode.set(node.id, last.output);
@@ -37001,9 +37037,11 @@ async function executeNode(node, context) {
     if (!failedGate && last.exitCode === 0) {
       const successHook = await dispatchHooks(context, "node.success", undefined, node);
       if (successHook) {
-        return nodeFailure(node.id, attempt, successHook.evidence, last.output);
+        const result3 = nodeFailure(node.id, attempt, successHook.evidence, last.output);
+        emitNodeFinish(context, result3);
+        return result3;
       }
-      return {
+      const result2 = {
         attempts: attempt,
         evidence: last.evidence,
         exitCode: 0,
@@ -37011,6 +37049,8 @@ async function executeNode(node, context) {
         output: last.output,
         status: "passed"
       };
+      emitNodeFinish(context, result2);
+      return result2;
     }
     const evidence = failedGate?.evidence ?? last.evidence.concat(`node exited with code ${last.exitCode}`);
     if (attempt === maxAttempts) {
@@ -37020,10 +37060,14 @@ async function executeNode(node, context) {
         nodeId: node.id,
         reason: failedGate?.reason ?? `node exited with code ${last.exitCode}`
       }, node);
-      return nodeFailure(node.id, attempt, evidence, last.output);
+      const result2 = nodeFailure(node.id, attempt, evidence, last.output);
+      emitNodeFinish(context, result2);
+      return result2;
     }
   }
-  return nodeFailure(node.id, maxAttempts, last.evidence, last.output);
+  const result = nodeFailure(node.id, maxAttempts, last.evidence, last.output);
+  emitNodeFinish(context, result);
+  return result;
 }
 function nodeFailure(nodeId, attempts, evidence, output) {
   return {
@@ -37301,6 +37345,13 @@ async function evaluateNodeGates(node, context, attempt) {
     const result = await evaluateGate(gate, node.id, context, attempt);
     context.gates.push(result);
     results.push(result);
+    emit(context, {
+      gateId: result.gateId,
+      nodeId: result.nodeId,
+      passed: result.passed,
+      type: "gate.finish",
+      ...result.reason ? { reason: result.reason } : {}
+    });
     if (!result.passed) {
       await dispatchHooks(context, "gate.failure", {
         evidence: result.evidence,
@@ -37315,6 +37366,28 @@ async function evaluateNodeGates(node, context, attempt) {
   }
   return results;
 }
+function emit(context, event) {
+  context.reporter?.(event);
+}
+function emitNodeStart(context, node, attempt) {
+  const profile = node.profile ? context.config.profiles[node.profile] : undefined;
+  emit(context, {
+    attempt,
+    nodeId: node.id,
+    type: "node.start",
+    ...node.profile ? { profile: node.profile } : {},
+    ...profile?.runner ? { runnerId: profile.runner } : {}
+  });
+}
+function emitNodeFinish(context, result) {
+  emit(context, {
+    attempt: result.attempts,
+    exitCode: result.exitCode,
+    nodeId: result.nodeId,
+    status: result.status,
+    type: "node.finish"
+  });
+}
 async function evaluateGate(gate, nodeId, context, attempt) {
   const gateId = gate.id ?? `${gate.kind}:${nodeId}`;
   if (gate.kind === "command") {
@@ -37554,6 +37627,7 @@ function pipe2(description, options2 = {}) {
 async function runConfiguredPipeline(inputs) {
   const runner = inputs.pipelineRunner ?? runPipelineFromConfig;
   const result = await runner({
+    reporter: formatRuntimeProgress,
     task: inputs.task,
     workflowId: inputs.workflow,
     worktreePath: inputs.worktreePath
@@ -37563,13 +37637,49 @@ async function runConfiguredPipeline(inputs) {
     throw new Error(formatRuntimeFailure(result));
   }
 }
+function formatRuntimeProgress(event) {
+  switch (event.type) {
+    case "workflow.start":
+      console.error(`Pipeline starting: ${event.workflowId} (${event.nodeIds.join(" -> ")})`);
+      return;
+    case "node.start":
+      console.error([
+        `Node starting: ${event.nodeId}`,
+        event.runnerId ? `runner=${event.runnerId}` : "",
+        event.profile ? `profile=${event.profile}` : "",
+        `attempt=${event.attempt}`
+      ].filter(Boolean).join(" "));
+      return;
+    case "gate.finish":
+      console.error(`Gate ${event.passed ? "passed" : "failed"}: ${event.nodeId}/${event.gateId}${event.reason ? ` (${event.reason})` : ""}`);
+      return;
+    case "node.finish":
+      console.error(`Node finished: ${event.nodeId} ${event.status} exit=${event.exitCode}`);
+      return;
+    case "workflow.finish":
+      console.error(`Pipeline finished: ${event.workflowId} ${event.outcome}`);
+      return;
+    default: {
+      const _exhaustive = event;
+      throw new Error(`Unhandled runtime event: ${String(_exhaustive)}`);
+    }
+  }
+}
 function formatRuntimeResult(result) {
-  return [
+  const lines = [
     `Pipeline complete: ${result.outcome}`,
     `Workflow: ${result.plan.workflowId}`,
     `Nodes: ${result.nodes.map((node) => `${node.nodeId}:${node.status}`).join(", ")}`,
     `Agent boundaries: ${result.agentInvocations.length}`
-  ].join(`
+  ];
+  const outputs = result.nodes.filter((node) => node.output.trim());
+  if (outputs.length > 0) {
+    lines.push("Node outputs:");
+    for (const node of outputs) {
+      appendIndentedSection(lines, node.nodeId, [node.output]);
+    }
+  }
+  return lines.join(`
 `);
 }
 function formatRuntimeFailure(result) {

package/dist/mastra/runner.js

@@ -7277,6 +7277,8 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options = {}) {
       return [
         "exec",
         "--json",
+        "-C",
+        worktreePath,
         ...optionalModelArgs(harness, options.runner, options.actor),
         ...mcpArgs,
         ...skillArgs,
@@ -7285,9 +7287,7 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options = {}) {
         "--config",
         'approval_policy="never"',
         "--skip-git-repo-check",
-        prompt,
-        "-C",
-        worktreePath
+        prompt
       ];
     case "opencode":
       return contextFile ? [

package/dist/pipeline-runtime.d.ts

@@ -32,9 +32,37 @@ export interface PipelineRuntimeResult {
     outcome: "FAIL" | "PASS";
     plan: WorkflowExecutionPlan;
 }
+export type PipelineRuntimeEvent = {
+    nodeIds: string[];
+    type: "workflow.start";
+    workflowId: string;
+} | {
+    attempt: number;
+    nodeId: string;
+    profile?: string;
+    runnerId?: string;
+    type: "node.start";
+} | {
+    attempt: number;
+    exitCode: number;
+    nodeId: string;
+    status: RuntimeNodeResult["status"];
+    type: "node.finish";
+} | {
+    gateId: string;
+    nodeId: string;
+    passed: boolean;
+    reason?: string;
+    type: "gate.finish";
+} | {
+    outcome: PipelineRuntimeResult["outcome"];
+    type: "workflow.finish";
+    workflowId: string;
+};
 export interface PipelineRuntimeOptions {
     config?: PipelineConfig;
     executor?: (plan: RunnerLaunchPlan) => AgentResult | Promise<AgentResult>;
+    reporter?: (event: PipelineRuntimeEvent) => void;
     task: string;
     workflowId?: string;
     worktreePath?: string;

package/package.json

@@ -69,7 +69,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "",
   "main": "index.js",
   "keywords": [],