@oisincoveney/pipeline 3.19.4 → 3.19.5

package/dist/argo-submit.d.ts

@@ -26,6 +26,7 @@ declare const submitRunnerArgoWorkflowOptionsSchema: z.ZodObject<{
     Never: "Never";
   }>>;
   imagePullSecretName: z.ZodOptional<z.ZodString>;
+  kubeContext: z.ZodOptional<z.ZodString>;
   kubeconfigPath: z.ZodOptional<z.ZodString>;
   mcpGatewayAuth: z.ZodOptional<z.ZodObject<{
     secretKey: z.ZodDefault<z.ZodString>;
@@ -59,6 +60,7 @@ declare const submitDynamicRunnerArgoWorkflowOptionsSchema: z.ZodObject<{
     Never: "Never";
   }>>;
   imagePullSecretName: z.ZodOptional<z.ZodString>;
+  kubeContext: z.ZodOptional<z.ZodString>;
   kubeconfigPath: z.ZodOptional<z.ZodString>;
   mcpGatewayAuth: z.ZodOptional<z.ZodObject<{
     secretKey: z.ZodDefault<z.ZodString>;

package/dist/argo-submit.js

@@ -43,6 +43,7 @@ const submitRunnerArgoWorkflowBaseOptionShape = {
 		"Never"
 	]).optional(),
 	imagePullSecretName: z.string().min(1).optional(),
+	kubeContext: z.string().min(1).optional(),
 	kubeconfigPath: z.string().min(1).optional(),
 	mcpGatewayAuth: mcpGatewayAuthOptionSchema.optional(),
 	name: z.string().min(1).optional(),
@@ -166,16 +167,16 @@ function submitRunnerArgoWorkflowEffect(rawOptions, dependencies) {
 			namespace: options.namespace,
 			options
 		});
-		return workflowSubmitResult(yield* service.createWorkflow({
-			body: runnerArgoWorkflowManifestSchema.parse(workflow),
+		return yield* submitWorkflowManifest({
 			dependencies,
 			namespace: options.namespace,
-			options
-		}), workflow, {
-			namespace: options.namespace,
-			payloadConfigMapName,
-			scheduleConfigMapName: scheduleArtifactConfigMapName,
-			taskDescriptorConfigMapName
+			options,
+			resultExtras: {
+				payloadConfigMapName,
+				scheduleConfigMapName: scheduleArtifactConfigMapName,
+				taskDescriptorConfigMapName
+			},
+			workflow
 		});
 	});
 }
@@ -219,8 +220,7 @@ function submitDynamicRunnerArgoWorkflowEffect(rawOptions, dependencies) {
 		workflowId: options.workflowId
 	});
 	return Effect.gen(function* () {
-		const service = yield* KubernetesArgoService;
-		yield* service.createConfigMap({
+		yield* (yield* KubernetesArgoService).createConfigMap({
 			body: configMapSchema.parse({
 				apiVersion: "v1",
 				data: { "payload.json": payloadJson },
@@ -235,14 +235,25 @@ function submitDynamicRunnerArgoWorkflowEffect(rawOptions, dependencies) {
 			namespace: options.namespace,
 			options
 		});
-		return workflowSubmitResult(yield* service.createWorkflow({
-			body: runnerArgoWorkflowManifestSchema.parse(workflow),
+		return yield* submitWorkflowManifest({
 			dependencies,
 			namespace: options.namespace,
-			options
-		}), workflow, {
-			namespace: options.namespace,
-			payloadConfigMapName
+			options,
+			resultExtras: { payloadConfigMapName },
+			workflow
+		});
+	});
+}
+function submitWorkflowManifest(input) {
+	return Effect.gen(function* () {
+		return workflowSubmitResult(yield* (yield* KubernetesArgoService).createWorkflow({
+			body: runnerArgoWorkflowManifestSchema.parse(input.workflow),
+			dependencies: input.dependencies,
+			namespace: input.namespace,
+			options: input.options
+		}), input.workflow, {
+			namespace: input.namespace,
+			...input.resultExtras
 		});
 	});
 }

package/dist/cli/submit-options.js

@@ -4,8 +4,16 @@ import { loadMokaGlobalConfig } from "../moka-global-config.js";
 import { submitMoka } from "../moka-submit.js";
 import { Option } from "commander";
 //#region src/cli/submit-options.ts
+function resolveOptionalSecretRef(flags, fromGlobalConfig) {
+	if (flags.skip) return;
+	if (flags.secretName) return {
+		secretName: flags.secretName,
+		...flags.secretKey ? { secretKey: flags.secretKey } : {}
+	};
+	return fromGlobalConfig;
+}
 function addMokaSubmitOptions(command) {
-	return addRunnerArgoOptions(command.option("--quick", "submit the compact graph").option("--command", "treat input after -- as explicit argv").option("--schedule <path>", "approved schedule YAML to submit").option("--event-url <url>", "runner event sink URL").option("--open-pr", "append an open-pull-request delivery node (preview-labelled PR)").option("--task <text>", "task description for command-mode metadata"), { kubeconfig: true });
+	return addRunnerArgoOptions(command.option("--quick", "submit the compact graph").option("--command", "treat input after -- as explicit argv").option("--schedule <path>", "approved schedule YAML to submit").option("--event-url <url>", "runner event sink URL").option("--open-pr", "append an open-pull-request delivery node (preview-labelled PR)").option("--task <text>", "task description for command-mode metadata").option("--db-auth-secret-name <name>", "override momokaya.submit.dbAuth secret name").option("--db-auth-secret-key <key>", "override momokaya.submit.dbAuth secret key").option("--skip-db-auth", "omit MOKA_DB_URL injection regardless of global config").option("--mcp-gateway-auth-secret-name <name>", "override momokaya.submit.mcpGatewayAuth secret name").option("--mcp-gateway-auth-secret-key <key>", "override momokaya.submit.mcpGatewayAuth secret key").option("--skip-mcp-gateway-auth", "omit PIPELINE_MCP_GATEWAY_AUTHORIZATION injection regardless of global config"), { kubeconfig: true });
 }
 function runMokaSubmitFromCli(input, flags) {
 	const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
@@ -36,8 +44,16 @@ function mokaCommonSubmitOptions(input) {
 	return {
 		brokerAuth: resolveMokaBrokerAuth(input.globalConfig),
 		config: input.config,
-		dbAuth: momokaya?.submit.dbAuth,
-		mcpGatewayAuth: momokaya?.submit.mcpGatewayAuth,
+		dbAuth: resolveOptionalSecretRef({
+			secretKey: input.flags.dbAuthSecretKey,
+			secretName: input.flags.dbAuthSecretName,
+			skip: input.flags.skipDbAuth
+		}, momokaya?.submit.dbAuth),
+		mcpGatewayAuth: resolveOptionalSecretRef({
+			secretKey: input.flags.mcpGatewayAuthSecretKey,
+			secretName: input.flags.mcpGatewayAuthSecretName,
+			skip: input.flags.skipMcpGatewayAuth
+		}, momokaya?.submit.mcpGatewayAuth),
 		delivery: { pullRequest: input.flags.openPr === true },
 		eventUrl: input.eventUrl,
 		eventAuthSecretKey: momokaya?.submit.eventAuthSecretKey,
@@ -48,6 +64,7 @@ function mokaCommonSubmitOptions(input) {
 		image: input.flags.image,
 		imagePullPolicy: parseImagePullPolicy(input.flags.imagePullPolicy),
 		imagePullSecretName: input.flags.imagePullSecret ?? momokaya?.submit.imagePullSecretName,
+		kubeContext: input.flags.kubeContext ?? momokaya?.kubernetes.context,
 		kubeconfigPath: input.flags.kubeconfig ?? momokaya?.kubernetes.kubeconfig,
 		name: input.flags.name,
 		namespace: input.flags.namespace ?? momokaya?.kubernetes.namespace,
@@ -83,7 +100,7 @@ function submitMokaGraphInput(input, flags, commonOptions) {
 }
 function addRunnerArgoOptions(command, options = {}) {
 	command.option("--name <name>", "Workflow metadata.name").option("--generate-name <prefix>", "Workflow metadata.generateName").option("--namespace <namespace>", "Workflow namespace");
-	if (options.kubeconfig) command.option("--kubeconfig <path>", "kubeconfig path");
+	if (options.kubeconfig) command.option("--kubeconfig <path>", "kubeconfig path").option("--kube-context <name>", "kubeconfig context to target");
 	return command.option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").addOption(new Option("--image-pull-policy <policy>", "runner image pull policy").choices([
 		"Always",
 		"IfNotPresent",

package/dist/moka-global-config.d.ts

@@ -9,6 +9,7 @@ declare const mokaGlobalConfigSchema: z.ZodObject<{
       url: z.ZodString;
     }, z.core.$strict>>;
     kubernetes: z.ZodObject<{
+      context: z.ZodOptional<z.ZodString>;
       kubeconfig: z.ZodOptional<z.ZodString>;
       namespace: z.ZodString;
     }, z.core.$strict>;

package/dist/moka-global-config.js

@@ -29,6 +29,7 @@ const mokaSubmitGlobalConfigSchema = z.object({
 	serviceAccountName: z.string().min(1)
 }).strict();
 const mokaKubernetesGlobalConfigSchema = z.object({
+	context: z.string().min(1).optional(),
 	kubeconfig: z.string().min(1).optional(),
 	namespace: z.string().min(1)
 }).strict();

package/dist/moka-submit.d.ts

@@ -197,6 +197,7 @@ declare const mokaSubmitBaseOptionsSchema: z.ZodObject<{
     Never: "Never";
   }>>;
   imagePullSecretName: z.ZodOptional<z.ZodString>;
+  kubeContext: z.ZodOptional<z.ZodString>;
   kubeconfigPath: z.ZodOptional<z.ZodString>;
   name: z.ZodOptional<z.ZodString>;
   namespace: z.ZodOptional<z.ZodString>;
@@ -310,6 +311,7 @@ declare const mokaGraphSubmitOptionsSchema: z.ZodObject<{
     Never: "Never";
   }>>;
   imagePullSecretName: z.ZodOptional<z.ZodString>;
+  kubeContext: z.ZodOptional<z.ZodString>;
   kubeconfigPath: z.ZodOptional<z.ZodString>;
   name: z.ZodOptional<z.ZodString>;
   namespace: z.ZodOptional<z.ZodString>;
@@ -440,6 +442,7 @@ declare const mokaCommandSubmitOptionsSchema: z.ZodObject<{
     Never: "Never";
   }>>;
   imagePullSecretName: z.ZodOptional<z.ZodString>;
+  kubeContext: z.ZodOptional<z.ZodString>;
   kubeconfigPath: z.ZodOptional<z.ZodString>;
   name: z.ZodOptional<z.ZodString>;
   namespace: z.ZodOptional<z.ZodString>;
@@ -565,6 +568,7 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     Never: "Never";
   }>>;
   imagePullSecretName: z.ZodOptional<z.ZodString>;
+  kubeContext: z.ZodOptional<z.ZodString>;
   kubeconfigPath: z.ZodOptional<z.ZodString>;
   name: z.ZodOptional<z.ZodString>;
   namespace: z.ZodOptional<z.ZodString>;
@@ -694,6 +698,7 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     Never: "Never";
   }>>;
   imagePullSecretName: z.ZodOptional<z.ZodString>;
+  kubeContext: z.ZodOptional<z.ZodString>;
   kubeconfigPath: z.ZodOptional<z.ZodString>;
   name: z.ZodOptional<z.ZodString>;
   namespace: z.ZodOptional<z.ZodString>;

package/dist/moka-submit.js

@@ -66,6 +66,7 @@ const mokaSubmitBaseOptionsSchema = z.object({
 	image: z.string().min(1).optional(),
 	imagePullPolicy: imagePullPolicySchema,
 	imagePullSecretName: z.string().min(1).optional(),
+	kubeContext: z.string().min(1).optional(),
 	kubeconfigPath: z.string().min(1).optional(),
 	name: z.string().min(1).optional(),
 	namespace: z.string().min(1).optional(),

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

@@ -18,6 +18,7 @@ interface MokaWorkflowSubmitOptions {
   image?: string;
   imagePullPolicy?: "Always" | "IfNotPresent" | "Never";
   imagePullSecretName?: string;
+  kubeContext?: string;
   kubeconfigPath?: string;
   mcpGatewayAuth?: {
     secretKey?: string;

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

@@ -50,6 +50,7 @@ function workflowSubmitOptions(options) {
 		image: options.image,
 		imagePullPolicy: options.imagePullPolicy,
 		imagePullSecretName: options.imagePullSecretName,
+		kubeContext: options.kubeContext,
 		kubeconfigPath: options.kubeconfigPath,
 		name: options.name,
 		namespace: requireSubmitOption(options.namespace, "namespace"),

package/dist/run-control/postgres/postgres-run-control-store.js

@@ -1,13 +1,12 @@
+import "../../runtime/durable-store/postgres/migrate-substrate.js";
 import { DEFAULT_RUN_CONTROL_STALE_DETECTION, parseMokaNodeStatus, parseMokaRunController, parseMokaRunEvent, parseMokaRunManifest, parseMokaRunStatus, parseRunControlStaleDetection, parseRunEffort, parseRunMode, parseRunTarget } from "../contracts.js";
 import { publishScheduleManifest } from "../store-manifest.js";
 import { runControlEvent, runControlNodeArtifact, runControlNodeSession, runControlRun } from "./schema.js";
 import { Effect } from "effect";
-import { fileURLToPath } from "node:url";
-import { asc, eq, inArray } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/postgres-js";
-import "drizzle-orm/postgres-js/migrator";
 import postgres from "postgres";
-fileURLToPath(new URL("../../runtime/durable-store/postgres/migrations", import.meta.url));
+import { asc, eq, inArray } from "drizzle-orm";
+//#region src/run-control/postgres/postgres-run-control-store.ts
 function openClient(dbUrl) {
 	return postgres(dbUrl, { max: 1 });
 }
@@ -39,7 +38,7 @@ function createRun(db, input) {
 			manifest,
 			runId: manifest.runId
 		}).onConflictDoNothing());
-		const existing = yield* readRun(db, manifest.runId);
+		const existing = yield* loadBaseManifest(db, manifest.runId);
 		if (existing === void 0) return yield* Effect.fail(/* @__PURE__ */ new Error(`Run ${manifest.runId} not found after createRun upsert.`));
 		return existing;
 	});

package/dist/run-control/run-control-store.js

@@ -1,4 +1,5 @@
 import { loadMokaDbUrl, requireMokaDbUrl } from "../moka-global-config.js";
+import { migratePostgresSubstrate } from "../runtime/durable-store/postgres/migrate-substrate.js";
 import { postgresRunControlStore } from "./postgres/postgres-run-control-store.js";
 import "./store-paths.js";
 import "./store.js";
@@ -19,7 +20,10 @@ import { Effect } from "effect";
 * filesystem store holds no resources, so it is returned directly.
 */
 function resolveRunControlStore(dbUrl, _workspaceRoot) {
-	return requireMokaDbUrl(dbUrl).pipe(Effect.flatMap((requiredDbUrl) => Effect.acquireRelease(Effect.sync(() => postgresRunControlStore(requiredDbUrl)), (store) => Effect.promise(() => store.close()))));
+	return requireMokaDbUrl(dbUrl).pipe(Effect.flatMap((requiredDbUrl) => Effect.tryPromise({
+		catch: (error) => error,
+		try: () => migratePostgresSubstrate(requiredDbUrl)
+	}).pipe(Effect.flatMap(() => Effect.acquireRelease(Effect.sync(() => postgresRunControlStore(requiredDbUrl)), (store) => Effect.promise(() => store.close()))))));
 }
 /**
 * PIPE-91.14: the single store-lifecycle wrapper shared by every run-control

package/dist/runtime/durable-store/acquisition.js

@@ -1,9 +1,10 @@
 import { requireMokaDbUrl } from "../../moka-global-config.js";
+import { migratePostgresSubstrate } from "./postgres/migrate-substrate.js";
 import { postgresDurableRunStore } from "./postgres/postgres-store.js";
 import { Effect } from "effect";
 //#region src/runtime/durable-store/acquisition.ts
 function resolveDurableStore(dbUrl, runId) {
-	return requireMokaDbUrl(dbUrl).pipe(Effect.flatMap((requiredDbUrl) => Effect.acquireRelease(Effect.tryPromise(() => postgresDurableRunStore(requiredDbUrl, runId)), (store) => Effect.promise(() => store.close()))));
+	return requireMokaDbUrl(dbUrl).pipe(Effect.flatMap((requiredDbUrl) => Effect.tryPromise(() => migratePostgresSubstrate(requiredDbUrl)).pipe(Effect.flatMap(() => Effect.acquireRelease(Effect.tryPromise(() => postgresDurableRunStore(requiredDbUrl, runId)), (store) => Effect.promise(() => store.close()))))));
 }
 //#endregion
 export { resolveDurableStore };

package/dist/runtime/durable-store/postgres/migrate-substrate.js

@@ -0,0 +1,29 @@
+import { fileURLToPath } from "node:url";
+import { drizzle } from "drizzle-orm/postgres-js";
+import { migrate } from "drizzle-orm/postgres-js/migrator";
+import postgres from "postgres";
+//#region src/runtime/durable-store/postgres/migrate-substrate.ts
+const migrationsFolder = fileURLToPath(new URL("./migrations", import.meta.url));
+const MIGRATION_LOCK_KEY = 8942017;
+/**
+* Apply the Drizzle migrations shared by the run-control and durable stores to
+* `dbUrl`. Idempotent (Drizzle tracks applied migrations in
+* `__drizzle_migrations` by content hash) and safe under concurrent callers
+* (Postgres advisory lock serializes them). Opens and closes its own
+* single-connection client.
+*/
+async function migratePostgresSubstrate(dbUrl) {
+	const client = postgres(dbUrl, { max: 1 });
+	try {
+		await client`select pg_advisory_lock(${MIGRATION_LOCK_KEY}::bigint)`;
+		try {
+			await migrate(drizzle(client), { migrationsFolder });
+		} finally {
+			await client`select pg_advisory_unlock(${MIGRATION_LOCK_KEY}::bigint)`;
+		}
+	} finally {
+		await client.end();
+	}
+}
+//#endregion
+export { migratePostgresSubstrate };

package/dist/runtime/durable-store/postgres/postgres-store.js

@@ -1,15 +1,13 @@
+import "./migrate-substrate.js";
 import { createSerializedWriteQueue } from "../../../serialized-write-queue.js";
 import { buildRunJournal } from "../../run-journal.js";
 import { durableNodeRecord, durableRun } from "./schema.js";
-import { fileURLToPath } from "node:url";
-import { eq } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/postgres-js";
-import "drizzle-orm/postgres-js/migrator";
 import postgres from "postgres";
+import { eq } from "drizzle-orm";
 import pino from "pino";
 //#region src/runtime/durable-store/postgres/postgres-store.ts
 const logger = pino({ name: "postgres-durable-store" });
-fileURLToPath(new URL("./migrations", import.meta.url));
 function openClient(dbUrl) {
 	return postgres(dbUrl, { max: 1 });
 }

package/dist/runtime/services/kubernetes-argo-service.js

@@ -62,6 +62,10 @@ function resolveKubeConfig(options, dependencies) {
 	const kubeConfig = new KubeConfig();
 	if (options.kubeconfigPath) kubeConfig.loadFromFile(options.kubeconfigPath);
 	else kubeConfig.loadFromDefault();
+	if (options.kubeContext) {
+		if (!kubeConfig.getContextObject(options.kubeContext)) throw new Error(`Kube context '${options.kubeContext}' was not found in the resolved kubeconfig`);
+		kubeConfig.setCurrentContext(options.kubeContext);
+	}
 	return kubeConfig;
 }
 function apiClients(options, dependencies) {

package/docs/adr-two-stage-submit-scheduling.md

@@ -0,0 +1,112 @@
+# ADR: Two-Stage `moka submit` — Schedule-Then-Dispatch
+
+Status: Accepted
+
+Date: 2026-07-01
+
+## Decision
+
+`moka submit` is one flow with two stages, not two separate commands and not two
+separate code paths:
+
+1. **Schedule** — research, planning, and graph generation, producing a
+   `ScheduleArtifact` and persisting it to the durable Postgres run-control
+   store before any Argo Workflow exists.
+2. **Dispatch** — compile the persisted (or explicitly supplied) schedule into
+   an Argo Workflow manifest and submit it, targeting whatever Kubernetes
+   cluster/context the operator configured.
+
+Both stages run inside the single call chain:
+
+```
+moka submit [args]
+  -> registerSubmitCommand()            src/cli/program.ts:71
+  -> runMokaSubmitFromCli()             src/cli/submit-options.ts:55
+  -> submitMoka()                       src/moka-submit.ts:238
+  -> submitParsedMoka()                 src/remote/submit/service.ts:47
+       - compileMokaSubmitPlan()        src/remote/submit/compilation.ts:32
+       - upsertRunRecord()  [Schedule -> DB]
+       - submitCompiledMokaWorkflow()   src/remote/submit/argo-submission.ts:46  [Dispatch]
+```
+
+There is exactly one WorkflowSpec builder chain (`buildRunnerArgoWorkflowManifest`
+/ `buildDynamicRunnerArgoWorkflowManifest` in `src/argo-workflow.ts`) and exactly
+one Kubernetes/Argo client (`KubernetesArgoService` in
+`src/runtime/services/kubernetes-argo-service.ts`). Static and dynamic
+scheduling are a discriminated union (`dynamicScheduling: boolean` on
+`CompiledMokaSubmitPlan`), not parallel implementations.
+
+## Stage 1 — Schedule (research -> planning -> graph, persisted)
+
+When no `scheduleYaml`/`schedulePath` is supplied at submit time
+(`dynamicScheduling: true`), the schedule is produced inside the runner pod by
+three sequential phases, run via `moka runner-pre-schedule --phase <phase>`
+(`src/runner-command/pre-schedule.ts`):
+
+1. `pre-research` — produces research context (findings, risks, target).
+2. `pre-planning` — consumes research, produces a `TicketPlan` (tickets +
+   dependencies), via `ticketPlanPlanningContext()`
+   (`src/planning/generate.ts:343`).
+3. `generate-schedule` — calls the configured planner profile to produce the
+   final `ScheduleArtifact`. If the planner fails or emits an invalid
+   artifact, `ticketPlanScheduleArtifact()` (`src/planning/generate.ts:497`)
+   deterministically derives a schedule directly from the `TicketPlan` graph
+   instead — this is the accepted fallback shape, not a patch to remove.
+
+The result is written once via `publishSchedule()`
+(`src/run-control/run-control-store.ts:60`) into the run's manifest
+(`moka_run_control_run.manifest` JSONB). `publishSchedule` is idempotent for an
+identical schedule and rejects a conflicting one for the same run
+(`tests/run-control-store-contract.test.ts:423`).
+
+## Stage 2 — Dispatch (compile -> submit)
+
+`submitParsedMoka()` (`src/remote/submit/service.ts:47`) upserts the run record
+to Postgres **before** calling Argo, but a DB write failure never blocks
+dispatch — the guard at `service.ts:56-61` logs and proceeds, because the
+in-pod runner lifecycle (`src/runner-command/lifecycle.ts`) re-creates the same
+run record idempotently once the pod starts. Postgres is a durability/inspection
+substrate for `moka status`/`moka logs`/`moka resume`, not a precondition for
+submission.
+
+`submitCompiledMokaWorkflow()` then calls `submitRunnerArgoWorkflow()` (static,
+schedule already known) or `submitDynamicRunnerArgoWorkflow()` (dynamic,
+schedule generated in-pod) — both in `src/argo-submit.ts`, both routed through
+the same `KubernetesArgoService`.
+
+## Cluster targeting is one seam, not per-caller
+
+Kubernetes context/kubeconfig resolution is a single function,
+`resolveKubeConfig()` (`src/runtime/services/kubernetes-argo-service.ts`), used
+by every Argo/K8s call (`createConfigMap`, `createWorkflow`,
+`getWorkflowPhase`). Precedence, highest wins:
+
+1. `--kube-context <name>` / `--kubeconfig <path>` CLI flags
+   (`src/cli/submit-options.ts`)
+2. `momokaya.kubernetes.context` / `momokaya.kubernetes.kubeconfig` in
+   `~/.config/moka/config.yaml` (`src/moka-global-config.ts`)
+3. The kubeconfig's own `current-context` (`KubeConfig.loadFromDefault()`)
+
+An unresolvable `kubeContext` fails loud at resolution time (`kubeConfig.
+getContextObject()` check) rather than silently falling through to whatever
+context happened to be current — this is what makes "point submit at momokaya
+or at a local orbstack context" a config change, never a code change. Prior to
+this ADR, `kubeContext` existed for the `kubectl`-shellout polling path
+(`cluster-doctor.ts`) but not for the actual submission API calls; that gap is
+closed as part of this decision.
+
+## Consequences
+
+- Do not add a second "generate the graph" path or a second Argo client.
+  Static vs. dynamic scheduling is a data flag on `CompiledMokaSubmitPlan`, not
+  a reason to fork the builder or the service.
+- Do not gate submission on the DB write succeeding — the guard in
+  `service.ts` is intentional, not a missing try/catch to "fix".
+- Any new cluster-targeting option (a third context source, a per-namespace
+  override) is added to `resolveKubeConfig`'s precedence list, not threaded
+  ad hoc through individual call sites.
+
+## References
+
+- Run-control persistence model: `./run-control.md`
+- PIPE-94 durable substrate: `oisin-ee` backlog PIPE-94.3/94.4/94.5/94.8

package/package.json

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