@oisincoveney/pipeline 1.27.11 → 1.27.13

package/dist/argo-submit.js

@@ -64,6 +64,11 @@ async function submitRunnerArgoWorkflow(rawOptions, dependencies = {}) {
 		"pipeline.oisin.dev/workflow": compiled.workflowId
 	};
 	const workflow = buildRunnerArgoWorkflowManifest({
+		annotations: payload.task.kind === "ticket" ? {
+			"pipeline.oisin.dev/ticket-id": payload.task.id,
+			"pipeline.oisin.dev/ticket-project": payload.run.project,
+			"pipeline.oisin.dev/ticket-title": payload.task.title
+		} : {},
 		eventAuthSecretKey: options.eventAuthSecretKey,
 		eventAuthSecretName: options.eventAuthSecretName,
 		generateName: options.generateName,

package/dist/argo-workflow.d.ts

@@ -6,6 +6,7 @@ declare const runnerArgoWorkflowManifestSchema: z.ZodObject<{
   apiVersion: z.ZodLiteral<"argoproj.io/v1alpha1">;
   kind: z.ZodLiteral<"Workflow">;
   metadata: z.ZodObject<{
+    annotations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     generateName: z.ZodOptional<z.ZodString>;
     labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     name: z.ZodOptional<z.ZodString>;
@@ -112,6 +113,7 @@ declare const buildRunnerArgoWorkflowOptionsSchema: z.ZodObject<{
   eventAuthSecretName: z.ZodOptional<z.ZodString>;
   generateName: z.ZodOptional<z.ZodString>;
   githubAuthSecretName: z.ZodOptional<z.ZodString>;
+  annotations: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>>;
   image: z.ZodDefault<z.ZodString>;
   imagePullPolicy: z.ZodDefault<z.ZodEnum<{
     Always: "Always";

package/dist/argo-workflow.js

@@ -83,6 +83,7 @@ const runnerArgoWorkflowManifestSchema = z.object({
 	apiVersion: z.literal(ARGO_WORKFLOW_API_VERSION),
 	kind: z.literal(ARGO_WORKFLOW_KIND),
 	metadata: z.object({
+		annotations: z.record(z.string().min(1), z.string().min(1)).optional(),
 		generateName: z.string().min(1).optional(),
 		labels: z.record(z.string().min(1), labelValueSchema).optional(),
 		name: z.string().min(1).optional(),
@@ -110,6 +111,7 @@ const buildRunnerArgoWorkflowOptionsSchema = z.object({
 	eventAuthSecretName: kubernetesNameSchema.optional(),
 	generateName: z.string().min(1).optional(),
 	githubAuthSecretName: kubernetesNameSchema.optional(),
+	annotations: z.record(z.string().min(1), z.string().min(1).optional()).default({}),
 	image: z.string().min(1).default(RUNNER_WORKFLOW_IMAGE),
 	imagePullPolicy: z.enum([
 		"Always",
@@ -151,6 +153,7 @@ function buildRunnerArgoWorkflowManifest(rawOptions) {
 		apiVersion: ARGO_WORKFLOW_API_VERSION,
 		kind: ARGO_WORKFLOW_KIND,
 		metadata: {
+			annotations: compactRecord(options.annotations),
 			...options.name ? { name: options.name } : {},
 			...options.generateName ? { generateName: options.generateName } : {},
 			labels: compactRecord({

package/dist/config.d.ts

@@ -452,6 +452,7 @@ declare const configSchema: z.ZodObject<{
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
     tools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+      task: "task";
       read: "read";
       list: "list";
       grep: "grep";
@@ -459,7 +460,6 @@ declare const configSchema: z.ZodObject<{
       bash: "bash";
       edit: "edit";
       write: "write";
-      task: "task";
     }>>>;
   }, z.core.$strict>>>;
   runner_command: z.ZodDefault<z.ZodObject<{
@@ -511,6 +511,7 @@ declare const configSchema: z.ZodObject<{
       rules: z.ZodOptional<z.ZodBoolean>;
       skills: z.ZodOptional<z.ZodBoolean>;
       tools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        task: "task";
         read: "read";
         list: "list";
         grep: "grep";
@@ -518,7 +519,6 @@ declare const configSchema: z.ZodObject<{
         bash: "bash";
         edit: "edit";
         write: "write";
-        task: "task";
       }>>>;
     }, z.core.$strict>;
     command: z.ZodOptional<z.ZodString>;

package/dist/hooks.d.ts

@@ -13,8 +13,8 @@ declare const hookResultSchema: z.ZodObject<{
     taskContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   }, z.core.$strict>>;
   status: z.ZodEnum<{
-    pass: "pass";
     fail: "fail";
+    pass: "pass";
     skip: "skip";
   }>;
   summary: z.ZodOptional<z.ZodString>;

package/dist/pipeline-runtime.js

@@ -302,27 +302,22 @@ async function executeNode(node, context) {
 			return cycle.result;
 		}
 		retry = retryCandidateForCycle(node, cycle, last, attempt);
-		const selfRemediation = await remediateWritableNodeFailure({
+		const remediation = await remediateFailedNode({
 			attempt,
 			context,
 			node,
 			retry
 		});
-		if (selfRemediation) {
+		if (remediation?.result) {
 			recordNodeEvent(context, node.id, {
 				at: now(),
-				result: selfRemediation,
+				result: remediation.result,
 				type: "PASSED"
 			});
-			emitNodeFinish(context, selfRemediation);
-			return selfRemediation;
+			emitNodeFinish(context, remediation.result);
+			return remediation.result;
 		}
-		if (await remediateCoverageFailure({
-			attempt,
-			context,
-			node,
-			retry
-		})) continue;
+		if (remediation?.retryNode) continue;
 		recordNodeEvent(context, node.id, {
 			at: now(),
 			attempt,
@@ -379,6 +374,13 @@ async function executeNode(node, context) {
 	emitNodeFinish(context, result);
 	return result;
 }
+async function remediateFailedNode(input) {
+	const selfRemediation = await remediateWritableNodeFailure(input);
+	if (selfRemediation) return { result: selfRemediation };
+	if (await remediateCoverageFailure(input)) return { retryNode: true };
+	if (await remediateUpstreamImplementationFailure(input)) return { retryNode: true };
+	return null;
+}
 async function remediateWritableNodeFailure(input) {
 	if (input.retry.retryReason !== "gate_failure" || isRemediationNode(input.node) || !nodeCanWrite(input.context, input.node)) return null;
 	const beforeSnapshot = await snapshotChangedFiles(input.context.worktreePath);
@@ -421,23 +423,41 @@ async function executeSelfRemediation(input) {
 }
 async function remediateCoverageFailure(input) {
 	if (input.retry.retryReason !== "gate_failure" || !hasSchedulingRole(input.context, input.node, "coverage")) return false;
+	return await remediatePassedImplementationAncestors(input);
+}
+async function remediateUpstreamImplementationFailure(input) {
+	if (isRemediationNode(input.node) || nodeCanWrite(input.context, input.node) || hasSchedulingRole(input.context, input.node, "coverage")) return false;
+	return await remediatePassedImplementationAncestors(input);
+}
+async function remediatePassedImplementationAncestors(input) {
 	const implementationNodes = upstreamImplementationNodes(input.context, input.node).filter((candidate) => input.context.nodeStates.get(candidate.id)?.status === "passed");
 	if (implementationNodes.length === 0) return false;
-	for (const implementationNode of implementationNodes) {
-		if (isCancelled(input.context)) return false;
-		const beforeSnapshot = await snapshotChangedFiles(input.context.worktreePath);
-		const beforeOutput = input.context.lastOutputByNode.get(implementationNode.id);
-		const result = await executeImplementationRemediation({
-			attempt: input.attempt,
-			context: input.context,
-			coverageNode: input.node,
-			implementationNode,
-			retry: input.retry
-		});
-		if (result.status !== "passed") return false;
-		if (diffChangedFiles(beforeSnapshot, await snapshotChangedFiles(input.context.worktreePath), input.context.worktreePath).files.size === 0 && result.output === beforeOutput) return false;
-		input.context.lastOutputByNode.set(implementationNode.id, result.output);
-	}
+	for (const implementationNode of implementationNodes) if (!await remediateImplementationAncestor(input, implementationNode)) return false;
+	return true;
+}
+async function remediateImplementationAncestor(input, implementationNode) {
+	if (isCancelled(input.context)) return false;
+	const beforeSnapshot = await snapshotChangedFiles(input.context.worktreePath);
+	const beforeOutput = input.context.lastOutputByNode.get(implementationNode.id);
+	const result = await executeImplementationRemediation({
+		attempt: input.attempt,
+		context: input.context,
+		coverageNode: input.node,
+		implementationNode,
+		retry: input.retry
+	});
+	if (result.status !== "passed") return false;
+	return await recordImplementationRemediationEffect({
+		beforeOutput,
+		beforeSnapshot,
+		context: input.context,
+		implementationNode,
+		result
+	});
+}
+async function recordImplementationRemediationEffect(input) {
+	if (diffChangedFiles(input.beforeSnapshot, await snapshotChangedFiles(input.context.worktreePath), input.context.worktreePath).files.size === 0 && input.result.output === input.beforeOutput) return false;
+	input.context.lastOutputByNode.set(input.implementationNode.id, input.result.output);
 	return true;
 }
 async function executeImplementationRemediation(input) {

package/dist/runtime/agent-node/agent-node.js

@@ -4,7 +4,7 @@ import { normalizeRunnerOutput, runnerTextCandidates } from "../../runner-output
 import { gatewayServerForProfile } from "../../mcp/gateway.js";
 import { selectNodeModel } from "../../model-resolver.js";
 import { resolvePackageAssetPath } from "../../package-assets.js";
-import { readJsonSchemaSource, validateJsonSchemaSource } from "../json-validation/json-validation.js";
+import { normalizeJsonSource, readJsonSchemaSource, validateJsonSchemaSource } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
 import { emit, emitAgentFinish, emitAgentStart } from "../events/events.js";
 import "../events/index.js";
@@ -54,22 +54,33 @@ async function executeAgentNode(node, context, attempt) {
 }
 async function finalizeAgentOutput(inputs) {
 	const { attempt, context, node, normalized, plan, result } = inputs;
-	const validStructuredOutput = selectValidStructuredOutput(context, node, plan, result.stdout);
+	const validStructuredOutput = selectValidStructuredOutput(context, node, normalized, plan, result.stdout);
 	if (validStructuredOutput) return validStructuredOutput;
 	const repairContext = outputRepairContext(context, node, normalized, result);
 	if (!repairContext) return normalized;
 	return await runOutputRepair(context, node, normalized, repairContext, attempt);
 }
-function selectValidStructuredOutput(context, node, plan, stdout) {
+function selectValidStructuredOutput(context, node, normalized, plan, stdout) {
 	const output = (node.profile ? context.config.profiles[node.profile] : void 0)?.output;
 	if (output?.format !== "json_schema" || !output.schema_path) return null;
-	const candidates = runnerTextCandidates(plan, stdout);
-	for (const candidate of [...candidates].reverse()) if (validateJsonSchemaSource(candidate.output, output.schema_path, context.worktreePath).passed) return {
-		evidence: [candidate.evidence, `selected valid structured output for ${node.id}`],
-		output: candidate.output
-	};
+	const candidates = structuredOutputCandidates(plan, stdout, normalized);
+	for (const candidate of candidates) {
+		const candidateOutput = normalizeJsonSource(candidate.output);
+		if (validateJsonSchemaSource(candidateOutput, output.schema_path, context.worktreePath).passed) return {
+			evidence: [candidate.evidence, `selected valid structured output for ${node.id}`],
+			output: candidateOutput
+		};
+	}
 	return null;
 }
+function structuredOutputCandidates(plan, stdout, normalized) {
+	const candidates = runnerTextCandidates(plan, stdout);
+	if (candidates.length > 0) return [...candidates].reverse();
+	return [{
+		evidence: normalized.evidence.join("; ") || "selected runner stdout",
+		output: normalized.output
+	}];
+}
 function outputRepairContext(context, node, normalized, result) {
 	if (result.exitCode !== 0 || result.timedOut) return null;
 	const profile = node.profile ? context.config.profiles[node.profile] : void 0;
@@ -110,14 +121,15 @@ async function runOutputRepair(context, node, normalized, repairContext, nodeAtt
 		const repairResult = await context.executor(repairPlan, { signal: context.signal });
 		emitAgentFinish(context, repairPlan, nodeAttempt, repairResult);
 		const repaired = normalizeAgentOutput(repairPlan, repairResult.stdout);
-		const repairedValidation = validateJsonSchemaSource(repaired.output, repairContext.schemaPath, context.worktreePath);
+		const repairedOutput = normalizeJsonSource(repaired.output);
+		const repairedValidation = validateJsonSchemaSource(repairedOutput, repairContext.schemaPath, context.worktreePath);
 		latest = {
 			evidence: [
 				...repaired.evidence,
 				...repairResult.stderr ? [`repair stderr: ${repairResult.stderr}`] : [],
 				...repairResult.timedOut ? ["output repair timed out"] : []
 			],
-			output: repaired.output
+			output: repairedOutput
 		};
 		latestValidation = repairedValidation;
 		const passed = repairResult.exitCode === 0 && repairedValidation.passed;
@@ -131,7 +143,7 @@ async function runOutputRepair(context, node, normalized, repairContext, nodeAtt
 		});
 		if (passed) return {
 			evidence,
-			output: repaired.output
+			output: repairedOutput
 		};
 	}
 	return {

package/dist/runtime/json-validation/json-validation.js

@@ -6,6 +6,7 @@ import Ajv from "ajv";
 import addFormats from "ajv-formats";
 //#region src/runtime/json-validation/json-validation.ts
 const LINE_RE = /\r?\n/;
+const MARKDOWN_JSON_FENCE_RE = /^\s*```(?:json)?\s*\r?\n([\s\S]*?)\r?\n```\s*$/i;
 const jsonSchemaValidator = addFormats(new Ajv({
 	allErrors: true,
 	strict: false
@@ -15,7 +16,7 @@ function parseRuntimeOutput(format, output) {
 	if (!(format === "json" || format === "json_schema" || format === "jsonl")) return { output };
 	try {
 		if (format === "jsonl") return { output: output.split(LINE_RE).filter((line) => line.trim().length > 0).map((line) => parseJson(line, "runtime JSONL line")) };
-		return { output: parseJson(output, "runtime JSON output") };
+		return { output: parseJson(normalizeJsonSource(output), "runtime JSON output") };
 	} catch (err) {
 		return {
 			error: err instanceof Error ? err.message : "failed to parse output",
@@ -26,7 +27,7 @@ function parseRuntimeOutput(format, output) {
 function validateJsonSchemaSource(source, schemaPath, worktreePath) {
 	try {
 		const schemaSource = readJsonSchemaSource(schemaPath, worktreePath);
-		const value = parseJson(source, "JSON schema gate value");
+		const value = parseJson(normalizeJsonSource(source), "JSON schema gate value");
 		const validate = compiledJsonSchemaValidator(schemaPath, schemaSource);
 		const errors = validate(value) ? [] : formatJsonSchemaErrors(validate.errors ?? []);
 		return {
@@ -42,6 +43,10 @@ function validateJsonSchemaSource(source, schemaPath, worktreePath) {
 		};
 	}
 }
+function normalizeJsonSource(source) {
+	const trimmed = source.trim();
+	return MARKDOWN_JSON_FENCE_RE.exec(trimmed)?.[1].trim() ?? trimmed;
+}
 function readJsonSchemaSource(schemaPath, worktreePath) {
 	const standardName = standardOutputSchemaNameFromPath(schemaPath);
 	if (standardName) return standardOutputSchemaJson(standardName);
@@ -82,4 +87,4 @@ function parseJsonObject(value) {
 	}
 }
 //#endregion
-export { parseJsonObject, parseRuntimeOutput, readJsonSchemaSource, readOptionalFile, validateJsonSchemaSource };
+export { normalizeJsonSource, parseJsonObject, parseRuntimeOutput, readJsonSchemaSource, readOptionalFile, validateJsonSchemaSource };

package/package.json

@@ -120,7 +120,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "1.27.11",
+  "version": "1.27.13",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",