@oisincoveney/pipeline 2.7.0 → 2.8.1

package/dist/planning/compile.d.ts

@@ -7,9 +7,14 @@ interface WorkflowPlannerIssue {
   message: string;
   path?: string;
 }
-declare class WorkflowPlannerError extends Error {
-  code: WorkflowPlannerErrorCode;
-  issues: WorkflowPlannerIssue[];
+declare const WorkflowPlannerError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "WorkflowPlannerError";
+} & Readonly<A>;
+declare class WorkflowPlannerError extends WorkflowPlannerError_base<{
+  readonly code: WorkflowPlannerErrorCode;
+  readonly message: string;
+  readonly issues: WorkflowPlannerIssue[];
+}> {
   constructor(code: WorkflowPlannerErrorCode, message: string, issues?: WorkflowPlannerIssue[]);
 }
 interface PlannedWorkflowNode {

package/dist/planning/compile.js

@@ -1,15 +1,15 @@
 import { uniqueStrings } from "../strings.js";
 import { findDependencyCycles } from "./graph.js";
+import { Data } from "effect";
 import { Graph } from "@dagrejs/graphlib";
 //#region src/planning/compile.ts
-var WorkflowPlannerError = class extends Error {
-	code;
-	issues;
+var WorkflowPlannerError = class extends Data.TaggedError("WorkflowPlannerError") {
 	constructor(code, message, issues = []) {
-		super(message);
-		this.name = "WorkflowPlannerError";
-		this.code = code;
-		this.issues = issues;
+		super({
+			code,
+			message,
+			issues
+		});
 	}
 };
 function compileWorkflowPlan(config, workflowId = config.default_workflow) {

package/dist/planning/generate.d.ts

@@ -1594,7 +1594,12 @@ interface SchedulePlanningContext {
   workUnits: BacklogWorkUnit[];
 }
 declare function parseScheduleArtifact(source: string, sourcePath?: string): ScheduleArtifact;
-declare class ScheduleArtifactError extends Error {
+declare const ScheduleArtifactError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "ScheduleArtifactError";
+} & Readonly<A>;
+declare class ScheduleArtifactError extends ScheduleArtifactError_base<{
+  readonly message: string;
+}> {
   constructor(message: string);
 }
 declare function compileScheduleArtifact(config: PipelineConfig, artifact: ScheduleArtifact, projectRoot?: string): CompiledScheduleArtifact;

package/dist/planning/generate.js

@@ -17,6 +17,7 @@ import { plannerPrompt, plannerRepairPrompt } from "../schedule/prompts.js";
 import { compileWorkflowPlan } from "./compile.js";
 import { parseDocument, stringify } from "yaml";
 import { z } from "zod";
+import { Data } from "effect";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/planning/generate.ts
@@ -30,10 +31,12 @@ const SCHEDULE_BUILTINS = [
 	"duplication",
 	"fallow",
 	"lint",
+	"select-candidate",
 	"semgrep",
 	"test",
 	"typecheck"
 ];
+const PARALLEL_MERGE_BUILTINS = new Set(["drain-merge", "select-candidate"]);
 const scheduleArtifactSchema = z.object({
 	generated_at: z.string().datetime(),
 	kind: z.literal(SCHEDULE_KIND),
@@ -54,10 +57,9 @@ function parseScheduleArtifact(source, sourcePath = "schedule.yaml") {
 	if (!parsed.success) throw new ScheduleArtifactError([`Invalid schedule artifact ${sourcePath}:`, ...parsed.error.issues.map((issue) => issue.path.length > 0 ? `- ${issue.path.join(".")}: ${issue.message}` : `- ${issue.message}`)].join("\n"));
 	return parsed.data;
 }
-var ScheduleArtifactError = class extends Error {
+var ScheduleArtifactError = class extends Data.TaggedError("ScheduleArtifactError") {
 	constructor(message) {
-		super(message);
-		this.name = "ScheduleArtifactError";
+		super({ message });
 	}
 };
 function compileScheduleArtifact(config, artifact, projectRoot) {
@@ -255,11 +257,28 @@ function unsafeParallelWorktreeIssues(config, artifact) {
 		return [`parallel node '${workflowId}.${node.id}' has write-capable children sharing a worktree without isolated worktree roots or drain-merge integration`];
 	}));
 }
+function registerContainmentEdge(parent, child, index) {
+	const dependents = index.get(child.id) ?? [];
+	dependents.push(parent);
+	index.set(child.id, dependents);
+}
+function addParallelContainmentEdges(nodes, index) {
+	for (const node of nodes) {
+		if (node.kind !== "parallel") continue;
+		for (const child of node.nodes) registerContainmentEdge(node, child, index);
+		addParallelContainmentEdges(node.nodes, index);
+	}
+}
+function dependentsByNeedWithContainment(nested, flat) {
+	const index = dependentsByNeed(flat);
+	addParallelContainmentEdges(nested, index);
+	return index;
+}
 function workflowNodeIssues(artifact, collectIssues) {
 	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
 		const nodes = flattenWorkflowNodes(workflow.nodes);
 		return collectIssues({
-			dependentsByNeed: dependentsByNeed(nodes),
+			dependentsByNeed: dependentsByNeedWithContainment(workflow.nodes, nodes),
 			nodes,
 			workflowId
 		});
@@ -272,7 +291,7 @@ function isWriteCapableParallelChild(config, node) {
 	return false;
 }
 function hasDownstreamDrainMerge(nodeId, index) {
-	return hasReachableDependent(nodeId, index, (node) => node.kind === "builtin" && node.builtin === "drain-merge");
+	return hasReachableDependent(nodeId, index, (node) => node.kind === "builtin" && PARALLEL_MERGE_BUILTINS.has(node.builtin));
 }
 function generatedRootWorkflowIssues(artifact) {
 	const workflowIds = Object.keys(artifact.workflows);
@@ -324,9 +343,9 @@ function workUnitDependencyIssues(config, artifact, workUnits) {
 	const dependenciesByUnit = new Map(workUnits.map((unit) => [unit.id, (unit.dependencies ?? []).filter((id) => workUnitIds.has(id))]));
 	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
 		const nodes = flattenWorkflowNodes(workflow.nodes);
-		const index = dependentsByNeed(nodes);
+		const index = dependentsByNeedWithContainment(workflow.nodes, nodes);
 		const nodesByWorkUnit = nodesByAssignedWorkUnit(nodes);
-		return nodes.filter((node) => isImplementationNode(config, node)).flatMap((node) => {
+		return nodes.filter((node) => isImplementationNode(config, node) || isSelectCandidateNode(node)).flatMap((node) => {
 			const dependentId = node.task_context?.id;
 			if (!dependentId) return [];
 			return (dependenciesByUnit.get(dependentId) ?? []).flatMap((prerequisiteId) => {
@@ -336,6 +355,9 @@ function workUnitDependencyIssues(config, artifact, workUnits) {
 		});
 	});
 }
+function isSelectCandidateNode(node) {
+	return node.kind === "builtin" && node.builtin === "select-candidate";
+}
 function nodesByAssignedWorkUnit(nodes) {
 	const grouped = /* @__PURE__ */ new Map();
 	for (const node of nodes) {

package/dist/run-state/git-refs.js

@@ -1,14 +1,13 @@
+import { GitPorcelainService, GitPorcelainServiceLive } from "../runtime/services/git-porcelain-service.js";
+import { Effect } from "effect";
 import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { tmpdir } from "node:os";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 //#region src/run-state/git-refs.ts
 const DEFAULT_WORKSPACE_PATH = "/workspace";
 const DEFAULT_GIT_CREDENTIALS_DIR = "/etc/pipeline/git-credentials";
 const WRITABLE_GIT_CREDENTIAL_STORE = resolve(tmpdir(), "pipeline-git-credentials");
 const SCP_LIKE_SSH_REMOTE_RE = /^[^@\s]+@[^:\s]+:.+/u;
-const execGit = promisify(execFile);
 let preparedBasicAuthCredentialStore;
 function runnerGitRefs(payload, nodeId) {
 	const prefix = `refs/heads/pipeline/runs/${payload.run.id}/${payload.workflow.id}`;
@@ -19,101 +18,132 @@ function runnerGitRefs(payload, nodeId) {
 	};
 }
 async function prepareRunnerGitWorkspace(payload, options = {}) {
-	if (options.cwd) return resolve(options.cwd);
-	const worktreePath = options.workspacePath ?? DEFAULT_WORKSPACE_PATH;
-	mkdirSync(dirname(worktreePath), { recursive: true });
-	await runGit(dirname(worktreePath), [
-		"clone",
-		"--no-tags",
-		payload.repository.url,
-		worktreePath
-	]);
-	await runGit(worktreePath, ["checkout", payload.repository.sha ?? `origin/${payload.repository.baseBranch}`]);
-	return worktreePath;
+	return await Effect.runPromise(Effect.provide(prepareRunnerGitWorkspaceEffect(payload, options), GitPorcelainServiceLive));
+}
+function prepareRunnerGitWorkspaceEffect(payload, options) {
+	return Effect.gen(function* () {
+		if (options.cwd) return resolve(options.cwd);
+		const worktreePath = options.workspacePath ?? DEFAULT_WORKSPACE_PATH;
+		yield* Effect.sync(() => mkdirSync(dirname(worktreePath), { recursive: true }));
+		yield* runGit(dirname(worktreePath), [
+			"clone",
+			"--no-tags",
+			payload.repository.url,
+			worktreePath
+		]);
+		yield* runGit(worktreePath, ["checkout", payload.repository.sha ?? `origin/${payload.repository.baseBranch}`]);
+		return worktreePath;
+	});
 }
 async function mergeDependencyRefs(input) {
-	await configureGitCommitter(input.worktreePath, input.committer);
-	for (const nodeId of input.dependencyNodeIds) {
-		const ref = runnerGitRefs(input.payload, nodeId).nodeRef;
-		await runGit(input.worktreePath, [
+	return await Effect.runPromise(Effect.provide(mergeDependencyRefsEffect(input), GitPorcelainServiceLive));
+}
+function mergeDependencyRefsEffect(input) {
+	return Effect.gen(function* () {
+		yield* configureGitCommitter(input.worktreePath, input.committer);
+		yield* Effect.forEach(input.dependencyNodeIds, (nodeId) => mergeDependencyRef(input.worktreePath, runnerGitRefs(input.payload, nodeId).nodeRef));
+	});
+}
+function mergeDependencyRef(worktreePath, ref) {
+	return Effect.gen(function* () {
+		yield* runGit(worktreePath, [
 			"fetch",
 			"origin",
 			ref
 		]);
-		await runGit(input.worktreePath, [
+		yield* runGit(worktreePath, [
 			"merge",
 			"--no-ff",
 			"--no-edit",
 			"FETCH_HEAD"
 		]);
-	}
+	});
 }
 async function commitAndPushNodeRef(input) {
-	await commitChangesIfNeeded(input.worktreePath, input.nodeId, input.committer);
-	const sha = (await runGit(input.worktreePath, ["rev-parse", "HEAD"])).trim();
-	await runGit(input.worktreePath, [
-		"push",
-		"origin",
-		`HEAD:${runnerGitRefs(input.payload, input.nodeId).nodeRef}`
-	]);
-	return sha;
+	return await Effect.runPromise(Effect.provide(commitAndPushNodeRefEffect(input), GitPorcelainServiceLive));
+}
+function commitAndPushNodeRefEffect(input) {
+	return Effect.gen(function* () {
+		yield* commitChangesIfNeeded(input.worktreePath, input.nodeId, input.committer);
+		const sha = yield* headSha(input.worktreePath);
+		yield* runGit(input.worktreePath, [
+			"push",
+			"origin",
+			`HEAD:${runnerGitRefs(input.payload, input.nodeId).nodeRef}`
+		]);
+		return sha;
+	});
 }
 async function promoteFinalRef(input) {
-	await mergeDependencyRefs({
-		committer: input.committer,
-		dependencyNodeIds: input.sourceNodeIds,
-		payload: input.payload,
-		worktreePath: input.worktreePath
+	return await Effect.runPromise(Effect.provide(promoteFinalRefEffect(input), GitPorcelainServiceLive));
+}
+function promoteFinalRefEffect(input) {
+	return Effect.gen(function* () {
+		yield* mergeDependencyRefsEffect({
+			committer: input.committer,
+			dependencyNodeIds: input.sourceNodeIds,
+			payload: input.payload,
+			worktreePath: input.worktreePath
+		});
+		yield* commitChangesIfNeeded(input.worktreePath, "final", input.committer);
+		const sha = yield* headSha(input.worktreePath);
+		yield* runGit(input.worktreePath, [
+			"push",
+			"origin",
+			`HEAD:${runnerGitRefs(input.payload, "final").finalRef}`
+		]);
+		return sha;
+	});
+}
+function headSha(worktreePath) {
+	return Effect.map(runGit(worktreePath, ["rev-parse", "HEAD"]), (sha) => sha.trim());
+}
+function commitChangesIfNeeded(worktreePath, nodeId, committer) {
+	return Effect.gen(function* () {
+		if ((yield* runGit(worktreePath, [
+			"status",
+			"--porcelain",
+			"--untracked-files=all"
+		])).trim().length === 0) return;
+		yield* runGit(worktreePath, ["add", "--all"]);
+		yield* configureGitCommitter(worktreePath, committer);
+		yield* runGit(worktreePath, [
+			"commit",
+			"-m",
+			`pipeline: ${nodeId}`
+		]);
+	});
+}
+function configureGitCommitter(worktreePath, committer) {
+	return Effect.gen(function* () {
+		yield* runGit(worktreePath, [
+			"config",
+			"--local",
+			"user.name",
+			committer.name
+		]);
+		yield* runGit(worktreePath, [
+			"config",
+			"--local",
+			"user.email",
+			committer.email
+		]);
 	});
-	await commitChangesIfNeeded(input.worktreePath, "final", input.committer);
-	const sha = (await runGit(input.worktreePath, ["rev-parse", "HEAD"])).trim();
-	await runGit(input.worktreePath, [
-		"push",
-		"origin",
-		`HEAD:${runnerGitRefs(input.payload, "final").finalRef}`
-	]);
-	return sha;
-}
-async function commitChangesIfNeeded(worktreePath, nodeId, committer) {
-	if ((await runGit(worktreePath, [
-		"status",
-		"--porcelain",
-		"--untracked-files=all"
-	])).trim().length === 0) return;
-	await runGit(worktreePath, ["add", "--all"]);
-	await configureGitCommitter(worktreePath, committer);
-	await runGit(worktreePath, [
-		"commit",
-		"-m",
-		`pipeline: ${nodeId}`
-	]);
-}
-async function configureGitCommitter(worktreePath, committer) {
-	await runGit(worktreePath, [
-		"config",
-		"--local",
-		"user.name",
-		committer.name
-	]);
-	await runGit(worktreePath, [
-		"config",
-		"--local",
-		"user.email",
-		committer.email
-	]);
 }
 function runnerGitCommandArgs(args, remoteUrl) {
 	return [...gitCredentialConfigArgs(remoteUrl), ...args];
 }
-async function runGit(cwd, args) {
-	const remoteUrl = await remoteUrlFromGitArgs(cwd, args);
-	assertSshCredentialsAvailable(remoteUrl);
-	const { stdout } = await execGit("git", runnerGitCommandArgs(args, remoteUrl), {
-		cwd,
-		encoding: "utf8",
-		env: runnerGitEnv(remoteUrl)
+function runGit(cwd, args) {
+	return Effect.gen(function* () {
+		const remoteUrl = yield* remoteUrlFromGitArgs(cwd, args);
+		yield* Effect.try({
+			try: () => assertSshCredentialsAvailable(remoteUrl),
+			catch: (error) => error
+		});
+		const git = yield* GitPorcelainService;
+		const commandArgs = runnerGitCommandArgs(args, remoteUrl);
+		return yield* git.run(cwd, commandArgs, runnerGitEnv(remoteUrl));
 	});
-	return stdout;
 }
 function assertSshCredentialsAvailable(remoteUrl) {
 	if (!(remoteUrl && isSshRemote(remoteUrl))) return;
@@ -227,12 +257,15 @@ function isOwnerReadOnly(path) {
 function readCredentialFile(path) {
 	return readFileSync(path, "utf8").trim();
 }
-async function remoteUrlFromGitArgs(cwd, args) {
-	const literalRemoteUrl = literalRemoteUrlFromGitArgs(args);
-	if (literalRemoteUrl) return literalRemoteUrl;
-	const remoteName = remoteNameFromGitArgs(args);
-	if (!remoteName) return;
-	return await gitRemoteUrl(cwd, remoteName);
+function remoteUrlFromGitArgs(cwd, args) {
+	return Effect.gen(function* () {
+		const literalRemoteUrl = literalRemoteUrlFromGitArgs(args);
+		if (literalRemoteUrl) return literalRemoteUrl;
+		return yield* remoteUrlForName(cwd, remoteNameFromGitArgs(args));
+	});
+}
+function remoteUrlForName(cwd, remoteName) {
+	return remoteName ? gitRemoteUrl(cwd, remoteName) : Effect.succeed(void 0);
 }
 function literalRemoteUrlFromGitArgs(args) {
 	if (args[0] === "clone") return args.find((arg) => isRemoteUrl(arg));
@@ -247,20 +280,17 @@ function remoteNameFromGitArgs(args) {
 		if (remoteArg && !remoteArg.startsWith("-") && !isRemoteUrl(remoteArg)) return remoteArg;
 	}
 }
-async function gitRemoteUrl(cwd, remoteName) {
-	const { stdout } = await execGit("git", [
-		"remote",
-		"get-url",
-		remoteName
-	], {
-		cwd,
-		encoding: "utf8",
-		env: {
+function gitRemoteUrl(cwd, remoteName) {
+	return Effect.gen(function* () {
+		return (yield* (yield* GitPorcelainService).run(cwd, [
+			"remote",
+			"get-url",
+			remoteName
+		], {
 			...process.env,
 			GIT_TERMINAL_PROMPT: "0"
-		}
+		})).trim() || void 0;
 	});
-	return stdout.trim() || void 0;
 }
 function isRemoteUrl(value) {
 	return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("ssh://") || isScpLikeSshRemote(value);

package/dist/runner-command-contract.d.ts

@@ -140,8 +140,13 @@ interface RunnerCommandPayloadValidationIssue {
   message: string;
   path: string;
 }
-declare class RunnerCommandPayloadValidationError extends Error {
+declare const RunnerCommandPayloadValidationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "RunnerCommandPayloadValidationError";
+} & Readonly<A>;
+declare class RunnerCommandPayloadValidationError extends RunnerCommandPayloadValidationError_base<{
+  readonly message: string;
   readonly issues: RunnerCommandPayloadValidationIssue[];
+}> {
   constructor(message: string, issues: RunnerCommandPayloadValidationIssue[]);
 }
 interface BuildRunnerCommandPayloadOptions {

package/dist/runner-command-contract.js

@@ -1,5 +1,6 @@
 import { parseJson } from "./safe-json.js";
 import { z } from "zod";
+import { Data } from "effect";
 import { readFileSync } from "node:fs";
 import parseGitUrl from "git-url-parse";
 //#region src/runner-command-contract.ts
@@ -71,12 +72,12 @@ const runnerCommandPayloadSchema = z.object({
 	task: runnerTaskSchema,
 	workflow: runnerWorkflowIdentitySchema
 }).strict();
-var RunnerCommandPayloadValidationError = class extends Error {
-	issues;
+var RunnerCommandPayloadValidationError = class extends Data.TaggedError("RunnerCommandPayloadValidationError") {
 	constructor(message, issues) {
-		super(message);
-		this.name = "RunnerCommandPayloadValidationError";
-		this.issues = issues;
+		super({
+			message,
+			issues
+		});
 	}
 };
 function resolveRunnerEventSinkAuthToken(options) {

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

@@ -10,8 +10,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
   sequence: z.ZodNumber;
   type: z.ZodEnum<{
-    "workflow.planned": "workflow.planned";
     "workflow.start": "workflow.start";
+    "workflow.planned": "workflow.planned";
   }>;
   workflowPlan: z.ZodObject<{
     edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -55,10 +55,10 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
     }>;
   }, z.core.$strip>;
   type: z.ZodEnum<{
+    "node.start": "node.start";
+    "node.finish": "node.finish";
     "agent.finish": "agent.finish";
     "agent.start": "agent.start";
-    "node.finish": "node.finish";
-    "node.start": "node.start";
   }>;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
@@ -180,8 +180,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
     sequence: z.ZodNumber;
     type: z.ZodEnum<{
-      "workflow.planned": "workflow.planned";
       "workflow.start": "workflow.start";
+      "workflow.planned": "workflow.planned";
     }>;
     workflowPlan: z.ZodObject<{
       edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -225,10 +225,10 @@ declare const runnerEventBatchSchema: z.ZodObject<{
       }>;
     }, z.core.$strip>;
     type: z.ZodEnum<{
+      "node.start": "node.start";
+      "node.finish": "node.finish";
       "agent.finish": "agent.finish";
       "agent.start": "agent.start";
-      "node.finish": "node.finish";
-      "node.start": "node.start";
     }>;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;

package/dist/runner-event-sink.js

@@ -1,38 +1,14 @@
 import { mapRuntimeEventToRunnerEventRecords } from "./runner-command-contract.js";
-import ky, { isHTTPError } from "ky";
+import { RunnerEventSinkHttpService, RunnerEventSinkHttpServiceLive } from "./runtime/services/runner-event-sink-http-service.js";
+import { Effect } from "effect";
 //#region src/runner-event-sink.ts
 const DEFAULT_BATCH_SIZE = 50;
 const DEFAULT_MAX_RETRIES = 0;
 const DEFAULT_RETRY_DELAY_MS = 250;
-const RETRYABLE_STATUS_CODES = [
-	408,
-	429,
-	500,
-	501,
-	502,
-	503,
-	504,
-	505,
-	506,
-	507,
-	508,
-	509,
-	510,
-	511
-];
-var EventSinkHttpError = class extends Error {
-	status;
-	constructor(status, message) {
-		super(message);
-		this.name = "EventSinkHttpError";
-		this.status = status;
-	}
-};
 function createRunnerEventSink(options) {
-	const batchSize = Math.max(1, options.batchSize ?? DEFAULT_BATCH_SIZE);
-	const fetchImpl = options.fetch ?? globalThis.fetch?.bind(globalThis);
-	if (!fetchImpl) throw new Error("Runner event sink requires fetch support");
-	if (!options.authToken.trim()) throw new Error("Runner event sink requires an auth token");
+	const batchSize = positiveOrDefault(options.batchSize, DEFAULT_BATCH_SIZE);
+	const fetchImpl = resolveFetch(options.fetch);
+	assertAuthToken(options.authToken);
 	const queue = [];
 	let flushChain = Promise.resolve();
 	let nextSequence = 1;
@@ -45,15 +21,17 @@ function createRunnerEventSink(options) {
 			sequence
 		};
 	};
-	const flushQueue = async () => {
-		while (queue.length > 0) {
+	const flushQueueEffect = () => Effect.gen(function* () {
+		const service = yield* RunnerEventSinkHttpService;
+		while (hasQueuedEvents(queue)) {
 			const batch = queue.slice(0, batchSize);
-			await postBatch(options, fetchImpl, batch);
+			yield* service.postBatch(postBatchRequest(options, fetchImpl, batch));
 			queue.splice(0, batch.length);
 		}
-	};
+	});
+	const runFlush = () => Effect.runPromise(Effect.provide(flushQueueEffect(), RunnerEventSinkHttpServiceLive));
 	const runSerializedFlush = () => {
-		const nextFlush = flushChain.then(flushQueue, flushQueue);
+		const nextFlush = flushChain.then(runFlush, runFlush);
 		flushChain = nextFlush.catch(() => void 0);
 		return nextFlush;
 	};
@@ -144,41 +122,32 @@ function createRunnerEventSink(options) {
 		}
 	};
 }
-async function postBatch(options, fetchImpl, events) {
-	const maxRetries = Math.max(0, options.maxRetries ?? DEFAULT_MAX_RETRIES);
-	const retryDelayMs = Math.max(0, options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS);
-	try {
-		await ky.post(options.url, {
-			fetch: kyFetchAdapter(fetchImpl),
-			headers: { [options.authHeader ?? "Authorization"]: `Bearer ${options.authToken}` },
-			json: { events },
-			retry: {
-				delay: () => retryDelayMs,
-				limit: maxRetries,
-				methods: ["post"],
-				retryOnTimeout: true,
-				statusCodes: RETRYABLE_STATUS_CODES
-			}
-		});
-	} catch (err) {
-		if (isHTTPError(err)) {
-			let data = "";
-			if (typeof err.data === "string") data = err.data;
-			else if (err.data !== void 0) data = JSON.stringify(err.data);
-			throw new EventSinkHttpError(err.response.status, `Event sink responded with ${err.response.status}${data ? `: ${data}` : ""}`);
-		}
-		throw err instanceof Error ? err : new Error(String(err));
-	}
+function hasQueuedEvents(queue) {
+	return queue.length > 0;
 }
-function kyFetchAdapter(fetchImpl) {
-	return async (input, init) => {
-		const request = new Request(input, init);
-		return fetchImpl(request.url, {
-			body: await request.clone().text(),
-			headers: request.headers,
-			method: request.method,
-			signal: request.signal
-		});
+function positiveOrDefault(value, fallback) {
+	return Math.max(1, value ?? fallback);
+}
+function nonNegativeOrDefault(value, fallback) {
+	return Math.max(0, value ?? fallback);
+}
+function resolveFetch(fetchImpl) {
+	const resolved = fetchImpl ?? globalThis.fetch?.bind(globalThis);
+	if (!resolved) throw new Error("Runner event sink requires fetch support");
+	return resolved;
+}
+function assertAuthToken(authToken) {
+	if (!authToken.trim()) throw new Error("Runner event sink requires an auth token");
+}
+function postBatchRequest(options, fetchImpl, events) {
+	return {
+		authHeader: options.authHeader,
+		authToken: options.authToken,
+		events,
+		fetch: fetchImpl,
+		maxRetries: nonNegativeOrDefault(options.maxRetries, DEFAULT_MAX_RETRIES),
+		retryDelayMs: nonNegativeOrDefault(options.retryDelayMs, DEFAULT_RETRY_DELAY_MS),
+		url: options.url
 	};
 }
 function timestamp(now) {

package/dist/runner.d.ts

@@ -80,7 +80,12 @@ interface RunnerLaunchInput {
   prompt: string;
   worktreePath: string;
 }
-declare class RunnerCapabilityError extends Error {
+declare const RunnerCapabilityError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "RunnerCapabilityError";
+} & Readonly<A>;
+declare class RunnerCapabilityError extends RunnerCapabilityError_base<{
+  readonly message: string;
+}> {
   constructor(message: string);
 }
 /**