@oisincoveney/pipeline 2.11.0 → 2.11.2

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/run-control/run-state-lock.js

@@ -0,0 +1,41 @@
+//#region src/run-control/run-state-lock.ts
+/**
+* Process-wide serialization for critical sections that read, write, or
+* temporarily relocate the `.pipeline/runs` run-state directory.
+*
+* The mechanical-check builtins (`lint`, `fallow`) hide `.pipeline/runs` for the
+* duration of their command so those tools do not scan supervisor run-state
+* (see builtins.ts `hidePipelineRunsDirectory`). Under the parallel
+* mechanical-checks fan-out that hide window overlapped the run-control
+* reporter's persistence of sibling node-status events, which then observed a
+* momentarily-missing run directory and failed the whole run with
+* "Run <id> does not exist". This lock makes the hide window and run-state
+* persistence mutually exclusive without serializing any unrelated parallel
+* work: only the run-state critical sections contend for it.
+*/
+let chain = Promise.resolve();
+/**
+* Acquire the lock, resolving with a release function once every previously
+* queued holder has released. Callers MUST invoke the returned release exactly
+* once (use `withRunStateLock` unless you must span non-promise boundaries, as
+* the builtin hide/restore does).
+*/
+function acquireRunStateLock() {
+	const previous = chain;
+	let release = () => {};
+	chain = new Promise((resolve) => {
+		release = resolve;
+	});
+	return previous.then(() => release);
+}
+/** Run `fn` while holding the run-state lock, releasing on success or failure. */
+async function withRunStateLock(fn) {
+	const release = await acquireRunStateLock();
+	try {
+		return await fn();
+	} finally {
+		release();
+	}
+}
+//#endregion
+export { acquireRunStateLock, withRunStateLock };

package/dist/run-control/runtime-reporter.js

@@ -1,3 +1,4 @@
+import { withRunStateLock } from "./run-state-lock.js";
 import { updateNodeSessionEffect, updateNodeStatusEffect, updateRunStatusEffect } from "./store.js";
 import { Effect } from "effect";
 import { isAbsolute, join } from "node:path";
@@ -23,7 +24,7 @@ function createRunStoreRuntimeReporterRuntime(input) {
 			activeHookPreviousStatuses,
 			observedNodeStatuses
 		});
-		writeChain = writeChain.then(() => Effect.runPromise(persistRuntimeEventEffect(input, event, projection, now)));
+		writeChain = writeChain.then(() => withRunStateLock(() => Effect.runPromise(persistRuntimeEventEffect(input, event, projection, now))));
 	};
 	const flushEffect = () => Effect.tryPromise({
 		catch: (error) => error,

package/dist/runner-event-schema.d.ts

@@ -103,8 +103,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
     nodeId: z.ZodOptional<z.ZodString>;
     outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     status: z.ZodEnum<{
-      pass: "pass";
       fail: "fail";
+      pass: "pass";
       skip: "skip";
     }>;
     summary: z.ZodOptional<z.ZodString>;
@@ -273,8 +273,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
       nodeId: z.ZodOptional<z.ZodString>;
       outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
       status: z.ZodEnum<{
-        pass: "pass";
         fail: "fail";
+        pass: "pass";
         skip: "skip";
       }>;
       summary: z.ZodOptional<z.ZodString>;

package/dist/runtime/builtins/builtins.js

@@ -1,4 +1,5 @@
 import { parseJson } from "../../safe-json.js";
+import { acquireRunStateLock } from "../../run-control/run-state-lock.js";
 import { executeDrainMergeBuiltin } from "../drain-merge/drain-merge.js";
 import "../drain-merge/index.js";
 import { CommandExecutor, CommandExecutorLive } from "../services/command-executor-service.js";
@@ -95,7 +96,7 @@ function executeVisibleProjectCommand(command, context) {
 	});
 }
 function withHiddenPipelineRuns(worktreePath, effect) {
-	return Effect.acquireUseRelease(Effect.sync(() => hidePipelineRunsDirectory(worktreePath)), () => effect, (hiddenRuns) => Effect.sync(() => hiddenRuns?.restore()));
+	return Effect.acquireUseRelease(Effect.promise(() => acquireRunStateLock()), () => Effect.acquireUseRelease(Effect.sync(() => hidePipelineRunsDirectory(worktreePath)), () => effect, (hiddenRuns) => Effect.sync(() => hiddenRuns?.restore())), (release) => Effect.sync(() => release()));
 }
 function resolveRequiredScriptCommand(worktreePath, envName, scriptName) {
 	return Effect.gen(function* () {

package/dist/runtime/gates/gates.js

@@ -308,7 +308,7 @@ function evaluateChangedFilesGate(gate, gateId, nodeId, context) {
 	const changed = context.nodeStateStore.changedFiles(nodeId);
 	const policy = gate.changed_files ?? {};
 	const evidence = [];
-	const included = policy.include_untracked === false ? changed.filter((file) => !file.startsWith("?? ")) : changed;
+	const included = (policy.include_untracked === false ? changed.filter((file) => !file.startsWith("?? ")) : changed).filter((file) => !isSupervisorRunStatePath(file));
 	const denied = included.filter((file) => (policy.deny ?? []).some((pattern) => globMatch(pattern, file)));
 	if (denied.length > 0) evidence.push(`denied changes: ${denied.join(", ")}`);
 	const disallowed = included.filter((file) => (policy.allow?.length ?? 0) > 0 && !(policy.allow ?? []).some((pattern) => globMatch(pattern, file)));
@@ -324,6 +324,34 @@ function evaluateChangedFilesGate(gate, gateId, nodeId, context) {
 		reason: passed ? void 0 : "changed-file policy failed"
 	};
 }
+/**
+* Supervisor-owned run-state the run-control store and journal write into the
+* worktree's .pipeline/ during a run (src/run-control/store.ts RUNS_DIRECTORY
+* and src/runtime/run-journal.ts). These are never node-authored content under
+* test, so the changed_files gate must not attribute them to a node. Narrowly
+* scoped to run-state, NOT a blanket .pipeline/ bypass, so a node that writes
+* real output under .pipeline/ is still gated.
+*/
+const SUPERVISOR_RUN_STATE_GLOBS = [
+	"**/.pipeline/runs/**",
+	"**/.pipeline/journal/**",
+	"**/.pipeline/runtime-events.jsonl",
+	"**/.pipeline/**/status.json"
+];
+function isSupervisorRunStatePath(file) {
+	const path = stripPorcelainStatusPrefix(file);
+	return SUPERVISOR_RUN_STATE_GLOBS.some((pattern) => globMatch(pattern, path));
+}
+/**
+* Snapshot entries are repo-relative paths (the porcelain parser already strips
+* the status code), but some fixtures and untracked entries carry a leading
+* "XY " status prefix. Strip it before matching run-state globs so both shapes
+* resolve to the same path; non-prefixed paths (".pipeline/...") are unchanged.
+*/
+const PORCELAIN_STATUS_PREFIX = /^.{2} /;
+function stripPorcelainStatusPrefix(file) {
+	return PORCELAIN_STATUS_PREFIX.test(file) ? file.slice(3) : file;
+}
 function globMatch(pattern, value) {
 	return micromatch.isMatch(value, pattern, { dot: true });
 }

package/dist/runtime/opencode-session-executor.js

@@ -1,6 +1,7 @@
+import { isRecord } from "../safe-json.js";
 import { opencodeAgentName } from "./opencode-agent-name.js";
 import { OpencodeSdkService, OpencodeSdkServiceLive } from "./services/opencode-sdk-service.js";
-import { Effect } from "effect";
+import { Duration, Effect } from "effect";
 //#region src/runtime/opencode-session-executor.ts
 function createOpencodeSessionRegistry() {
 	return { sessions: /* @__PURE__ */ new Map() };
@@ -20,7 +21,7 @@ const EXIT_INFRA = 70;
 */
 function createOpencodeExecutor(deps) {
 	return async function execute(plan, options = {}) {
-		return await Effect.runPromise(Effect.provide(executeOpencodeEffect(deps, plan, options), OpencodeSdkServiceLive));
+		return await Effect.runPromise(Effect.provide(executeOpencodeEffect(deps, plan, options), OpencodeSdkServiceLive), options.signal ? { signal: options.signal } : void 0);
 	};
 }
 function executeOpencodeEffect(deps, plan, options) {
@@ -43,20 +44,24 @@ function sessionDirectory(deps, plan) {
 }
 function driveSession(deps, plan, options) {
 	return Effect.gen(function* () {
-		const sessionId = yield* resolveSessionId(deps, plan);
+		const sessionId = yield* resolveSessionId(deps, plan, options);
 		recordSession(deps, plan.nodeId, sessionId);
 		const stream = yield* streamEventsToOutput(deps, sessionId, plan, options);
-		return yield* promptSessionResult(deps, plan, sessionId).pipe(Effect.ensuring(stopStream(stream)));
+		return yield* promptSessionResult(deps, plan, sessionId, options).pipe(Effect.ensuring(stopStream(stream)));
 	});
 }
-function promptSessionResult(deps, plan, sessionId) {
-	return Effect.gen(function* () {
-		const data = unwrap(yield* (yield* OpencodeSdkService).promptSession(deps.client, promptRequest(deps, plan, sessionId)));
+function promptSessionResult(deps, plan, sessionId, options) {
+	return retryTransientTransport(() => Effect.gen(function* () {
+		const data = yield* unwrapEffect(yield* (yield* OpencodeSdkService).promptSession(deps.client, promptRequest(deps, plan, sessionId)));
 		return {
 			...data.info ? { assistant: data.info } : {},
 			parts: data.parts ?? [],
 			sessionId
 		};
+	}), {
+		label: "session.prompt",
+		options,
+		plan
 	});
 }
 function promptRequest(deps, plan, sessionId) {
@@ -72,18 +77,77 @@ function stopStream(stream) {
 function recordSession(deps, nodeId, sessionId) {
 	deps.onSession?.(nodeId, sessionId);
 }
-function resolveSessionId(deps, plan) {
+function resolveSessionId(deps, plan, options) {
 	const existing = deps.registry.sessions.get(plan.nodeId);
 	if (existing) return Effect.succeed(existing);
 	return Effect.gen(function* () {
-		const session = unwrap(yield* (yield* OpencodeSdkService).createSession(deps.client, {
-			body: { title: `moka:${plan.nodeId}` },
-			query: { directory: plan.cwd ?? deps.directory }
-		}));
+		const session = yield* retryTransientTransport(() => Effect.gen(function* () {
+			return yield* unwrapEffect(yield* (yield* OpencodeSdkService).createSession(deps.client, {
+				body: { title: `moka:${plan.nodeId}` },
+				query: { directory: plan.cwd ?? deps.directory }
+			}));
+		}), {
+			label: "session.create",
+			options,
+			plan
+		});
 		deps.registry.sessions.set(plan.nodeId, session.id);
 		return session.id;
 	});
 }
+/**
+* Bounded retry for transient OpenCode transport failures at the SDK boundary.
+* Distinct from the node-level retry in retry.ts (which reprompts on gate
+* failures): this re-issues a single SDK call that failed to complete a round
+* trip, before the executor returns an AgentResult. `make` is re-invoked per
+* attempt so each retry issues a fresh request. Backoff sleeps are interruptible
+* via the AbortSignal threaded into Effect.runPromise.
+*/
+const MAX_TRANSIENT_RETRIES = 2;
+const TRANSIENT_RETRY_BASE_MS = 250;
+function retryTransientTransport(make, ctx, attempt = 0) {
+	return make().pipe(Effect.catchAll((error) => attempt < MAX_TRANSIENT_RETRIES && isTransientTransportError(error) ? scheduleTransientRetry(make, ctx, attempt, error) : Effect.fail(error)));
+}
+function scheduleTransientRetry(make, ctx, attempt, error) {
+	const nextAttempt = attempt + 1;
+	const delay = Duration.millis(TRANSIENT_RETRY_BASE_MS * 2 ** attempt);
+	return emitTransientRetry(ctx, error, nextAttempt, delay).pipe(Effect.zipRight(Effect.sleep(delay)), Effect.zipRight(retryTransientTransport(make, ctx, nextAttempt)));
+}
+function emitTransientRetry(ctx, error, attempt, delay) {
+	return Effect.sync(() => {
+		ctx.options.onOutput?.({
+			chunk: `opencode ${ctx.label} transient failure: ${errorMessage(error)}; retry ${attempt}/${MAX_TRANSIENT_RETRIES} in ${Duration.toMillis(delay)}ms\n`,
+			nodeId: ctx.plan.nodeId,
+			stream: "stderr"
+		});
+	});
+}
+const TRANSIENT_TRANSPORT_RE = /fetch failed|econnreset|etimedout|enotfound|eai_again|socket hang ?up|network|connection (?:reset|closed|refused)|aborterror|operation was aborted|timed? ?out/i;
+/**
+* Retry only failures that prove the turn was NOT accepted: transport errors
+* (no completed round trip) and HTTP 429/5xx rejections. Deterministic agent
+* outcomes (output-length, aborted message, schema/contract problems) and gate
+* failures are out of scope and never reach this classifier as retryable.
+*/
+function isTransientTransportError(error) {
+	if (TRANSIENT_TRANSPORT_RE.test(errorMessage(error))) return true;
+	const status = httpStatusFromError(error);
+	return status !== void 0 && (status === 429 || status >= 500);
+}
+function numericField(container, key) {
+	const value = isRecord(container) ? container[key] : void 0;
+	return typeof value === "number" ? value : void 0;
+}
+function httpStatusFromError(error) {
+	const response = isRecord(error) ? error.response : void 0;
+	return numericField(error, "status") ?? numericField(error, "statusCode") ?? numericField(response, "status");
+}
+function unwrapEffect(response) {
+	return Effect.try({
+		catch: (error) => error,
+		try: () => unwrap(response)
+	});
+}
 function promptBody(plan) {
 	const prompt = promptText(plan);
 	const model = parseModel(plan.model);

package/package.json

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