@oisincoveney/pipeline 3.24.2 → 4.0.0

package/dist/remote/submit/event-boundary.js

@@ -1,81 +1,69 @@
 import { MOKA_SUBMIT_HOOK_EVENTS } from "./hook-events.js";
+import * as Option$1 from "effect/Option";
 //#region src/remote/submit/event-boundary.ts
 const submitHookId = (event) => `moka-submit-${event.replaceAll(".", "-")}`;
-function hookFunctionForSubmitHook(hook) {
-	return hook.kind === "module" ? moduleHookFunctionForSubmitHook(hook) : commandHookFunctionForSubmitHook(hook);
-}
-function moduleHookFunctionForSubmitHook(hook) {
-	const hookFunction = {
-		kind: "module",
-		module: hook.module
-	};
-	if (hook.timeoutMs !== void 0) hookFunction.timeout_ms = hook.timeoutMs;
-	return hookFunction;
-}
-function commandHookFunctionForSubmitHook(hook) {
-	const hookFunction = {
-		command: hook.command,
-		kind: "command",
-		protocol: {
-			input: "file",
-			result: "file"
-		}
-	};
-	if (hook.outputLimitBytes !== void 0) hookFunction.output_limit_bytes = hook.outputLimitBytes;
-	if (hook.timeoutMs !== void 0) hookFunction.timeout_ms = hook.timeoutMs;
-	if (hook.trusted !== void 0) hookFunction.trusted = hook.trusted;
-	return hookFunction;
-}
-function submitHookBindingResult(hook) {
-	if (!submitHookHasResult(hook)) return;
-	const result = {};
-	addSubmitHookResultFields(result, hook);
-	return result;
-}
-function submitHookHasResult(hook) {
-	return hook.publishResult !== void 0 || hook.saveResultAs !== void 0;
-}
-function addSubmitHookResultFields(result, hook) {
-	if (hook.publishResult !== void 0) result.publish = hook.publishResult;
-	if (hook.saveResultAs !== void 0) result.save_as = hook.saveResultAs;
-}
-function hookBindingForSubmitHook(event, hook) {
+const moduleHookFunctionForSubmitHook = (hook) => ({
+	kind: "module",
+	module: hook.module,
+	...hook.timeoutMs !== void 0 ? { timeout_ms: hook.timeoutMs } : {}
+});
+const commandHookFunctionForSubmitHook = (hook) => ({
+	command: hook.command,
+	kind: "command",
+	...hook.outputLimitBytes !== void 0 ? { output_limit_bytes: hook.outputLimitBytes } : {},
+	protocol: {
+		input: "file",
+		result: "file"
+	},
+	...hook.timeoutMs !== void 0 ? { timeout_ms: hook.timeoutMs } : {},
+	...hook.trusted !== void 0 ? { trusted: hook.trusted } : {}
+});
+const hookFunctionForSubmitHook = (hook) => hook.kind === "module" ? moduleHookFunctionForSubmitHook(hook) : commandHookFunctionForSubmitHook(hook);
+const submitHookHasResult = (hook) => hook.publishResult !== void 0 || hook.saveResultAs !== void 0;
+const addSubmitHookResultFields = (hook) => ({
+	...hook.publishResult !== void 0 ? { publish: hook.publishResult } : {},
+	...hook.saveResultAs !== void 0 ? { save_as: hook.saveResultAs } : {}
+});
+const submitHookBindingResult = (hook) => {
+	if (!submitHookHasResult(hook)) return Option$1.none();
+	return Option$1.some(addSubmitHookResultFields(hook));
+};
+const hookBindingForSubmitHook = (event, hook) => {
 	const id = submitHookId(event);
-	const binding = {
+	const result = submitHookBindingResult(hook);
+	return {
 		failure: hook.failure,
 		function: id,
-		id
+		id,
+		...Option$1.isSome(result) ? { result: result.value } : {},
+		...hook.where !== void 0 ? { where: hook.where } : {},
+		...hook.input !== void 0 ? { with: hook.input } : {}
 	};
-	const result = submitHookBindingResult(hook);
-	if (result !== void 0) binding.result = result;
-	if (hook.where !== void 0) binding.where = hook.where;
-	if (hook.input !== void 0) binding.with = hook.input;
-	return binding;
-}
-function submitHookEntries(hooks) {
+};
+const submitHookEntries = (hooks) => {
 	const entries = [];
 	for (const event of MOKA_SUBMIT_HOOK_EVENTS) {
-		const hook = hooks?.[event];
+		const hook = Option$1.isSome(hooks) ? hooks.value[event] : void 0;
 		if (hook !== void 0) entries.push({
 			event,
 			hook
 		});
 	}
 	return entries;
-}
-function cloneHookBindings(on) {
+};
+const cloneHookBindings = (on) => {
 	const cloned = {};
 	for (const [event, bindings] of Object.entries(on)) cloned[event] = [...bindings];
 	return cloned;
-}
-function appendSubmitHook(event, hook, target) {
+};
+const appendSubmitHook = (event, hook, target) => {
 	const id = submitHookId(event);
-	if (target.functions[id] !== void 0) throw new Error(`Moka submit hook id already exists in config: ${id}`);
+	if (Object.hasOwn(target.functions, id)) throw new Error(`Moka submit hook id already exists in config: ${id}`);
 	target.functions[id] = hookFunctionForSubmitHook(hook);
 	target.on[event] = [...target.on[event] ?? [], hookBindingForSubmitHook(event, hook)];
-}
-function configWithSubmitHooks(config, hooks) {
-	const entries = submitHookEntries(hooks);
+};
+const configWithSubmitHooks = (config, hooks) => {
+	const entries = submitHookEntries(Option$1.fromUndefinedOr(hooks));
 	if (entries.length === 0) return config;
 	const target = {
 		functions: { ...config.hooks.functions },
@@ -90,29 +78,27 @@ function configWithSubmitHooks(config, hooks) {
 			on: target.on
 		}
 	};
-}
-function runnerEvents(options) {
-	const eventSink = options.eventSink ?? options.events;
-	return eventSink ? runnerEventsFromSink(options, eventSink) : runnerEventsFromUrl(options);
-}
-function runnerEventsFromSink(options, eventSink) {
-	return {
-		authHeader: eventSink.authHeader,
-		authTokenFile: eventSink.authTokenFile ?? eventAuthTokenFile(options),
-		url: eventSink.url
-	};
-}
-function runnerEventsFromUrl(options) {
-	if (!options.eventUrl) throw new Error("eventUrl is required unless eventSink or events is provided");
+};
+const eventAuthTokenFile = (options) => {
+	if (options.eventAuthSecretKey === void 0 || options.eventAuthSecretKey.length === 0) throw new Error("eventAuthSecretKey is required unless eventSink.authTokenFile is provided");
+	return `/etc/pipeline/event-auth/${options.eventAuthSecretKey}`;
+};
+const runnerEventsFromSink = (options, eventSink) => ({
+	authHeader: eventSink.authHeader,
+	authTokenFile: eventSink.authTokenFile ?? eventAuthTokenFile(options),
+	url: eventSink.url
+});
+const runnerEventsFromUrl = (options) => {
+	if (options.eventUrl === void 0 || options.eventUrl.length === 0) throw new Error("eventUrl is required unless eventSink or events is provided");
 	return {
 		authHeader: "Authorization",
 		authTokenFile: eventAuthTokenFile(options),
 		url: options.eventUrl
 	};
-}
-function eventAuthTokenFile(options) {
-	if (!options.eventAuthSecretKey) throw new Error("eventAuthSecretKey is required unless eventSink.authTokenFile is provided");
-	return `/etc/pipeline/event-auth/${options.eventAuthSecretKey}`;
-}
+};
+const runnerEvents = (options) => {
+	const eventSink = options.eventSink ?? options.events;
+	return eventSink === void 0 ? runnerEventsFromUrl(options) : runnerEventsFromSink(options, eventSink);
+};
 //#endregion
 export { configWithSubmitHooks, runnerEvents };

package/dist/remote/submit/hook-events.d.ts

@@ -0,0 +1,6 @@
+import { HookEvent } from "../../config/schemas.js";
+import "../../config.js";
+//#region src/remote/submit/hook-events.d.ts
+declare const MOKA_SUBMIT_HOOK_EVENTS: readonly [HookEvent, ...HookEvent[]];
+//#endregion
+export { MOKA_SUBMIT_HOOK_EVENTS };

package/dist/remote/submit/io.d.ts

@@ -1,3 +1,5 @@
+import { RunnerRepositoryContext, RunnerRunIdentity } from "../../runner-command-contract.js";
+import "../../moka-submit.js";
 //#region src/remote/submit/io.d.ts
 interface MokaGitContext {
   baseBranch: string;
@@ -5,9 +7,13 @@ interface MokaGitContext {
   sha: string;
   url: string;
 }
+interface MokaSubmissionContext {
+  repository: RunnerRepositoryContext;
+  run: RunnerRunIdentity;
+}
 interface MokaSubmitIoDependencies {
   readFile?: (path: string) => string;
   resolveGitContext?: (worktreePath: string) => Promise<MokaGitContext>;
 }
 //#endregion
-export { MokaSubmitIoDependencies };
+export { MokaSubmissionContext, MokaSubmitIoDependencies };

package/dist/remote/submit/io.js

@@ -1,52 +1,34 @@
 import { normalizeRunnerRepositoryForSubmit } from "../../git-remote-url.js";
 import { readFileSync } from "node:fs";
+import { Option } from "effect";
 import { simpleGit as simpleGit$1 } from "simple-git";
 import parseGitUrl from "git-url-parse";
 //#region src/remote/submit/io.ts
-function readScheduleFile(dependencies, path) {
-	return (dependencies.readFile ?? ((filePath) => readFileSync(filePath, "utf8")))(path);
-}
-async function resolveSubmissionContext(options, dependencies, runId) {
-	const explicitContext = explicitSubmissionContext(options);
-	if (explicitContext) return explicitContext;
-	const git = await resolveRequiredGit(options, dependencies);
-	const repository = repositoryContext(options, git);
-	assertRepositoryCredentialConfiguration(options);
-	return {
-		repository,
-		run: runContext(options, git, runId)
-	};
-}
-function explicitSubmissionContext(options) {
-	if (!(options.repository && options.run)) return null;
+const readScheduleFile = (dependencies, path) => {
+	return (dependencies.readFile ?? ((filePath) => readFileSync(filePath, "utf-8")))(path);
+};
+const repositoryContext = (options, git) => normalizeRunnerRepositoryForSubmit(options.repository ?? {
+	baseBranch: git.baseBranch,
+	sha: git.sha,
+	url: git.url
+});
+const assertRepositoryCredentialConfiguration = (options) => {
+	if (options.gitCredentialsSecretName === void 0 || options.gitCredentialsSecretName.length === 0) throw new Error("gitCredentialsSecretName is required for runner git clone, fetch, and push operations");
+};
+const explicitSubmissionContext = (options) => {
+	if (options.repository === void 0 || options.run === void 0) return Option.none();
 	assertRepositoryCredentialConfiguration(options);
-	return {
+	return Option.some({
 		repository: normalizeRunnerRepositoryForSubmit(options.repository),
 		run: options.run
-	};
-}
-function resolveRequiredGit(options, dependencies) {
-	if (!options.worktreePath) throw new Error("worktreePath is required when moka submit must resolve repository or run context");
-	return resolveGit(options.worktreePath, dependencies);
-}
-function repositoryContext(options, git) {
-	return normalizeRunnerRepositoryForSubmit(options.repository ?? {
-		baseBranch: git.baseBranch,
-		sha: git.sha,
-		url: git.url
 	});
-}
-function assertRepositoryCredentialConfiguration(options) {
-	if (!options.gitCredentialsSecretName) throw new Error("gitCredentialsSecretName is required for runner git clone, fetch, and push operations");
-}
-function runContext(options, git, runId) {
-	return options.run ?? {
-		id: runId,
-		project: git.project
-	};
-}
-async function resolveGit(worktreePath, dependencies) {
-	if (dependencies.resolveGitContext) return dependencies.resolveGitContext(worktreePath);
+};
+const runContext = (options, git, runId) => options.run ?? {
+	id: runId,
+	project: git.project
+};
+const resolveGit = async (worktreePath, dependencies) => {
+	if (dependencies.resolveGitContext !== void 0) return await dependencies.resolveGitContext(worktreePath);
 	const git = simpleGit$1({ baseDir: worktreePath });
 	const [branchResult, sha, remoteConfig] = await Promise.all([
 		git.branch(),
@@ -54,13 +36,28 @@ async function resolveGit(worktreePath, dependencies) {
 		git.getConfig("remote.origin.url")
 	]);
 	const url = remoteConfig.value;
-	if (!url) throw new Error("Could not resolve git remote origin URL. Ensure the repository has a remote configured.");
+	if (url === null || url.length === 0) throw new Error("Could not resolve git remote origin URL. Ensure the repository has a remote configured.");
 	return {
 		baseBranch: branchResult.current,
-		project: parseGitUrl(url).name || "unknown",
+		project: parseGitUrl(url).name.length > 0 ? parseGitUrl(url).name : "unknown",
 		sha: sha.trim(),
 		url
 	};
-}
+};
+const resolveRequiredGit = async (options, dependencies) => {
+	if (options.worktreePath === void 0 || options.worktreePath.length === 0) throw new Error("worktreePath is required when moka submit must resolve repository or run context");
+	return await resolveGit(options.worktreePath, dependencies);
+};
+const resolveSubmissionContext = async (options, dependencies, runId) => {
+	const explicitContext = explicitSubmissionContext(options);
+	if (Option.isSome(explicitContext)) return explicitContext.value;
+	const git = await resolveRequiredGit(options, dependencies);
+	const repository = repositoryContext(options, git);
+	assertRepositoryCredentialConfiguration(options);
+	return {
+		repository,
+		run: runContext(options, git, runId)
+	};
+};
 //#endregion
 export { readScheduleFile, resolveSubmissionContext };

package/dist/remote/submit/jobs-submission.d.ts

@@ -0,0 +1,59 @@
+import { PlannedWorkflowNode } from "../../planning/compile.js";
+import "./jobs-submit-result.js";
+import { JobOwnerReference } from "../jobs/model.js";
+import { KubernetesJobsIoDependencies } from "../../runtime/services/kubernetes-jobs-service.js";
+import { RunSpecRegistry } from "../jobs/run-spec-server.js";
+import { CompiledMokaSubmitPlan } from "./compilation.js";
+import { MokaSubmissionContext } from "./io.js";
+import { SubmitRunnerNodeJobsOptions, SubmittedNodeJob } from "../jobs/submit.js";
+import { ParsedMokaBaseOptions } from "../../moka-submit.js";
+import { RunSpec } from "@oisin-ee/yeet-api";
+//#region src/remote/submit/jobs-submission.d.ts
+/**
+ * Whole-run Jobs submission (doc-1 decision 3, ENG-56) — the replacement for the
+ * retired Argo whole-run submission. It turns a COMPILED multi-node schedule into
+ * a dependency-ordered wave of per-node `batch/v1` Jobs through the ENG-18 Jobs
+ * transport, and registers each node's self-contained {@link RunSpec} with the
+ * coordinator's serving side so the node's pod fetches it at start (no per-run
+ * ConfigMap). The waves are the planner's `parallelBatches` (a topological
+ * grouping), so Jobs are created dependency-order — every node in a wave depends
+ * only on nodes in earlier waves. Finalization is the ENG-19 reconcile/watch
+ * loop, keyed on the run-id label these Jobs carry.
+ *
+ * Dynamic scheduling (a graph planned INSIDE the pod, no schedule at submit) has
+ * no node ids to wave at submit time; it is a coordinator-runtime concern (plan,
+ * then submit waves) and is rejected here with a typed error rather than guessed.
+ */
+/** Injectable per-wave Job submit — defaults to the ENG-18 {@link submitRunnerNodeJobs}. */
+type NodeJobsSubmit = (options: SubmitRunnerNodeJobsOptions, dependencies: KubernetesJobsIoDependencies) => Promise<readonly SubmittedNodeJob[]>;
+/** Injectable per-node RunSpec builder — the coordinator's projection of a
+ * planned node onto the yeet run contract. Defaults to {@link defaultBuildNodeRunSpec}. */
+type BuildNodeRunSpec = (input: {
+  context: MokaSubmissionContext;
+  node: PlannedWorkflowNode;
+  nodeCwd: string;
+  plan: CompiledMokaSubmitPlan;
+}) => RunSpec;
+interface SubmitCompiledMokaJobsInput {
+  readonly buildRunSpec?: BuildNodeRunSpec;
+  readonly context: MokaSubmissionContext;
+  /** Secret names projected into each runner container via `envFrom` (ENG-18 AC#3). */
+  readonly envFromSecretNames: readonly string[];
+  /** Cluster client injection for the Jobs transport (tests pass a fake `batchApi`). */
+  readonly jobsDependencies?: KubernetesJobsIoDependencies;
+  /** Working directory each node's pod runs yeet in (the in-pod clone path). */
+  readonly nodeCwd?: string;
+  readonly options: ParsedMokaBaseOptions;
+  /** Run-scoped owner every Job points at so a run's Jobs GC together. */
+  readonly ownerReference: JobOwnerReference;
+  readonly plan: CompiledMokaSubmitPlan;
+  /** The serving side each node's pod fetches its RunSpec from. */
+  readonly registry: RunSpecRegistry;
+  /** Base URL of the coordinator RunSpec API the pods fetch from. */
+  readonly runSpecBaseUrl: string;
+  readonly submitNodeJobs?: NodeJobsSubmit;
+  /** Optional project root for schedule compilation (lint file resolution). */
+  readonly worktreePath?: string;
+}
+//#endregion
+export { BuildNodeRunSpec, NodeJobsSubmit, SubmitCompiledMokaJobsInput };

package/dist/remote/submit/jobs-submission.js

@@ -0,0 +1,97 @@
+import { compileScheduleArtifact, parseScheduleArtifact } from "../../planning/generate.js";
+import { submitRunnerNodeJobs } from "../jobs/submit.js";
+import { parseJobsSubmitResult } from "./jobs-submit-result.js";
+//#region src/remote/submit/jobs-submission.ts
+var DynamicScheduleJobsSubmitError = class extends Error {
+	constructor(runId) {
+		super(`Run ${runId} has no compiled schedule; the Jobs transport waves a compiled multi-node schedule. Dynamic (in-pod planned) scheduling must plan first, then submit waves.`);
+		this.name = "DynamicScheduleJobsSubmitError";
+	}
+};
+const requireSubmitNamespace = (options) => {
+	if (options.namespace === void 0 || options.namespace.length === 0) throw new Error("namespace is required for moka submit");
+	return options.namespace;
+};
+const requireCompiledSchedule = (plan) => {
+	if (plan.dynamicScheduling || plan.scheduleYaml === void 0 || plan.scheduleYaml.length === 0) throw new DynamicScheduleJobsSubmitError(plan.runId);
+	return plan.scheduleYaml;
+};
+const taskPromptText = (task) => {
+	if (task.kind === "prompt") return task.prompt;
+	return task.title !== void 0 && task.title.length > 0 ? `${task.id} ${task.title}` : task.id;
+};
+/**
+* Default projection of a planned node onto a {@link RunSpec}. The prompt is the
+* node's own task-context description when present (its slice of the work), else
+* the run's task. The harness is `opencode` — the executor seam the Jobs
+* transport runs (see `remote/jobs/node-bootstrap`); refining per-node harness
+* resolution from the node's profile is left to the injectable builder.
+*/
+const defaultBuildNodeRunSpec = ({ node, nodeCwd, plan }) => ({
+	cwd: nodeCwd,
+	harness: "opencode",
+	name: node.id,
+	prompt: node.taskContext?.description ?? taskPromptText(plan.task)
+});
+const waveNodeSpecs = (input, waves) => {
+	const buildRunSpec = input.buildRunSpec ?? defaultBuildNodeRunSpec;
+	const nodeCwd = input.nodeCwd ?? "/workspace";
+	return Object.fromEntries(waves.flatMap((wave) => wave.map((node) => [node.id, buildRunSpec({
+		context: input.context,
+		node,
+		nodeCwd,
+		plan: input.plan
+	})])));
+};
+const sharedJobOptions = (input, namespace) => ({
+	envFromSecretNames: [...input.envFromSecretNames],
+	namespace,
+	ownerReference: input.ownerReference,
+	runId: input.plan.runId,
+	runSpecBaseUrl: input.runSpecBaseUrl,
+	generateName: input.plan.generateName,
+	imagePullPolicy: input.options.imagePullPolicy,
+	workflowId: input.plan.workflowId,
+	...input.options.image === void 0 ? {} : { image: input.options.image },
+	...input.options.imagePullSecretName === void 0 ? {} : { imagePullSecretName: input.options.imagePullSecretName },
+	...input.options.serviceAccountName === void 0 ? {} : { serviceAccountName: input.options.serviceAccountName },
+	...input.options.activeDeadlineSeconds === void 0 ? {} : { activeDeadlineSeconds: input.options.activeDeadlineSeconds }
+});
+/**
+* Submit a compiled run as dependency-ordered waves of per-node Jobs, serving
+* each node's RunSpec from the coordinator registry. Waves are submitted in
+* topological order (a wave's Jobs are created only after all earlier waves'),
+* so the sequence of cluster writes respects the dependency graph. Returns the
+* created Job identities plus the wave structure, validated through the result
+* schema at the boundary.
+*/
+const submitCompiledMokaJobs = async (input) => {
+	const scheduleYaml = requireCompiledSchedule(input.plan);
+	const namespace = requireSubmitNamespace(input.options);
+	const waves = compileScheduleArtifact(input.plan.config, parseScheduleArtifact(scheduleYaml, "schedule.yaml"), input.worktreePath).plan.parallelBatches;
+	input.registry.register({
+		runId: input.plan.runId,
+		specs: waveNodeSpecs(input, waves)
+	});
+	const submitNodeJobs = input.submitNodeJobs ?? submitRunnerNodeJobs;
+	const shared = sharedJobOptions(input, namespace);
+	const jobsDependencies = input.jobsDependencies ?? {};
+	const submittedWaves = [];
+	for (const wave of waves) {
+		const submitted = await submitNodeJobs({
+			...shared,
+			nodeIds: wave.map((node) => node.id)
+		}, jobsDependencies);
+		submittedWaves.push([...submitted]);
+	}
+	return parseJobsSubmitResult({
+		jobs: submittedWaves.flat(),
+		namespace,
+		runId: input.plan.runId,
+		waves: waves.map((wave) => ({ nodeIds: wave.map((node) => node.id) })),
+		workflowName: input.plan.workflowId,
+		...input.ownerReference.uid.length === 0 ? {} : { workflowUid: input.ownerReference.uid }
+	});
+};
+//#endregion
+export { DynamicScheduleJobsSubmitError, defaultBuildNodeRunSpec, requireCompiledSchedule, requireSubmitNamespace, sharedJobOptions, submitCompiledMokaJobs };

package/dist/remote/submit/jobs-submit-result.d.ts

@@ -0,0 +1,25 @@
+import * as Schema from "effect/Schema";
+//#region src/remote/submit/jobs-submit-result.d.ts
+declare const jobsSubmitResultSchema: Schema.Struct<{
+  readonly jobs: Schema.mutable<Schema.$Array<Schema.Struct<{
+    readonly jobName: Schema.NonEmptyString;
+    readonly namespace: Schema.NonEmptyString;
+    readonly nodeId: Schema.NonEmptyString;
+    /** ENG-57.6: true when the node's Job was OBSERVED (already existed) rather than
+     * freshly created — the idempotent replay/restart path of create-or-observe. */
+    readonly observed: Schema.optional<Schema.Boolean>;
+    readonly uid: Schema.optional<Schema.NonEmptyString>;
+  }>>>;
+  readonly namespace: Schema.NonEmptyString;
+  readonly runId: Schema.NonEmptyString;
+  readonly waves: Schema.mutable<Schema.$Array<Schema.Struct<{
+    readonly nodeIds: Schema.mutable<Schema.$Array<Schema.NonEmptyString>>;
+  }>>>;
+  /** The run's schedule workflow id — the run handle the loop controller polls. */
+  readonly workflowName: Schema.NonEmptyString;
+  /** The run-scoped owner uid, when the coordinator supplied one. */
+  readonly workflowUid: Schema.optional<Schema.NonEmptyString>;
+}>;
+type MokaJobsSubmitOutput = typeof jobsSubmitResultSchema.Type;
+//#endregion
+export { MokaJobsSubmitOutput, jobsSubmitResultSchema };

package/dist/remote/submit/jobs-submit-result.js

@@ -0,0 +1,34 @@
+import { mutableArray, parseStrictWithSchema, requiredString, struct } from "../../schema-boundary.js";
+import * as Schema from "effect/Schema";
+//#region src/remote/submit/jobs-submit-result.ts
+/**
+* The Jobs whole-run submission result (doc-1 decision 3, ENG-56) — what
+* `submitCompiledMokaJobs` returns and the value `submitParsedMoka` yields on the
+* Jobs path. It replaces the Argo `workflowSubmitResultSchema`, dropping the
+* per-run ConfigMap names (there are none) and adding the created per-node Job
+* identities and the wave structure. `workflowName` and `namespace` are retained
+* (the loop controller and CLI print them) so downstream consumers are unchanged.
+*/
+const submittedNodeJobResultSchema = struct({
+	jobName: requiredString,
+	namespace: requiredString,
+	nodeId: requiredString,
+	/** ENG-57.6: true when the node's Job was OBSERVED (already existed) rather than
+	* freshly created — the idempotent replay/restart path of create-or-observe. */
+	observed: Schema.optional(Schema.Boolean),
+	uid: Schema.optional(requiredString)
+});
+const jobsSubmitWaveSchema = struct({ nodeIds: mutableArray(requiredString) });
+const jobsSubmitResultSchema = struct({
+	jobs: mutableArray(submittedNodeJobResultSchema),
+	namespace: requiredString,
+	runId: requiredString,
+	waves: mutableArray(jobsSubmitWaveSchema),
+	/** The run's schedule workflow id — the run handle the loop controller polls. */
+	workflowName: requiredString,
+	/** The run-scoped owner uid, when the coordinator supplied one. */
+	workflowUid: Schema.optional(requiredString)
+});
+const parseJobsSubmitResult = (value) => parseStrictWithSchema(jobsSubmitResultSchema, value);
+//#endregion
+export { jobsSubmitResultSchema, parseJobsSubmitResult };

package/dist/remote/submit/options.d.ts

@@ -0,0 +1,49 @@
+import * as Schema from "effect/Schema";
+//#region src/remote/submit/options.d.ts
+declare const runnerPodSubmitOptionShape: {
+  activeDeadlineSeconds: Schema.optional<Schema.Number>;
+  brokerAuth: Schema.Struct<{
+    readonly secretKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+    readonly secretName: Schema.NonEmptyString;
+    readonly url: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+  }>;
+  dbAuth: Schema.optional<Schema.Struct<{
+    readonly secretKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+    readonly secretName: Schema.NonEmptyString;
+  }>>;
+  eventAuthSecretKey: Schema.optional<Schema.NonEmptyString>;
+  eventAuthSecretName: Schema.optional<Schema.NonEmptyString>;
+  generateName: Schema.optional<Schema.NonEmptyString>;
+  gitCredentialsSecretName: Schema.optional<Schema.NonEmptyString>;
+  githubAuthSecretName: Schema.optional<Schema.NonEmptyString>;
+  image: Schema.optional<Schema.NonEmptyString>;
+  imagePullSecretName: Schema.optional<Schema.NonEmptyString>;
+  kubeContext: Schema.optional<Schema.NonEmptyString>;
+  kubeconfigPath: Schema.optional<Schema.NonEmptyString>;
+  mcpGatewayAuth: Schema.optional<Schema.Struct<{
+    readonly secretKey: Schema.withDecodingDefault<Schema.NonEmptyString, never>;
+    readonly secretName: Schema.NonEmptyString;
+  }>>;
+  name: Schema.optional<Schema.NonEmptyString>;
+  npmRegistryAuthSecretName: Schema.optional<Schema.NonEmptyString>;
+  podGC: Schema.optional<Schema.Struct<{
+    readonly deleteDelayDuration: Schema.optional<Schema.NonEmptyString>;
+    readonly labelSelector: Schema.optional<Schema.Struct<{
+      readonly matchExpressions: Schema.optional<Schema.mutable<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly operator: Schema.Literals<readonly ["In", "NotIn", "Exists", "DoesNotExist"]>;
+        readonly values: Schema.optional<Schema.mutable<Schema.$Array<Schema.String>>>;
+      }>>>>;
+      readonly matchLabels: Schema.optional<Schema.$Record<Schema.NonEmptyString, Schema.String>>;
+    }>>;
+    readonly strategy: Schema.optional<Schema.Literals<readonly ["OnPodCompletion", "OnPodSuccess", "OnWorkflowCompletion", "OnWorkflowSuccess"]>>;
+  }>>;
+  serviceAccountName: Schema.optional<Schema.NonEmptyString>;
+  ttlStrategy: Schema.optional<Schema.Struct<{
+    readonly secondsAfterCompletion: Schema.optional<Schema.Number>;
+    readonly secondsAfterFailure: Schema.optional<Schema.Number>;
+    readonly secondsAfterSuccess: Schema.optional<Schema.Number>;
+  }>>;
+};
+//#endregion
+export { runnerPodSubmitOptionShape };

package/dist/remote/submit/options.js

@@ -0,0 +1,27 @@
+import { requiredString } from "../../schema-boundary.js";
+import { argoWorkflowActiveDeadlineSecondsSchema, argoWorkflowPodGcSchema, argoWorkflowTtlStrategySchema, dbAuthOptionSchema, mcpGatewayAuthOptionSchema } from "../argo/model.js";
+import { brokerAuthOptionSchema } from "../../credentials/broker.js";
+import * as Schema from "effect/Schema";
+//#region src/remote/submit/options.ts
+const runnerPodSubmitOptionShape = {
+	activeDeadlineSeconds: Schema.optional(argoWorkflowActiveDeadlineSecondsSchema),
+	brokerAuth: brokerAuthOptionSchema,
+	dbAuth: Schema.optional(dbAuthOptionSchema),
+	eventAuthSecretKey: Schema.optional(requiredString),
+	eventAuthSecretName: Schema.optional(requiredString),
+	generateName: Schema.optional(requiredString),
+	gitCredentialsSecretName: Schema.optional(requiredString),
+	githubAuthSecretName: Schema.optional(requiredString),
+	image: Schema.optional(requiredString),
+	imagePullSecretName: Schema.optional(requiredString),
+	kubeContext: Schema.optional(requiredString),
+	kubeconfigPath: Schema.optional(requiredString),
+	mcpGatewayAuth: Schema.optional(mcpGatewayAuthOptionSchema),
+	name: Schema.optional(requiredString),
+	npmRegistryAuthSecretName: Schema.optional(requiredString),
+	podGC: Schema.optional(argoWorkflowPodGcSchema),
+	serviceAccountName: Schema.optional(requiredString),
+	ttlStrategy: Schema.optional(argoWorkflowTtlStrategySchema)
+};
+//#endregion
+export { runnerPodSubmitOptionShape };