@oisincoveney/pipeline 1.3.1 → 1.4.0

package/dist/index.js

@@ -27948,8 +27948,14 @@ var filesystemSchema = exports_external.object({
 var networkSchema = exports_external.object({
   mode: exports_external.enum(NETWORK_MODES)
 }).strict();
+var outputRepairSchema = exports_external.object({
+  enabled: exports_external.boolean().optional(),
+  max_attempts: exports_external.number().int().positive().optional(),
+  runner: exports_external.string().optional()
+}).strict();
 var outputSchema = exports_external.object({
   format: exports_external.enum(OUTPUT_FORMATS),
+  repair: outputRepairSchema.optional(),
   schema_path: exports_external.string().min(1).optional()
 }).strict();
 var artifactSchema = exports_external.object({
@@ -28184,6 +28190,16 @@ function validateProfile(profileId, profile, runner, config2, issues, projectRoo
       message: `profile '${profileId}' must declare output.schema_path for json_schema output`
     });
   }
+  const repairRunnerId = profile.output?.repair?.runner;
+  if (repairRunnerId && !config2.runners[repairRunnerId]) {
+    issues.push({
+      path: `profiles.${profileId}.output.repair.runner`,
+      message: `profile '${profileId}' references missing repair runner '${repairRunnerId}'`
+    });
+  }
+  if (repairRunnerId && config2.runners[repairRunnerId]) {
+    validateListCapability(`profiles.${profileId}.output.repair.runner`, ["text"], config2.runners[repairRunnerId].capabilities.output_formats, "repair output format", issues);
+  }
   validatePath(`profiles.${profileId}.output.schema_path`, profile.output?.schema_path, projectRoot, issues);
 }
 function validateActor(label, path, actor, runner, config2, issues, projectRoot) {
@@ -35815,7 +35831,7 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options2 = {})
         ...mcpArgs,
         ...skillArgs,
         "--sandbox",
-        "workspace-write",
+        codexSandboxFor(options2.actor),
         "--config",
         'approval_policy="never"',
         "--skip-git-repo-check",
@@ -35864,6 +35880,9 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options2 = {})
     }
   }
 }
+function codexSandboxFor(actor) {
+  return actor?.filesystem?.mode === "read-only" ? "read-only" : "workspace-write";
+}
 function createRunnerLaunchPlan(config2, input) {
   const profile = input.profileId ? config2.profiles[input.profileId] : undefined;
   if (input.profileId && !profile) {
@@ -36267,6 +36286,9 @@ profiles:
     output:
       format: json_schema
       schema_path: .pipeline/schemas/research.schema.json
+      repair:
+        enabled: true
+        max_attempts: 1
   pipeline-inspector:
     runner: codex
     description: Inspect the repository without modifying files.
@@ -36327,6 +36349,9 @@ profiles:
     output:
       format: json_schema
       schema_path: .pipeline/schemas/verify.schema.json
+      repair:
+        enabled: true
+        max_attempts: 1
   pipeline-learner:
     runner: codex
     description: Store durable lessons from the completed run.
@@ -36342,6 +36367,9 @@ profiles:
     output:
       format: json_schema
       schema_path: .pipeline/schemas/learn.schema.json
+      repair:
+        enabled: true
+        max_attempts: 1
 `;
 var RESEARCH_SCHEMA = JSON.stringify({
   additionalProperties: false,
@@ -37052,7 +37080,7 @@ async function executeNode(node, context) {
       emitNodeFinish(context, result2);
       return result2;
     }
-    const evidence = failedGate?.evidence ?? last.evidence.concat(`node exited with code ${last.exitCode}`);
+    const evidence = failedGate ? [...last.evidence, ...failedGate.evidence] : last.evidence.concat(`node exited with code ${last.exitCode}`);
     if (attempt === maxAttempts) {
       await dispatchHooks(context, "node.error", {
         evidence,
@@ -37117,17 +37145,167 @@ async function executeAgentNode(node, context) {
   context.agentInvocations.push(plan);
   const result = await context.executor(plan);
   const normalized = normalizeAgentOutput(plan, result.stdout);
+  const finalized = await finalizeAgentOutput({
+    context,
+    node,
+    normalized,
+    result
+  });
   return {
     evidence: [
       `agent boundary node=${node.id} profile=${node.profile} runner=${plan.runnerId} strategy=${plan.strategy}`,
-      ...normalized.evidence,
+      ...finalized.evidence,
       ...result.stderr ? [`stderr: ${result.stderr}`] : [],
       ...result.timedOut ? ["agent timed out"] : []
     ],
     exitCode: result.exitCode,
-    output: normalized.output
+    output: finalized.output
+  };
+}
+async function finalizeAgentOutput(inputs) {
+  const { context, node, normalized, result } = inputs;
+  const repairContext = outputRepairContext(context, node, normalized, result);
+  if (!repairContext) {
+    return normalized;
+  }
+  return await runOutputRepair(context, node, normalized, repairContext);
+}
+function outputRepairContext(context, node, normalized, result) {
+  if (result.exitCode !== 0 || result.timedOut) {
+    return null;
+  }
+  const profile = node.profile ? context.config.profiles[node.profile] : undefined;
+  if (!profile) {
+    return null;
+  }
+  const output = profile?.output;
+  if (output?.format !== "json_schema" || !output.schema_path) {
+    return null;
+  }
+  const firstValidation = validateJsonSchemaSource(normalized.output, output.schema_path, context.worktreePath);
+  if (firstValidation.passed) {
+    return null;
+  }
+  const repair = outputRepairOptions(output);
+  if (!repair.enabled) {
+    return null;
+  }
+  return {
+    evidence: [
+      ...normalized.evidence,
+      "output repair triggered",
+      ...firstValidation.evidence.map((item) => `original output: ${item}`)
+    ],
+    maxAttempts: repair.maxAttempts,
+    runner: repair.runner ?? profile.runner,
+    schemaPath: output.schema_path,
+    validation: firstValidation
+  };
+}
+async function runOutputRepair(context, node, normalized, repairContext) {
+  let latest = normalized;
+  let latestValidation = repairContext.validation;
+  const evidence = [...repairContext.evidence];
+  for (let attempt = 1;attempt <= repairContext.maxAttempts; attempt += 1) {
+    const repairPlan = createOutputRepairPlan({
+      context,
+      node,
+      originalOutput: latest.output,
+      repairRunner: repairContext.runner,
+      schemaPath: repairContext.schemaPath,
+      validation: latestValidation
+    });
+    context.agentInvocations.push(repairPlan);
+    const repairResult = await context.executor(repairPlan);
+    const repaired = normalizeAgentOutput(repairPlan, repairResult.stdout);
+    const repairedValidation = validateJsonSchemaSource(repaired.output, repairContext.schemaPath, context.worktreePath);
+    latest = {
+      evidence: [
+        ...repaired.evidence,
+        ...repairResult.stderr ? [`repair stderr: ${repairResult.stderr}`] : [],
+        ...repairResult.timedOut ? ["output repair timed out"] : []
+      ],
+      output: repaired.output
+    };
+    latestValidation = repairedValidation;
+    const passed = repairResult.exitCode === 0 && repairedValidation.passed;
+    evidence.push(...repaired.evidence, passed ? `output repair passed for ${node.id} after attempt ${attempt}` : `output repair failed for ${node.id} after attempt ${attempt}`, ...repairedValidation.evidence.map((item) => `repaired output: ${item}`));
+    emit(context, {
+      attempt,
+      nodeId: node.id,
+      passed,
+      type: "output.repair",
+      ...passed ? {} : { reason: repairedValidation.reason ?? "repair failed" }
+    });
+    if (passed) {
+      return {
+        evidence,
+        output: repaired.output
+      };
+    }
+  }
+  return {
+    evidence,
+    output: latest.output
   };
 }
+function outputRepairOptions(output) {
+  const repair = output.repair;
+  return {
+    enabled: repair?.enabled ?? true,
+    maxAttempts: repair?.max_attempts ?? 1,
+    ...repair?.runner ? { runner: repair.runner } : {}
+  };
+}
+function createOutputRepairPlan(inputs) {
+  const {
+    context,
+    node,
+    originalOutput,
+    repairRunner,
+    schemaPath,
+    validation
+  } = inputs;
+  const schema = readFileSync7(join6(context.worktreePath, schemaPath), "utf8");
+  const repairProfileId = `${node.id}:output-repair`;
+  const repairConfig = {
+    ...context.config,
+    profiles: {
+      ...context.config.profiles,
+      [repairProfileId]: {
+        filesystem: { mode: "read-only" },
+        instructions: { inline: "Repair invalid structured output." },
+        network: { mode: "disabled" },
+        output: { format: "text" },
+        runner: repairRunner,
+        tools: []
+      }
+    }
+  };
+  const prompt = [
+    "You are an output finalizer for a pipeline agent.",
+    "Return only valid JSON matching the expected schema.",
+    "Do not use Markdown fences or add prose outside the JSON value.",
+    "Preserve facts from the original output. If required information is missing, use empty arrays or nulls only where the schema permits.",
+    "",
+    "Expected schema:",
+    schema,
+    "",
+    "Validation error:",
+    validation.evidence.join(`
+`),
+    "",
+    "Original output:",
+    originalOutput
+  ].join(`
+`);
+  return createRunnerLaunchPlan(repairConfig, {
+    nodeId: repairProfileId,
+    profileId: repairProfileId,
+    prompt,
+    worktreePath: context.worktreePath
+  });
+}
 function normalizeAgentOutput(plan, stdout) {
   if (plan.type === "codex") {
     const text = lastJsonLineValue(stdout, (value) => {
@@ -37442,24 +37620,29 @@ function evaluateJsonSchemaGate(gate, gateId, nodeId, context, attempt) {
       reason: `missing JSON artifact '${gate.path ?? ""}'`
     };
   }
+  const result = validateJsonSchemaSource(source, schemaPath, context.worktreePath);
+  return {
+    evidence: result.evidence,
+    gateId,
+    kind: gate.kind,
+    nodeId,
+    passed: result.passed,
+    reason: result.reason
+  };
+}
+function validateJsonSchemaSource(source, schemaPath, worktreePath) {
   try {
-    const schema = JSON.parse(readFileSync7(join6(context.worktreePath, schemaPath), "utf8"));
+    const schema = JSON.parse(readFileSync7(join6(worktreePath, schemaPath), "utf8"));
     const value = JSON.parse(source);
     const errors4 = validateJsonSchema(value, schema);
     return {
       evidence: errors4.length === 0 ? [`JSON schema passed: ${schemaPath}`] : errors4.map((error51) => `schema: ${error51}`),
-      gateId,
-      kind: gate.kind,
-      nodeId,
       passed: errors4.length === 0,
       reason: errors4.length === 0 ? undefined : "JSON schema validation failed"
     };
   } catch (err) {
     return {
       evidence: [err instanceof Error ? err.message : String(err)],
-      gateId,
-      kind: gate.kind,
-      nodeId,
       passed: false,
       reason: "JSON schema validation failed"
     };
@@ -37653,6 +37836,9 @@ function formatRuntimeProgress(event) {
     case "gate.finish":
       console.error(`Gate ${event.passed ? "passed" : "failed"}: ${event.nodeId}/${event.gateId}${event.reason ? ` (${event.reason})` : ""}`);
       return;
+    case "output.repair":
+      console.error(`Output repair ${event.passed ? "passed" : "failed"}: ${event.nodeId} attempt=${event.attempt}${event.reason ? ` (${event.reason})` : ""}`);
+      return;
     case "node.finish":
       console.error(`Node finished: ${event.nodeId} ${event.status} exit=${event.exitCode}`);
       return;

package/dist/mastra/config.d.ts

@@ -76,6 +76,11 @@ declare const configSchema: z.ZodObject<{
                 jsonl: "jsonl";
                 json_schema: "json_schema";
             }>;
+            repair: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+                max_attempts: z.ZodOptional<z.ZodNumber>;
+                runner: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
             schema_path: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>;
         rules: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/mastra/runner.js

@@ -7283,7 +7283,7 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options = {}) {
         ...mcpArgs,
         ...skillArgs,
         "--sandbox",
-        "workspace-write",
+        codexSandboxFor(options.actor),
         "--config",
         'approval_policy="never"',
         "--skip-git-repo-check",
@@ -7332,6 +7332,9 @@ function harnessArgv(harness, prompt, worktreePath, contextFile, options = {}) {
     }
   }
 }
+function codexSandboxFor(actor) {
+  return actor?.filesystem?.mode === "read-only" ? "read-only" : "workspace-write";
+}
 async function execaHarness(harness, prompt, contextFile, worktreePath) {
   if (harness === "pi") {
     return execaHarnessPi(prompt, contextFile, worktreePath);

package/dist/pipeline-runtime.d.ts

@@ -54,6 +54,12 @@ export type PipelineRuntimeEvent = {
     passed: boolean;
     reason?: string;
     type: "gate.finish";
+} | {
+    attempt: number;
+    nodeId: string;
+    passed: boolean;
+    reason?: string;
+    type: "output.repair";
 } | {
     outcome: PipelineRuntimeResult["outcome"];
     type: "workflow.finish";

package/docs/config-architecture.md

@@ -109,6 +109,24 @@ receive explicit grants:
 - `network`: inherited or disabled.
 - `output`: text, JSON, JSONL, or JSON Schema output.
 
+JSON Schema outputs are hard contracts. The runtime validates normalized agent
+output before the node can pass. Schema outputs also get a bounded repair pass
+by default:
+
+```yaml
+output:
+  format: json_schema
+  schema_path: .pipeline/schemas/research.schema.json
+  repair:
+    enabled: true
+    max_attempts: 1
+```
+
+The repair pass receives only the schema, invalid output, and validation error.
+It uses a no-tools, read-only profile, then the runtime validates the repaired
+output again. If repair still fails, the node fails with both original and
+repair evidence.
+
 Hooks live in `pipeline.yaml` and can be attached to the orchestrator, workflow,
 or workflow nodes.
 

package/package.json

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