@oisincoveney/pipeline 2.8.3 → 2.9.0

package/dist/runner-command/run.js

@@ -1,16 +1,14 @@
-import { readRunnerTaskDescriptor } from "./task-descriptor.js";
 import { loadPipelineConfig } from "../config/load.js";
 import "../config.js";
-import { compileScheduleArtifact, parseScheduleArtifact } from "../planning/generate.js";
+import { findPlannedNode } from "../planned-node.js";
 import { RunnerCommandPayloadValidationError, parseRunnerCommandPayload, resolveRunnerEventSinkAuthToken } from "../runner-command-contract.js";
-import { commitAndPushNodeRef, mergeDependencyRefs, prepareRunnerGitWorkspace } from "../run-state/git-refs.js";
 import { createRunnerEventSink } from "../runner-event-sink.js";
-import { findPlannedNode } from "../planned-node.js";
-import { runScheduledWorkflowTask } from "../pipeline-runtime.js";
+import { RunnerCommandIoService, RunnerCommandIoServiceLive } from "../runtime/services/runner-command-io-service.js";
+import { readRunnerTaskDescriptorEffect } from "./task-descriptor.js";
+import { compileScheduleArtifact, parseScheduleArtifact } from "../planning/generate.js";
 import { z } from "zod";
-import { readFileSync } from "node:fs";
+import { Effect } from "effect";
 import { resolve } from "node:path";
-import { execa } from "execa";
 import pino from "pino";
 //#region src/runner-command/run.ts
 const runnerCommandOptionsSchema = z.object({
@@ -27,27 +25,47 @@ const EXIT_PASS = 0;
 const EXIT_FAIL = 1;
 const EXIT_VALIDATION = 64;
 const EXIT_STARTUP = 70;
-async function runRunnerCommand(rawOptions = {}) {
+function runRunnerCommand(rawOptions = {}) {
 	const parsedOptions = runnerCommandOptionsSchema.safeParse(rawOptions);
+	const stderr = isOutputStream(rawOptions.stderr) ? rawOptions.stderr : process.stderr;
+	const stdout = isOutputStream(rawOptions.stdout) ? rawOptions.stdout : process.stdout;
 	const logger = createRunnerLogger({
-		stderr: isOutputStream(rawOptions.stderr) ? rawOptions.stderr : process.stderr,
-		stdout: isOutputStream(rawOptions.stdout) ? rawOptions.stdout : process.stdout
+		stderr,
+		stdout
 	});
 	if (!parsedOptions.success) {
 		logger.error({
 			error: parsedOptions.error.message,
 			phase: "options.validate"
 		}, "runner options validation failed");
-		return EXIT_VALIDATION;
+		return Promise.resolve(EXIT_VALIDATION);
 	}
 	const options = parsedOptions.data;
-	try {
+	return Effect.runPromise(Effect.provide(runRunnerCommandEffect(options, {
+		logger,
+		stderr,
+		stdout
+	}), RunnerCommandIoServiceLive));
+}
+function resolveRunnerTargetNode(payload, compiled, descriptor) {
+	return Effect.gen(function* () {
+		if (payload.workflow.id !== compiled.workflowId) return yield* Effect.fail(/* @__PURE__ */ new Error(`Runner payload workflow '${payload.workflow.id}' does not match schedule workflow '${compiled.workflowId}'`));
+		const node = findPlannedNode(compiled.plan.topologicalOrder, descriptor.nodeId);
+		if (!node) return yield* Effect.fail(/* @__PURE__ */ new Error(`Argo task '${descriptor.nodeId}' is not declared in workflow '${compiled.workflowId}'`));
+		return node;
+	});
+}
+function runRunnerCommandEffect(options, runtime) {
+	return Effect.gen(function* () {
+		const io = yield* RunnerCommandIoService;
+		const logger = runtime.logger;
 		logger.info({
 			phase: "payload.load",
 			status: "start"
 		}, "payload.load start");
-		const payload = parseRunnerCommandPayload(readFileSync(options.payloadFile, "utf8"));
-		const descriptor = readRunnerTaskDescriptor(options.taskDescriptorFile ?? "/etc/pipeline/task.json");
+		const payloadRaw = yield* io.readText(options.payloadFile);
+		const payload = yield* attemptSync(() => parseRunnerCommandPayload(payloadRaw));
+		const descriptor = yield* readRunnerTaskDescriptorEffect(options.taskDescriptorFile ?? "/etc/pipeline/task.json");
 		logger.info({
 			nodeId: descriptor.nodeId,
 			phase: "payload.load",
@@ -76,7 +94,7 @@ async function runRunnerCommand(rawOptions = {}) {
 			phase: "git.workspace.prepare",
 			status: "start"
 		}, "git.workspace.prepare start");
-		const worktreePath = await prepareRunnerGitWorkspace(payload, { cwd: options.cwd });
+		const worktreePath = yield* io.prepareRunnerGitWorkspace(payload, { cwd: options.cwd });
 		logger.info({
 			phase: "git.workspace.prepare",
 			status: "finish"
@@ -85,7 +103,7 @@ async function runRunnerCommand(rawOptions = {}) {
 			phase: "config.load",
 			status: "start"
 		}, "config.load start");
-		const baseConfig = loadPipelineConfig(worktreePath, { allowMissingLintFileReferences: true });
+		const baseConfig = yield* attemptSync(() => loadPipelineConfig(worktreePath, { allowMissingLintFileReferences: true }));
 		logger.info({
 			phase: "config.load",
 			status: "finish"
@@ -94,22 +112,21 @@ async function runRunnerCommand(rawOptions = {}) {
 			phase: "schedule.compile",
 			status: "start"
 		}, "schedule.compile start");
-		const compiled = compileScheduleArtifact(baseConfig, parseScheduleArtifact(readFileSync(options.scheduleFile, "utf8"), options.scheduleFile), worktreePath);
+		const scheduleRaw = yield* io.readText(options.scheduleFile);
+		const compiled = yield* attemptSync(() => compileScheduleArtifact(baseConfig, parseScheduleArtifact(scheduleRaw, options.scheduleFile), worktreePath));
 		logger.info({
 			phase: "schedule.compile",
 			status: "finish",
 			workflowId: compiled.workflowId
 		}, "schedule.compile finish");
-		if (payload.workflow.id !== compiled.workflowId) throw new Error(`Runner payload workflow '${payload.workflow.id}' does not match schedule workflow '${compiled.workflowId}'`);
-		const node = findPlannedNode(compiled.plan.topologicalOrder, descriptor.nodeId);
-		if (!node) throw new Error(`Argo task '${descriptor.nodeId}' is not declared in workflow '${compiled.workflowId}'`);
+		const node = yield* resolveRunnerTargetNode(payload, compiled, descriptor);
 		logger.info({
 			dependencyCount: node.needs.length,
 			nodeId: descriptor.nodeId,
 			phase: "dependency.merge",
 			status: "start"
 		}, "dependency.merge start");
-		await mergeDependencyRefs({
+		yield* io.mergeDependencyRefs({
 			committer: compiled.config.runner_command.git.committer,
 			dependencyNodeIds: node.needs,
 			payload,
@@ -126,7 +143,7 @@ async function runRunnerCommand(rawOptions = {}) {
 			phase: "setup.commands",
 			status: "start"
 		}, "setup.commands start");
-		await runSetupCommands(baseConfig.runner_command.environment.setup, {
+		yield* runSetupCommands(baseConfig.runner_command.environment.setup, {
 			env: options.env ?? process.env,
 			logger,
 			worktreePath
@@ -147,13 +164,14 @@ async function runRunnerCommand(rawOptions = {}) {
 			phase: "task.run",
 			status: "start"
 		}, "task.run start");
-		const result = await runScheduledWorkflowTask({
+		const taskText = yield* runnerTaskTextEffect(payload.task, worktreePath);
+		const result = yield* io.runScheduledWorkflowTask({
 			config: compiled.config,
 			hookPolicy: payload.hookPolicy,
 			nodeId: descriptor.nodeId,
 			reporter: (event) => sink.recordRuntimeEvent(event),
 			runId: payload.run.id,
-			task: runnerTaskText(payload.task, worktreePath),
+			task: taskText,
 			workflowId: compiled.workflowId,
 			worktreePath
 		});
@@ -170,7 +188,7 @@ async function runRunnerCommand(rawOptions = {}) {
 			phase: "git.node-ref.push",
 			status: "start"
 		}, "git.node-ref.push start");
-		await commitAndPushNodeRef({
+		yield* io.commitAndPushNodeRef({
 			committer: compiled.config.runner_command.git.committer,
 			nodeId: descriptor.nodeId,
 			payload,
@@ -188,40 +206,61 @@ async function runRunnerCommand(rawOptions = {}) {
 			taskId: descriptor.nodeId,
 			workflowId: payload.workflow.id
 		});
-		await flushAndReport(sink, logger);
+		yield* flushAndReport(sink, logger);
 		return result.status === "passed" ? EXIT_PASS : EXIT_FAIL;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		logger.error({
-			error: message,
-			phase: "runner-command"
-		}, message);
-		return error instanceof RunnerCommandPayloadValidationError || error instanceof z.ZodError ? EXIT_VALIDATION : EXIT_STARTUP;
-	}
+	}).pipe(Effect.catchAll((error) => Effect.sync(() => runnerCommandErrorExitCode(error, runtime.logger))));
 }
-async function runSetupCommands(commands, options) {
-	for (const [index, command] of commands.entries()) {
-		options.logger.info({
-			command: command.command,
-			index: index + 1,
-			phase: "setup.command",
-			status: "start"
-		}, "setup.command start");
-		const result = await execa(command.command, command.args, {
+function attemptSync(try_) {
+	return Effect.try({
+		try: try_,
+		catch: (error) => error
+	});
+}
+function runnerCommandErrorExitCode(error, logger) {
+	const message = error instanceof Error ? error.message : String(error);
+	logger.error({
+		error: message,
+		phase: "runner-command"
+	}, message);
+	return error instanceof RunnerCommandPayloadValidationError || error instanceof z.ZodError ? EXIT_VALIDATION : EXIT_STARTUP;
+}
+function runSetupCommands(commands, options) {
+	return Effect.forEach(commands.entries(), ([index, command]) => runSetupCommand(command, index, options)).pipe(Effect.asVoid);
+}
+function runSetupCommand(command, index, options) {
+	return Effect.gen(function* () {
+		const io = yield* RunnerCommandIoService;
+		const commandIndex = index + 1;
+		options.logger.info(setupCommandLog(command.command, commandIndex, "start"), "setup.command start");
+		const exitCode = setupExitCode((yield* io.runSetupCommand(command.command, command.args, {
 			cwd: options.worktreePath,
-			env: options.env,
-			reject: false
-		});
-		options.logger.info({
-			command: command.command,
-			exitCode: result.exitCode,
-			index: index + 1,
-			phase: "setup.command",
-			required: command.required,
-			status: "finish"
-		}, "setup.command finish");
-		if (result.exitCode !== 0 && command.required) throw new Error(`runner setup command '${command.command}' failed with exit ${result.exitCode}`);
-	}
+			env: options.env
+		})).exitCode);
+		options.logger.info(setupCommandFinishLog(command, commandIndex, exitCode), "setup.command finish");
+		if (exitCode !== 0 && command.required) return yield* Effect.fail(/* @__PURE__ */ new Error(`runner setup command '${command.command}' failed with exit ${exitCode}`));
+	});
+}
+function setupExitCode(exitCode) {
+	if (typeof exitCode === "number") return exitCode;
+	return 1;
+}
+function setupCommandLog(command, index, status) {
+	return {
+		command,
+		index,
+		phase: "setup.command",
+		status
+	};
+}
+function setupCommandFinishLog(command, index, exitCode) {
+	return {
+		command: command.command,
+		exitCode,
+		index,
+		phase: "setup.command",
+		required: command.required,
+		status: "finish"
+	};
 }
 function logFailedTaskRun(logger, nodeId, result) {
 	if (result.status === "passed" && result.exitCode === 0) return;
@@ -235,32 +274,41 @@ function logFailedTaskRun(logger, nodeId, result) {
 		status: "failed"
 	}, "task.run failed");
 }
-function runnerTaskText(task, worktreePath) {
-	if (task.kind === "prompt") return task.prompt;
-	if (task.path) return readFileSync(resolve(worktreePath, task.path), "utf8");
-	return [task.id, task.title].filter(Boolean).join(" ");
+function runnerTaskTextEffect(task, worktreePath) {
+	if (task.kind === "prompt") return Effect.succeed(task.prompt);
+	if (task.path) {
+		const taskPath = task.path;
+		return Effect.gen(function* () {
+			return yield* (yield* RunnerCommandIoService).readText(resolve(worktreePath, taskPath));
+		});
+	}
+	return Effect.succeed([task.id, task.title].filter(Boolean).join(" "));
 }
 function isOutputStream(value) {
 	return typeof value === "object" && value !== null && "write" in value && typeof value.write === "function";
 }
-async function flushAndReport(sink, logger) {
-	logger.info({
-		phase: "event.flush",
-		status: "start"
-	}, "event.flush start");
-	try {
-		await sink.flush();
+function flushAndReport(sink, logger) {
+	return Effect.gen(function* () {
+		const io = yield* RunnerCommandIoService;
 		logger.info({
 			phase: "event.flush",
-			status: "finish"
-		}, "event.flush finish");
-	} catch (error) {
+			status: "start"
+		}, "event.flush start");
+		const result = yield* Effect.either(io.flushSink(sink));
+		if (result._tag === "Right") {
+			logger.info({
+				phase: "event.flush",
+				status: "finish"
+			}, "event.flush finish");
+			return;
+		}
+		const error = result.left;
 		const message = error instanceof Error ? error.message : String(error);
 		logger.error({
 			error: message,
 			phase: "event.flush"
 		}, `runner event flush failed: ${message}`);
-	}
+	});
 }
 function createRunnerLogger(options) {
 	const streams = [{
@@ -291,4 +339,4 @@ function createRunnerLogger(options) {
 	}, pino.multistream(streams, { dedupe: true }));
 }
 //#endregion
-export { runRunnerCommand, runnerTaskText };
+export { runRunnerCommand, runnerTaskTextEffect };

package/dist/runner-command/task-descriptor.js

@@ -1,6 +1,7 @@
 import { parseJson } from "../safe-json.js";
+import { RunnerCommandIoService } from "../runtime/services/runner-command-io-service.js";
 import { z } from "zod";
-import { readFileSync } from "node:fs";
+import { Effect } from "effect";
 //#region src/runner-command/task-descriptor.ts
 const DEFAULT_RUNNER_TASK_DESCRIPTOR_PATH = "/etc/pipeline/task.json";
 const runnerTaskDescriptorSchema = z.object({ nodeId: z.string().min(1) }).strict();
@@ -10,8 +11,14 @@ function buildRunnerTaskDescriptor(nodeId) {
 function parseRunnerTaskDescriptor(raw) {
 	return runnerTaskDescriptorSchema.parse(parseJson(raw, "runner task descriptor JSON"));
 }
-function readRunnerTaskDescriptor(path = DEFAULT_RUNNER_TASK_DESCRIPTOR_PATH) {
-	return parseRunnerTaskDescriptor(readFileSync(path, "utf8"));
+function readRunnerTaskDescriptorEffect(path = DEFAULT_RUNNER_TASK_DESCRIPTOR_PATH) {
+	return Effect.gen(function* () {
+		const raw = yield* (yield* RunnerCommandIoService).readText(path);
+		return yield* Effect.try({
+			try: () => parseRunnerTaskDescriptor(raw),
+			catch: (error) => error
+		});
+	});
 }
 //#endregion
-export { DEFAULT_RUNNER_TASK_DESCRIPTOR_PATH, buildRunnerTaskDescriptor, readRunnerTaskDescriptor };
+export { DEFAULT_RUNNER_TASK_DESCRIPTOR_PATH, buildRunnerTaskDescriptor, readRunnerTaskDescriptorEffect };

package/dist/runner.js

@@ -1,7 +1,7 @@
 import { Data } from "effect";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
 import { execa } from "execa";
+import { join } from "node:path";
 //#region src/runner.ts
 var RunnerCapabilityError = class extends Data.TaggedError("RunnerCapabilityError") {
 	constructor(message) {

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

@@ -1,14 +1,14 @@
 import { resolvePackageAssetPath } from "../../package-assets.js";
 import { resolveFileReference } from "../../path-refs.js";
+import { gatewayServerForProfile } from "../../mcp/gateway.js";
+import { selectNodeModel } from "../../model-resolver.js";
 import { createRunnerLaunchPlan } from "../../runner.js";
 import { normalizeRunnerOutput, runnerTextCandidates } from "../../runner-output.js";
+import { estimateTokens } from "../../token-estimator.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";
-import { gatewayServerForProfile } from "../../mcp/gateway.js";
-import { selectNodeModel } from "../../model-resolver.js";
-import { estimateTokens } from "../../token-estimator.js";
 import { handoffFinalizerPrompt, parseHandoff, renderHandoff, synthesizeMinimalHandoff } from "../handoff.js";
 import { AgentNodeRuntimeService, AgentNodeRuntimeServiceLive } from "../services/agent-node-runtime-service.js";
 import { Effect } from "effect";

package/dist/runtime/builtins/builtins.js

@@ -1,8 +1,7 @@
 import { parseJson } from "../../safe-json.js";
-import { CommandExecutor, CommandExecutorLive } from "../services/command-executor-service.js";
 import { executeDrainMergeBuiltin } from "../drain-merge/drain-merge.js";
 import "../drain-merge/index.js";
-import { executeSelectCandidateBuiltin } from "../select-candidate/select-candidate.js";
+import { CommandExecutor, CommandExecutorLive } from "../services/command-executor-service.js";
 import { Effect } from "effect";
 import { existsSync, readFileSync, renameSync } from "node:fs";
 import { join } from "node:path";
@@ -29,7 +28,6 @@ const BUILTIN_HANDLERS = {
 	duplication: (context) => executeDuplicationBuiltinEffect(context),
 	fallow: (context) => executeFallowBuiltinEffect(context),
 	lint: (context) => executeScriptBuiltinEffect(context, "lint"),
-	"select-candidate": (context, node) => Effect.tryPromise(() => executeSelectCandidateBuiltin(context, node)),
 	semgrep: (context) => executeSemgrepBuiltinEffect(context),
 	test: (context) => executeTestBuiltinEffect(context),
 	typecheck: (context) => executeScriptBuiltinEffect(context, "typecheck")

package/dist/runtime/changed-files/changed-files.js

@@ -1,8 +1,8 @@
 import { GitPorcelainService, GitPorcelainServiceLive } from "../services/git-porcelain-service.js";
 import { Effect } from "effect";
 import { existsSync, readFileSync } from "node:fs";
-import { createHash } from "node:crypto";
 import { join } from "node:path";
+import { createHash } from "node:crypto";
 //#region src/runtime/changed-files/changed-files.ts
 function snapshotChangedFiles(worktreePath) {
 	return Effect.runSync(Effect.provide(snapshotChangedFilesEffect(worktreePath), GitPorcelainServiceLive));

package/dist/runtime/context/context.js

@@ -1,9 +1,9 @@
 import { loadPipelineConfig } from "../../config/load.js";
 import "../../config.js";
 import { runLaunchPlan } from "../../runner.js";
-import { compileWorkflowPlan } from "../../planning/compile.js";
 import { createPublicRuntimeObservabilityEmitter } from "../events/events.js";
 import "../events/index.js";
+import { compileWorkflowPlan } from "../../planning/compile.js";
 import { initialNodeStateStore } from "../node-state-store.js";
 import { randomUUID } from "node:crypto";
 //#region src/runtime/context/context.ts

package/dist/runtime/contracts/contracts.d.ts

@@ -146,6 +146,10 @@ type PipelineRuntimeEvent = {
   profile?: string;
   schemaPath?: string;
   type: "node.output.recorded";
+} | {
+  nodeId: string;
+  sessionId: string;
+  type: "node.session";
 } | {
   attempt: number;
   nodeId: string;

package/dist/runtime/hooks/hooks.js

@@ -1,11 +1,11 @@
 import { parseJson } from "../../safe-json.js";
-import { parseHookResult } from "../../hooks.js";
 import { runtimeActorId } from "../actor-ids.js";
 import { validateJsonSchemaSource } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
 import { emit, runtimeSystemId } from "../events/events.js";
 import "../events/index.js";
 import { CommandExecutor, CommandExecutorLive } from "../services/command-executor-service.js";
+import { parseHookResult } from "../../hooks.js";
 import { Effect } from "effect";
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";

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

@@ -1,6 +1,7 @@
-import { isRecord, parseJson, parseJsonRecord } from "../../safe-json.js";
 import { standardOutputSchemaJson, standardOutputSchemaNameFromPath } from "../../standard-output-schemas.js";
-import { existsSync, readFileSync } from "node:fs";
+import { isRecord, parseJson, parseJsonRecord } from "../../safe-json.js";
+import { FileSystemService, FileSystemServiceLive, runFileSystemSync } from "../services/file-system-service.js";
+import { Effect } from "effect";
 import { join } from "node:path";
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
@@ -25,32 +26,45 @@ function parseRuntimeOutput(format, output) {
 	}
 }
 function validateJsonSchemaSource(source, schemaPath, worktreePath) {
-	try {
-		const schemaSource = readJsonSchemaSource(schemaPath, worktreePath);
-		const value = parseJson(normalizeJsonSource(source), "JSON schema gate value");
-		const validate = compiledJsonSchemaValidator(schemaPath, schemaSource);
-		const errors = validate(value) ? [] : formatJsonSchemaErrors(validate.errors ?? []);
-		return {
-			evidence: errors.length === 0 ? [`JSON schema passed: ${schemaPath}`] : errors.map((error) => `schema: ${error}`),
-			passed: errors.length === 0,
-			reason: errors.length === 0 ? void 0 : "JSON schema validation failed"
-		};
-	} catch (err) {
-		return {
-			evidence: [err instanceof Error ? err.message : String(err)],
-			passed: false,
-			reason: "JSON schema validation failed"
-		};
-	}
+	return runFileSystemSync(validateJsonSchemaSourceEffect(source, schemaPath, worktreePath), FileSystemServiceLive);
+}
+function validateJsonSchemaSourceEffect(source, schemaPath, worktreePath) {
+	return Effect.catchAll(Effect.gen(function* () {
+		const schemaSource = yield* readJsonSchemaSourceEffect(schemaPath, worktreePath);
+		return yield* Effect.try({
+			try: () => validateJsonSchemaValue(source, schemaPath, schemaSource),
+			catch: (error) => error
+		});
+	}), (error) => Effect.succeed(jsonSchemaValidationFailure(error)));
+}
+function validateJsonSchemaValue(source, schemaPath, schemaSource) {
+	const value = parseJson(normalizeJsonSource(source), "JSON schema gate value");
+	const validate = compiledJsonSchemaValidator(schemaPath, schemaSource);
+	return jsonSchemaValidationSuccess(schemaPath, validate(value) ? [] : formatJsonSchemaErrors(validate.errors ?? []));
+}
+function jsonSchemaValidationSuccess(schemaPath, errors) {
+	return {
+		evidence: jsonSchemaValidationEvidence(schemaPath, errors),
+		passed: errors.length === 0,
+		reason: errors.length === 0 ? void 0 : "JSON schema validation failed"
+	};
+}
+function jsonSchemaValidationEvidence(schemaPath, errors) {
+	return errors.length === 0 ? [`JSON schema passed: ${schemaPath}`] : errors.map((error) => `schema: ${error}`);
 }
 function normalizeJsonSource(source) {
 	const trimmed = source.trim();
 	return MARKDOWN_JSON_FENCE_RE.exec(trimmed)?.[1].trim() ?? trimmed;
 }
 function readJsonSchemaSource(schemaPath, worktreePath) {
+	return runFileSystemSync(readJsonSchemaSourceEffect(schemaPath, worktreePath), FileSystemServiceLive);
+}
+function readJsonSchemaSourceEffect(schemaPath, worktreePath) {
 	const standardName = standardOutputSchemaNameFromPath(schemaPath);
-	if (standardName) return standardOutputSchemaJson(standardName);
-	return readFileSync(join(worktreePath, schemaPath), "utf8");
+	if (standardName) return Effect.succeed(standardOutputSchemaJson(standardName));
+	return Effect.gen(function* () {
+		return yield* (yield* FileSystemService).readText(join(worktreePath, schemaPath));
+	});
 }
 function compiledJsonSchemaValidator(schemaPath, schemaSource) {
 	const cached = jsonSchemaValidatorCache.get(schemaPath);
@@ -68,8 +82,20 @@ function isJsonSchema(value) {
 	return typeof value === "boolean" || isRecord(value);
 }
 function readOptionalFile(path) {
-	if (!existsSync(path)) return null;
-	return readFileSync(path, "utf8");
+	return runFileSystemSync(readOptionalFileEffect(path), FileSystemServiceLive);
+}
+function readOptionalFileEffect(path) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystemService;
+		return (yield* fileSystem.exists(path)) ? yield* fileSystem.readText(path) : null;
+	});
+}
+function jsonSchemaValidationFailure(error) {
+	return {
+		evidence: [error instanceof Error ? error.message : String(error)],
+		passed: false,
+		reason: "JSON schema validation failed"
+	};
 }
 function formatJsonSchemaErrors(errors) {
 	return errors.map((error) => {

package/dist/runtime/local-scheduler.js

@@ -1,6 +1,11 @@
-import { runWorkflowLifecycle } from "./workflow-lifecycle.js";
 import { runWorkflowScheduler } from "./scheduler.js";
+import { runWorkflowLifecycle } from "./workflow-lifecycle.js";
+import { Context, Effect, Layer } from "effect";
 //#region src/runtime/local-scheduler.ts
+var LocalSchedulerOptionsService = class extends Context.Tag("LocalSchedulerOptionsService")() {};
+function localSchedulerOptionsLive(options) {
+	return Layer.succeed(LocalSchedulerOptionsService, options);
+}
 /**
 * The local, in-process scheduler seam. It owns workflow lifecycle hooks and
 * delegates the topological fan-out/gating loop to `runWorkflowScheduler`,
@@ -14,32 +19,50 @@ var LocalScheduler = class {
 	async runWorkflow(plan, context) {
 		const options = this.options;
 		if (!options) throw new Error("LocalScheduler requires runtime options to run workflow");
-		return (await runWorkflowLifecycle({
-			buildResult: options.buildResult,
-			emitWorkflowPlanned: () => options.emitWorkflowPlanned(context),
-			emitWorkflowStarted: () => options.emitWorkflowStarted(context),
-			executeWorkflow: () => runWorkflowScheduler({
-				failFast: plan.execution.failFast,
-				fanOutWidth: context.config.token_budget?.fan_out_width,
-				isCancelled: () => options.isCancelled(context),
-				journal: options.resolveJournal?.(context),
-				markNodeReady: (nodeId) => options.markNodeReady(nodeId, context),
-				maxParallelNodes: context.maxParallelNodes,
-				nodes: plan.topologicalOrder.map((node) => ({
-					category: node.category,
-					dependents: node.dependents,
-					id: node.id,
-					index: node.index,
-					needs: node.needs
-				})),
-				runNode: (nodeId) => options.executeNode(nodeId, context),
-				shouldContinueAfterNodeResult: (result) => options.shouldContinueAfterNodeResult(result, context),
-				skipNode: (nodeId, reason) => options.skipNode(nodeId, reason, context)
-			}),
-			isCancelled: () => options.isCancelled(context),
-			runWorkflowHook: (event, failure) => options.runWorkflowHook(event, failure, context)
-		})).result;
+		return await Effect.runPromise(Effect.provide(runLocalWorkflowEffect(plan, context), localSchedulerOptionsLive(options)));
 	}
 };
+function runLocalWorkflowEffect(plan, context) {
+	return Effect.gen(function* () {
+		const options = yield* LocalSchedulerOptionsService;
+		return (yield* Effect.tryPromise({
+			catch: (error) => error,
+			try: () => runWorkflowLifecycle(lifecycleInput(plan, context, options))
+		})).result;
+	});
+}
+function lifecycleInput(plan, context, options) {
+	return {
+		buildResult: options.buildResult,
+		emitWorkflowPlanned: () => options.emitWorkflowPlanned(context),
+		emitWorkflowStarted: () => options.emitWorkflowStarted(context),
+		executeWorkflow: () => runWorkflowScheduler(schedulerInput(plan, context, options)),
+		isCancelled: () => options.isCancelled(context),
+		runWorkflowHook: (event, failure) => options.runWorkflowHook(event, failure, context)
+	};
+}
+function schedulerInput(plan, context, options) {
+	return {
+		failFast: plan.execution.failFast,
+		fanOutWidth: context.config.token_budget?.fan_out_width,
+		isCancelled: () => options.isCancelled(context),
+		journal: options.resolveJournal?.(context),
+		markNodeReady: (nodeId) => options.markNodeReady(nodeId, context),
+		maxParallelNodes: context.maxParallelNodes,
+		nodes: plan.topologicalOrder.map(scheduleNode),
+		runNode: (nodeId) => options.executeNode(nodeId, context),
+		shouldContinueAfterNodeResult: (result) => options.shouldContinueAfterNodeResult(result, context),
+		skipNode: (nodeId, reason) => options.skipNode(nodeId, reason, context)
+	};
+}
+function scheduleNode(node) {
+	return {
+		category: node.category,
+		dependents: node.dependents,
+		id: node.id,
+		index: node.index,
+		needs: node.needs
+	};
+}
 //#endregion
 export { LocalScheduler };