@oisincoveney/pipeline 1.2.2 → 1.3.1

package/README.md

@@ -45,6 +45,12 @@ Run the default workflow:
 pipe run "Implement PIPE-123 user-facing behavior"
 ```
 
+Run a read-only repository inspection:
+
+```shell
+pipe run --workflow inspect "Report the app structure and available checks. Do not modify files."
+```
+
 The `pipe` binary also accepts the task directly:
 
 ```shell

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 ? [
@@ -36123,6 +36123,12 @@ orchestrator:
 hooks: {}
 
 workflows:
+  inspect:
+    description: Read-only repository inspection workflow.
+    nodes:
+      - id: inspect
+        kind: agent
+        profile: pipeline-inspector
   default:
     description: Default research, red, green, verify, learn workflow.
     nodes:
@@ -36261,6 +36267,20 @@ profiles:
     output:
       format: json_schema
       schema_path: .pipeline/schemas/research.schema.json
+  pipeline-inspector:
+    runner: codex
+    description: Inspect the repository without modifying files.
+    instructions:
+      path: .pipeline/prompts/inspector.md
+    tools: [read, list, grep, glob, bash]
+    filesystem:
+      mode: read-only
+      allow: ["**/*"]
+      deny: ["node_modules/**", "dist/**", ".git/**"]
+    network:
+      mode: inherit
+    output:
+      format: text
   pipeline-test-writer:
     runner: codex
     description: Add focused failing tests for the requested behavior.
@@ -36377,6 +36397,19 @@ var SCAFFOLD_FILES = {
     "You are the research phase for the pipeline.",
     "Inspect first-party source, tests, docs, and task context before proposing changes.",
     "Write structured findings that identify relevant files, existing patterns, acceptance criteria, and risks.",
+    "Return only valid JSON matching `.pipeline/schemas/research.schema.json`: an object with `findings` and `ac` arrays, plus optional `files`, `risks`, and `target`.",
+    "Do not wrap the JSON in Markdown fences or add prose outside the JSON object.",
+    ""
+  ].join(`
+`),
+  ".pipeline/prompts/inspector.md": [
+    "You are the read-only inspection phase for the pipeline.",
+    "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(`
 `),
@@ -36400,6 +36433,8 @@ var SCAFFOLD_FILES = {
     "You are the VERIFY phase for the pipeline.",
     "Run configured checks, review implementation fit, and report PASS or FAIL with evidence.",
     "Do not mark the workflow passing without concrete verification evidence.",
+    "Return only valid JSON matching `.pipeline/schemas/verify.schema.json`: an object with `verdict`, `evidence`, and optional `violations`.",
+    "Do not wrap the JSON in Markdown fences or add prose outside the JSON object.",
     ""
   ].join(`
 `),
@@ -36407,6 +36442,8 @@ var SCAFFOLD_FILES = {
     "You are the LEARN phase for the pipeline.",
     "Store durable lessons from the run when useful and report qdrant-store evidence.",
     "Do not write local markdown knowledge as the durable sink.",
+    "Return only valid JSON matching `.pipeline/schemas/learn.schema.json`: an object with `qdrant` and `evidence`.",
+    "Do not wrap the JSON in Markdown fences or add prose outside the JSON object.",
     ""
   ].join(`
 `),
@@ -36898,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,
@@ -36918,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,
@@ -36936,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 {
@@ -36956,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);
@@ -36967,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,
@@ -36977,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) {
@@ -36986,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 {
@@ -37267,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,
@@ -37281,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") {
@@ -37520,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
@@ -37529,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/docs/config-architecture.md

@@ -80,6 +80,11 @@ orchestrator:
 hooks: {}
 
 workflows:
+  inspect:
+    nodes:
+      - id: inspect
+        kind: agent
+        profile: pipeline-inspector
   default:
     nodes:
       - id: research

package/package.json

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