@oisincoveney/pipeline 1.25.0 → 1.26.0

package/README.md

@@ -163,6 +163,13 @@ Submitters can import the executable contract from
 `@oisincoveney/pipeline/runner-command-contract` for payload construction,
 validation, contract-version checks, and JSON Schema generation.
 
+Pipeline Console submits hosted runs through `@oisincoveney/pipeline/moka-submit`.
+The subpath exports `mokaSubmitOptionsSchema`, `mokaSubmitResultSchema`,
+`MokaSubmitOptionsInput`, `MokaSubmitOptionsOutput`, `MokaSubmitInput`,
+`MokaSubmitOutput`, and `submitMoka` so callers can validate prompt or ticket
+tasks with explicit repository, run, delivery, event sink, and runner settings
+without importing Argo, Kubernetes, or runner-command internals.
+
 ## Configuration Model
 
 Runtime execution uses package-owned defaults. Tests and advanced embedding code

package/dist/argo-submit.d.ts

@@ -1,4 +1,5 @@
 import { PipelineConfig } from "./config.js";
+import { workflowSubmitResultSchema } from "./workflow-submit-contract.js";
 import { z } from "zod";
 import { CoreV1Api, CustomObjectsApi, KubeConfig } from "@kubernetes/client-node";
 
@@ -24,14 +25,6 @@ declare const submitRunnerArgoWorkflowOptionsSchema: z.ZodObject<{
   scheduleYaml: z.ZodString;
   serviceAccountName: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-declare const submitRunnerArgoWorkflowResultSchema: z.ZodObject<{
-  namespace: z.ZodString;
-  payloadConfigMapName: z.ZodString;
-  scheduleConfigMapName: z.ZodString;
-  taskDescriptorConfigMapName: z.ZodString;
-  workflowName: z.ZodString;
-  workflowUid: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
 declare const commandScheduleOptionsSchema: z.ZodObject<{
   command: z.ZodArray<z.ZodString>;
   generatedAt: z.ZodDefault<z.ZodDate>;
@@ -41,7 +34,7 @@ declare const commandScheduleOptionsSchema: z.ZodObject<{
 type SubmitRunnerArgoWorkflowOptions = z.input<typeof submitRunnerArgoWorkflowOptionsSchema> & {
   config: PipelineConfig;
 };
-type SubmitRunnerArgoWorkflowResult = z.infer<typeof submitRunnerArgoWorkflowResultSchema>;
+type SubmitRunnerArgoWorkflowResult = z.infer<typeof workflowSubmitResultSchema>;
 type CommandScheduleOptions = z.input<typeof commandScheduleOptionsSchema>;
 type CoreApi = Pick<CoreV1Api, "createNamespacedConfigMap">;
 type WorkflowApi = Pick<CustomObjectsApi, "createNamespacedCustomObject">;

package/dist/argo-submit.js

@@ -3,6 +3,7 @@ import { buildRunnerTaskDescriptor } from "./runner-command/task-descriptor.js";
 import { buildRunnerArgoWorkflowManifest, runnerArgoWorkflowManifestSchema } from "./argo-workflow.js";
 import { parseRunnerCommandPayload, runnerCommandPayloadSchema } from "./runner-command-contract.js";
 import { compileScheduleArtifact, parseScheduleArtifact } from "./schedule-planner.js";
+import { workflowSubmitResultSchema } from "./workflow-submit-contract.js";
 import { stringify } from "yaml";
 import { z } from "zod";
 import { randomBytes } from "node:crypto";
@@ -40,14 +41,6 @@ const submitRunnerArgoWorkflowOptionsSchema = z.object({
 	scheduleYaml: z.string().min(1),
 	serviceAccountName: z.string().min(1).optional()
 }).strict().refine((options) => options.name !== void 0 || options.generateName !== void 0, { message: "Argo submit options must declare name or generateName" });
-const submitRunnerArgoWorkflowResultSchema = z.object({
-	namespace: z.string().min(1),
-	payloadConfigMapName: z.string().min(1),
-	scheduleConfigMapName: z.string().min(1),
-	taskDescriptorConfigMapName: z.string().min(1),
-	workflowName: z.string().min(1),
-	workflowUid: z.string().min(1).optional()
-}).strict();
 const commandScheduleOptionsSchema = z.object({
 	command: z.array(z.string().min(1)).min(1),
 	generatedAt: z.date().default(() => /* @__PURE__ */ new Date()),
@@ -140,7 +133,7 @@ async function submitRunnerArgoWorkflow(rawOptions, dependencies = {}) {
 		name: z.string().min(1).optional(),
 		uid: z.string().min(1).optional()
 	}).passthrough() }).passthrough().parse(response);
-	return submitRunnerArgoWorkflowResultSchema.parse({
+	return workflowSubmitResultSchema.parse({
 		namespace: options.namespace,
 		payloadConfigMapName,
 		scheduleConfigMapName: scheduleArtifactConfigMapName,

package/dist/config.d.ts

@@ -485,8 +485,8 @@ declare const configSchema: z.ZodObject<{
   rules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     path: z.ZodString;
     source_root: z.ZodDefault<z.ZodEnum<{
-      package: "package";
       project: "project";
+      package: "package";
     }>>;
   }, z.core.$strict>>>;
   runners: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -613,8 +613,8 @@ declare const configSchema: z.ZodObject<{
   schedules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     baseline: z.ZodEnum<{
-      execute: "execute";
       quick: "quick";
+      execute: "execute";
     }>;
     max_parallel_nodes: z.ZodOptional<z.ZodNumber>;
     node_catalog: z.ZodOptional<z.ZodString>;
@@ -626,8 +626,8 @@ declare const configSchema: z.ZodObject<{
   skills: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     path: z.ZodString;
     source_root: z.ZodDefault<z.ZodEnum<{
-      package: "package";
       project: "project";
+      package: "package";
     }>>;
   }, z.core.$strict>>>;
   task_context: z.ZodOptional<z.ZodObject<{

package/dist/hooks.d.ts

@@ -13,8 +13,8 @@ declare const hookResultSchema: z.ZodObject<{
     taskContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   }, z.core.$strict>>;
   status: z.ZodEnum<{
-    fail: "fail";
     pass: "pass";
+    fail: "fail";
     skip: "skip";
   }>;
   summary: z.ZodOptional<z.ZodString>;

package/dist/install-commands.js

@@ -3,6 +3,7 @@ import { DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST, loadPipelineConfig } from "./confi
 import { compileWorkflowPlan } from "./workflow-planner.js";
 import { renderOpenCodeGatewayConfig } from "./mcp/gateway.js";
 import { resolvePackageAssetPath } from "./package-assets.js";
+import { mergeOpenCodeProjectConfig } from "./opencode-project-config.js";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, join, relative } from "node:path";
 import matter from "gray-matter";
@@ -17,6 +18,7 @@ const OWNER_YAML_MARKER_PREFIX = "# @oisincoveney/pipeline:";
 const AGENTS_MD_START = "<!-- @oisincoveney/pipeline:agents:start -->";
 const AGENTS_MD_END = "<!-- @oisincoveney/pipeline:agents:end -->";
 const SINGLE_OPENCODE_PLUGIN_ARRAY_RE = /\n {2}"plugin": \[\n {4}("[^"]+")\n {2}\]/;
+const OPENCODE_PROJECT_CONFIG_PATH = ".opencode/opencode.json";
 const ENTRYPOINT_PATH_PATTERNS = { opencode: [/^\.opencode\/commands\/([^/]+)\.md$/] };
 const COMMAND_HOSTS = ["opencode"];
 function header(host) {
@@ -517,6 +519,22 @@ function entrypointIdFromGeneratedPath(host, path) {
 function invocationForHost(host, entrypointId = "execute") {
 	return `${{ opencode: "/" }[host]}${entrypointId} <task description>`;
 }
+function resolveDefinitionContent(definition, target) {
+	if (definition.path !== OPENCODE_PROJECT_CONFIG_PATH || !existsSync(target)) return {
+		conflict: false,
+		content: definition.content
+	};
+	const projection = JSON.parse(definition.content);
+	const merged = mergeOpenCodeProjectConfig(readFileSync(target, "utf8"), projection);
+	if (!merged.ok) return {
+		conflict: true,
+		content: definition.content
+	};
+	return {
+		conflict: false,
+		content: merged.content
+	};
+}
 function actionFor(path, content, force, block) {
 	if (!existsSync(path)) return "create";
 	const current = readFileSync(path, "utf8");
@@ -540,37 +558,90 @@ function upsertGeneratedBlock(current, content, block) {
 	const separator = current.trimEnd().length > 0 ? "\n\n" : "";
 	return `${current.trimEnd()}${separator}${content}`;
 }
-async function installCommands(options = {}) {
+function installActionForDefinition(definition, target, resolved, force) {
+	if (resolved.conflict) return "conflict";
+	return actionFor(target, resolved.content, force || definition.path === OPENCODE_PROJECT_CONFIG_PATH, definition.block);
+}
+async function writeDefinition(definition, target, content) {
+	await mkdir(dirname(target), { recursive: true });
+	if (definition.block && existsSync(target)) {
+		await writeFile(target, upsertGeneratedBlock(readFileSync(target, "utf8"), content, definition.block));
+		return;
+	}
+	await writeFile(target, content);
+}
+function shouldSkipInstallWrite(options, action) {
+	return Boolean(options.check || options.dryRun || action === "unchanged" || action === "conflict");
+}
+async function installDefinition(cwd, definition, options) {
+	const target = join(cwd, definition.path);
+	const resolved = resolveDefinitionContent(definition, target);
+	const action = installActionForDefinition(definition, target, resolved, Boolean(options.force));
+	const item = commandInstallPlanItem(definition, action);
+	if (!shouldSkipInstallWrite(options, action)) await writeDefinition(definition, target, resolved.content);
+	return item;
+}
+function commandInstallPlanItem(definition, action) {
+	return {
+		action,
+		host: definition.host,
+		invocation: definition.invocation,
+		path: definition.path
+	};
+}
+function installCommandsContext(options) {
 	const cwd = options.cwd ?? process.cwd();
 	const host = options.host ?? "all";
-	const config = loadPipelineConfig(cwd, { allowMissingLintFileReferences: true });
+	const definitions = definitionsFor(host, loadPipelineConfig(cwd, { allowMissingLintFileReferences: true }), cwd);
+	return {
+		cwd,
+		definitions,
+		host,
+		wantedPaths: new Set(definitions.map((definition) => definition.path))
+	};
+}
+async function installDefinitions(cwd, definitions, options) {
 	const items = [];
-	const definitions = definitionsFor(host, config, cwd);
-	const wantedPaths = new Set(definitions.map((definition) => definition.path));
-	for (const definition of definitions) {
-		const target = join(cwd, definition.path);
-		const action = actionFor(target, definition.content, Boolean(options.force), definition.block);
-		items.push({
-			action,
-			host: definition.host,
-			invocation: definition.invocation,
-			path: definition.path
-		});
-		if (options.check || options.dryRun || action === "unchanged") continue;
-		if (action === "conflict") continue;
-		await mkdir(dirname(target), { recursive: true });
-		if (definition.block && existsSync(target)) await writeFile(target, upsertGeneratedBlock(readFileSync(target, "utf8"), definition.content, definition.block));
-		else await writeFile(target, definition.content);
-	}
-	const obsoleteItems = await obsoleteGeneratedItems(cwd, host, wantedPaths);
-	items.push(...obsoleteItems);
-	if (!(options.check || options.dryRun)) for (const item of obsoleteItems) await rm(join(cwd, item.path), { force: true });
-	if (!options.dryRun && items.some((item) => item.action === "conflict")) throw new Error([
+	for (const definition of definitions) items.push(await installDefinition(cwd, definition, options));
+	return items;
+}
+function shouldRemoveObsoleteItems(options) {
+	return !(options.check || options.dryRun);
+}
+async function removeObsoleteItems(cwd, items, options) {
+	if (!shouldRemoveObsoleteItems(options)) return;
+	for (const item of items) await rm(join(cwd, item.path), { force: true });
+}
+function actionIsConflict(item) {
+	return item.action === "conflict";
+}
+function actionIsChanged(item) {
+	return item.action !== "unchanged";
+}
+function assertNoInstallConflicts(options, items) {
+	if (options.dryRun) return;
+	const conflicts = items.filter(actionIsConflict);
+	if (conflicts.length === 0) return;
+	throw new Error([
 		"Refusing to overwrite manually edited command files.",
-		...items.filter((item) => item.action === "conflict").map((item) => `- ${item.path}`),
+		...conflicts.map((item) => `- ${item.path}`),
 		"Re-run with --force to overwrite them."
 	].join("\n"));
-	if (options.check && items.some((item) => item.action !== "unchanged")) throw new Error(["Installed command files are not up to date.", ...items.filter((item) => item.action !== "unchanged").map((item) => `- ${item.path}: ${item.action}`)].join("\n"));
+}
+function assertInstallCheckCurrent(options, items) {
+	if (!options.check) return;
+	const changedItems = items.filter(actionIsChanged);
+	if (changedItems.length === 0) return;
+	throw new Error(["Installed command files are not up to date.", ...changedItems.map((item) => `- ${item.path}: ${item.action}`)].join("\n"));
+}
+async function installCommands(options = {}) {
+	const context = installCommandsContext(options);
+	const items = await installDefinitions(context.cwd, context.definitions, options);
+	const obsoleteItems = await obsoleteGeneratedItems(context.cwd, context.host, context.wantedPaths);
+	items.push(...obsoleteItems);
+	await removeObsoleteItems(context.cwd, obsoleteItems, options);
+	assertNoInstallConflicts(options, items);
+	assertInstallCheckCurrent(options, items);
 	return { items };
 }
 function parseCommandHost(value) {

package/dist/moka-submit.d.ts

@@ -0,0 +1,160 @@
+import { PipelineConfig } from "./config.js";
+import { generateScheduleArtifact } from "./schedule-planner.js";
+import { z } from "zod";
+
+//#region src/moka-submit.d.ts
+declare const mokaSubmitResultSchema: z.ZodObject<{
+  namespace: z.ZodString;
+  payloadConfigMapName: z.ZodString;
+  scheduleConfigMapName: z.ZodString;
+  taskDescriptorConfigMapName: z.ZodString;
+  workflowName: z.ZodString;
+  workflowUid: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  delivery: z.ZodDefault<z.ZodObject<{
+    pullRequest: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strict>>;
+  eventAuthSecretKey: z.ZodDefault<z.ZodString>;
+  eventAuthSecretName: z.ZodDefault<z.ZodString>;
+  eventUrl: z.ZodDefault<z.ZodString>;
+  events: z.ZodOptional<z.ZodObject<{
+    authHeader: z.ZodDefault<z.ZodString>;
+    authTokenFile: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+  }, z.core.$strict>>;
+  generateName: z.ZodOptional<z.ZodString>;
+  githubAuthSecretName: z.ZodDefault<z.ZodString>;
+  image: z.ZodOptional<z.ZodString>;
+  imagePullPolicy: z.ZodDefault<z.ZodEnum<{
+    Always: "Always";
+    IfNotPresent: "IfNotPresent";
+    Never: "Never";
+  }>>;
+  imagePullSecretName: z.ZodDefault<z.ZodString>;
+  kubeconfigPath: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  namespace: z.ZodDefault<z.ZodString>;
+  opencodeAuthSecretName: z.ZodDefault<z.ZodString>;
+  queueName: z.ZodDefault<z.ZodString>;
+  repository: z.ZodOptional<z.ZodObject<{
+    baseBranch: z.ZodString;
+    sha: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+  }, z.core.$strict>>;
+  run: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    project: z.ZodString;
+    requestedBy: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  serviceAccountName: z.ZodDefault<z.ZodString>;
+  mode: z.ZodEnum<{
+    full: "full";
+    quick: "quick";
+  }>;
+  schedulePath: z.ZodOptional<z.ZodString>;
+  scheduleYaml: z.ZodOptional<z.ZodString>;
+  task: z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"prompt">;
+    prompt: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"ticket">;
+    path: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>], "kind">]>;
+  type: z.ZodLiteral<"graph">;
+}, z.core.$strict>, z.ZodObject<{
+  delivery: z.ZodDefault<z.ZodObject<{
+    pullRequest: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strict>>;
+  eventAuthSecretKey: z.ZodDefault<z.ZodString>;
+  eventAuthSecretName: z.ZodDefault<z.ZodString>;
+  eventUrl: z.ZodDefault<z.ZodString>;
+  events: z.ZodOptional<z.ZodObject<{
+    authHeader: z.ZodDefault<z.ZodString>;
+    authTokenFile: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+  }, z.core.$strict>>;
+  generateName: z.ZodOptional<z.ZodString>;
+  githubAuthSecretName: z.ZodDefault<z.ZodString>;
+  image: z.ZodOptional<z.ZodString>;
+  imagePullPolicy: z.ZodDefault<z.ZodEnum<{
+    Always: "Always";
+    IfNotPresent: "IfNotPresent";
+    Never: "Never";
+  }>>;
+  imagePullSecretName: z.ZodDefault<z.ZodString>;
+  kubeconfigPath: z.ZodOptional<z.ZodString>;
+  name: z.ZodOptional<z.ZodString>;
+  namespace: z.ZodDefault<z.ZodString>;
+  opencodeAuthSecretName: z.ZodDefault<z.ZodString>;
+  queueName: z.ZodDefault<z.ZodString>;
+  repository: z.ZodOptional<z.ZodObject<{
+    baseBranch: z.ZodString;
+    sha: z.ZodOptional<z.ZodString>;
+    url: z.ZodString;
+  }, z.core.$strict>>;
+  run: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    project: z.ZodString;
+    requestedBy: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  serviceAccountName: z.ZodDefault<z.ZodString>;
+  commandArgv: z.ZodArray<z.ZodString>;
+  task: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"prompt">;
+    prompt: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"ticket">;
+    path: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>], "kind">]>>;
+  type: z.ZodLiteral<"command">;
+}, z.core.$strict>], "type">;
+type MokaSubmitOptionsInput = z.input<typeof mokaSubmitOptionsSchema>;
+type MokaSubmitOptionsOutput = z.output<typeof mokaSubmitOptionsSchema>;
+type MokaSubmitInput = MokaSubmitOptionsInput & {
+  config: PipelineConfig;
+  worktreePath?: string;
+};
+type MokaSubmitOptions = MokaSubmitInput;
+type MokaSubmitOutput = z.output<typeof mokaSubmitResultSchema>;
+type MokaSubmitResult = MokaSubmitOutput;
+interface MokaGitContext {
+  baseBranch: string;
+  project: string;
+  sha: string;
+  url: string;
+}
+interface SubmitMokaDependencies {
+  generateRunId?: () => string;
+  generateSchedule?: typeof generateScheduleArtifact;
+  readFile?: (path: string) => string;
+  resolveGitContext?: (worktreePath: string) => Promise<MokaGitContext>;
+  submitWorkflow?: (options: MokaWorkflowSubmitOptions) => Promise<MokaSubmitOutput>;
+}
+interface MokaWorkflowSubmitOptions {
+  config: PipelineConfig;
+  eventAuthSecretKey?: string;
+  eventAuthSecretName?: string;
+  generateName?: string;
+  githubAuthSecretName?: string;
+  image?: string;
+  imagePullPolicy?: "Always" | "IfNotPresent" | "Never";
+  imagePullSecretName?: string;
+  kubeconfigPath?: string;
+  name?: string;
+  namespace?: string;
+  opencodeAuthSecretName?: string;
+  payloadJson: string;
+  queueName?: string;
+  scheduleYaml: string;
+  serviceAccountName?: string;
+}
+declare function submitMoka(rawOptions: MokaSubmitInput, dependencies?: SubmitMokaDependencies): Promise<MokaSubmitOutput>;
+//#endregion
+export { MokaSubmitInput, MokaSubmitOptions, MokaSubmitOptionsInput, MokaSubmitOptionsOutput, MokaSubmitOutput, MokaSubmitResult, mokaSubmitOptionsSchema, mokaSubmitResultSchema, submitMoka };

package/dist/moka-submit.js

@@ -1,5 +1,6 @@
-import { buildRunnerCommandPayload } from "./runner-command-contract.js";
+import { buildRunnerCommandPayload, runnerDeliverySchema, runnerRepositoryContextSchema, runnerRunIdentitySchema, runnerTaskSchema } from "./runner-command-contract.js";
 import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifact } from "./schedule-planner.js";
+import { workflowSubmitResultSchema } from "./workflow-submit-contract.js";
 import { buildCommandScheduleYaml, submitRunnerArgoWorkflow } from "./argo-submit.js";
 import { z } from "zod";
 import { readFileSync } from "node:fs";
@@ -21,27 +22,43 @@ const imagePullPolicySchema = z.enum([
 	"IfNotPresent",
 	"Never"
 ]).default("Always");
+const mokaSubmitTaskInputSchema = z.union([z.string().min(1), runnerTaskSchema]);
+const mokaSubmitEventsSchema = z.object({
+	authHeader: z.string().min(1).default("Authorization"),
+	authTokenFile: z.string().min(1).optional(),
+	url: z.string().url()
+}).strict();
+const mokaSubmitResultSchema = workflowSubmitResultSchema;
 const mokaSubmitBaseOptionsSchema = z.object({
+	delivery: runnerDeliverySchema.default({ pullRequest: false }),
+	eventAuthSecretKey: z.string().min(1).default(MOMOKAYA_EVENT_AUTH_SECRET_KEY),
+	eventAuthSecretName: z.string().min(1).default(MOMOKAYA_EVENT_AUTH_SECRET_NAME),
 	eventUrl: z.string().url().default(MOMOKAYA_EVENT_URL),
+	events: mokaSubmitEventsSchema.optional(),
 	generateName: z.string().min(1).optional(),
+	githubAuthSecretName: z.string().min(1).default(MOMOKAYA_GITHUB_AUTH_SECRET_NAME),
 	image: z.string().min(1).optional(),
 	imagePullPolicy: imagePullPolicySchema,
 	imagePullSecretName: z.string().min(1).default(MOMOKAYA_IMAGE_PULL_SECRET_NAME),
 	kubeconfigPath: z.string().min(1).optional(),
 	name: z.string().min(1).optional(),
 	namespace: z.string().min(1).default("momokaya-pipeline"),
+	opencodeAuthSecretName: z.string().min(1).default(MOMOKAYA_OPENCODE_AUTH_SECRET_NAME),
 	queueName: z.string().min(1).default(MOMOKAYA_QUEUE_NAME),
+	repository: runnerRepositoryContextSchema.optional(),
+	run: runnerRunIdentitySchema.optional(),
 	serviceAccountName: z.string().min(1).default(MOMOKAYA_RUNNER_SERVICE_ACCOUNT_NAME)
 }).strict();
 const mokaGraphSubmitOptionsSchema = mokaSubmitBaseOptionsSchema.extend({
 	mode: z.enum(["full", "quick"]),
 	schedulePath: z.string().min(1).optional(),
-	task: z.string().min(1),
+	scheduleYaml: z.string().min(1).optional(),
+	task: mokaSubmitTaskInputSchema,
 	type: z.literal("graph")
 }).strict();
 const mokaCommandSubmitOptionsSchema = mokaSubmitBaseOptionsSchema.extend({
 	commandArgv: z.array(z.string().min(1)).min(1),
-	task: z.string().min(1).optional(),
+	task: mokaSubmitTaskInputSchema.optional(),
 	type: z.literal("command")
 }).strict();
 const mokaSubmitOptionsSchema = z.discriminatedUnion("type", [mokaGraphSubmitOptionsSchema, mokaCommandSubmitOptionsSchema]);
@@ -54,47 +71,59 @@ function submitMoka(rawOptions, dependencies = {}) {
 	};
 	return parsedOptions.type === "command" ? submitMokaCommand(parsedOptions, dependencies) : submitMokaGraph(parsedOptions, dependencies);
 }
+function resolveSubmitWorkflow(dependencies) {
+	return dependencies.submitWorkflow ?? submitRunnerArgoWorkflow;
+}
+function submitRunId(options, dependencies) {
+	return options.run?.id ?? generateRunId(dependencies);
+}
+function commandTask(options) {
+	if (options.task) return normalizeTask(options.task);
+	return normalizeTask(options.commandArgv.join(" "));
+}
 async function submitMokaGraph(options, dependencies) {
-	const git = await resolveGit(options.worktreePath, dependencies);
-	const submitWorkflow = dependencies.submitWorkflow ?? submitRunnerArgoWorkflow;
-	const runId = generateRunId(dependencies);
-	const scheduleYaml = await graphScheduleYaml(options, dependencies, runId);
+	const submitWorkflow = resolveSubmitWorkflow(dependencies);
+	const runId = submitRunId(options, dependencies);
+	const task = normalizeTask(options.task);
+	const context = await resolveSubmissionContext(options, dependencies, runId);
+	const scheduleYaml = await graphScheduleYaml(options, dependencies, runId, taskDescription(task));
 	const workflowId = scheduleWorkflowId(options, scheduleYaml);
-	return submitWorkflow({
+	const result = await submitWorkflow({
 		...workflowSubmitOptions(options),
 		config: options.config,
 		generateName: options.generateName ?? `moka-${options.mode}-`,
 		payloadJson: runnerPayloadJson({
-			git,
+			context,
 			options,
 			submission: {
 				kind: "graph",
 				mode: options.mode
 			},
-			task: options.task,
+			task,
 			runId,
 			workflowId
 		}),
 		scheduleYaml
 	});
+	return mokaSubmitResultSchema.parse(result);
 }
 async function submitMokaCommand(options, dependencies) {
-	const git = await resolveGit(options.worktreePath, dependencies);
-	const task = options.task ?? options.commandArgv.join(" ");
-	const submitWorkflow = dependencies.submitWorkflow ?? submitRunnerArgoWorkflow;
-	const runId = generateRunId(dependencies);
+	const runId = submitRunId(options, dependencies);
+	const task = commandTask(options);
+	const context = await resolveSubmissionContext(options, dependencies, runId);
+	const submitWorkflow = resolveSubmitWorkflow(dependencies);
 	const scheduleYaml = buildCommandScheduleYaml({
 		command: options.commandArgv,
 		scheduleId: runId,
-		task
+		task: taskDescription(task)
 	});
 	const workflowId = scheduleWorkflowId(options, scheduleYaml);
-	return submitWorkflow({
+	const result = await submitWorkflow({
 		...workflowSubmitOptions(options),
 		config: options.config,
 		generateName: options.generateName ?? "moka-command-",
 		payloadJson: runnerPayloadJson({
-			git,
+			context,
 			options,
 			submission: {
 				argv: options.commandArgv,
@@ -106,66 +135,129 @@ async function submitMokaCommand(options, dependencies) {
 		}),
 		scheduleYaml
 	});
+	return mokaSubmitResultSchema.parse(result);
 }
-async function graphScheduleYaml(options, dependencies, runId) {
-	const readFile = dependencies.readFile ?? ((path) => readFileSync(path, "utf8"));
-	if (options.schedulePath) return readFile(options.schedulePath);
-	const schedule = await (dependencies.generateSchedule ?? generateScheduleArtifact)({
+async function graphScheduleYaml(options, dependencies, runId, task) {
+	const explicitScheduleYaml = readExplicitGraphScheduleYaml(options, dependencies);
+	if (explicitScheduleYaml) return explicitScheduleYaml;
+	const worktreePath = requireScheduleWorktreePath(options);
+	return readScheduleFile(dependencies, resolve(worktreePath, (await (dependencies.generateSchedule ?? generateScheduleArtifact)({
 		config: options.config,
 		entrypointId: options.mode === "quick" ? "quick" : "execute",
 		runId,
-		task: options.task,
-		worktreePath: options.worktreePath
-	});
-	return readFile(resolve(options.worktreePath, schedule.path));
+		task,
+		worktreePath
+	})).path));
+}
+function readExplicitGraphScheduleYaml(options, dependencies) {
+	if (options.scheduleYaml) return options.scheduleYaml;
+	if (options.schedulePath) return readScheduleFile(dependencies, options.schedulePath);
+	return null;
+}
+function readScheduleFile(dependencies, path) {
+	return (dependencies.readFile ?? ((filePath) => readFileSync(filePath, "utf8")))(path);
+}
+function requireScheduleWorktreePath(options) {
+	if (!options.worktreePath) throw new Error("worktreePath is required when moka submit generates a graph schedule");
+	return options.worktreePath;
 }
 function scheduleWorkflowId(options, scheduleYaml) {
 	return compileScheduleArtifact(options.config, parseScheduleArtifact(scheduleYaml, "schedule.yaml"), options.worktreePath).workflowId;
 }
 function workflowSubmitOptions(options) {
 	return {
-		eventAuthSecretKey: MOMOKAYA_EVENT_AUTH_SECRET_KEY,
-		eventAuthSecretName: MOMOKAYA_EVENT_AUTH_SECRET_NAME,
-		githubAuthSecretName: MOMOKAYA_GITHUB_AUTH_SECRET_NAME,
+		eventAuthSecretKey: options.eventAuthSecretKey,
+		eventAuthSecretName: options.eventAuthSecretName,
+		githubAuthSecretName: options.githubAuthSecretName,
 		image: options.image,
 		imagePullPolicy: options.imagePullPolicy,
 		imagePullSecretName: options.imagePullSecretName,
 		kubeconfigPath: options.kubeconfigPath,
 		name: options.name,
 		namespace: options.namespace,
-		opencodeAuthSecretName: MOMOKAYA_OPENCODE_AUTH_SECRET_NAME,
+		opencodeAuthSecretName: options.opencodeAuthSecretName,
 		queueName: options.queueName,
 		serviceAccountName: options.serviceAccountName
 	};
 }
 function runnerPayloadJson(input) {
 	return JSON.stringify(buildRunnerCommandPayload({
-		delivery: { pullRequest: false },
+		delivery: input.options.delivery,
 		events: runnerEvents(input.options),
 		repository: {
-			baseBranch: input.git.baseBranch,
-			sha: input.git.sha,
-			url: input.git.url
+			baseBranch: input.context.repository.baseBranch,
+			sha: input.context.repository.sha,
+			url: input.context.repository.url
 		},
 		run: {
 			id: input.runId,
-			project: input.git.project
+			project: input.context.run.project,
+			requestedBy: input.context.run.requestedBy
 		},
 		submission: input.submission,
-		task: {
-			kind: "prompt",
-			prompt: input.task
-		},
+		task: input.task,
 		workflow: { id: input.workflowId }
 	}));
 }
 function runnerEvents(options) {
+	if (options.events) return {
+		authHeader: options.events.authHeader,
+		authTokenFile: options.events.authTokenFile ?? eventAuthTokenFile(options),
+		url: options.events.url
+	};
 	return {
 		authHeader: "Authorization",
-		authTokenFile: `/etc/pipeline/event-auth/${MOMOKAYA_EVENT_AUTH_SECRET_KEY}`,
+		authTokenFile: eventAuthTokenFile(options),
 		url: options.eventUrl
 	};
 }
+function eventAuthTokenFile(options) {
+	return `/etc/pipeline/event-auth/${options.eventAuthSecretKey}`;
+}
+async function resolveSubmissionContext(options, dependencies, runId) {
+	const explicitContext = explicitSubmissionContext(options);
+	if (explicitContext) return explicitContext;
+	const git = await resolveRequiredGit(options, dependencies);
+	return {
+		repository: repositoryContext(options, git),
+		run: runContext(options, git, runId)
+	};
+}
+function explicitSubmissionContext(options) {
+	if (!(options.repository && options.run)) return null;
+	return {
+		repository: 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 options.repository ?? {
+		baseBranch: git.baseBranch,
+		sha: git.sha,
+		url: git.url
+	};
+}
+function runContext(options, git, runId) {
+	return options.run ?? {
+		id: runId,
+		project: git.project
+	};
+}
+function normalizeTask(task) {
+	if (typeof task === "string") return {
+		kind: "prompt",
+		prompt: task
+	};
+	return task;
+}
+function taskDescription(task) {
+	if (task.kind === "prompt") return task.prompt;
+	return task.title ? `${task.id} ${task.title}` : task.id;
+}
 async function resolveGit(worktreePath, dependencies) {
 	if (dependencies.resolveGitContext) return dependencies.resolveGitContext(worktreePath);
 	const git = simpleGit({ baseDir: worktreePath });
@@ -187,4 +279,4 @@ function generateRunId(dependencies) {
 	return dependencies.generateRunId?.() ?? `run-${randomBytes(8).toString("hex")}`;
 }
 //#endregion
-export { submitMoka };
+export { mokaSubmitOptionsSchema, mokaSubmitResultSchema, submitMoka };

package/dist/opencode-project-config.js

@@ -0,0 +1,84 @@
+import { applyEdits, modify, parse } from "jsonc-parser";
+//#region src/opencode-project-config.ts
+const JSON_FORMAT_OPTIONS = {
+	insertSpaces: true,
+	tabSize: 2
+};
+function mergeOpenCodeProjectConfig(currentText, projection) {
+	if (currentText === void 0) return {
+		content: formatJson(projection),
+		ok: true
+	};
+	const parsed = parseOpenCodeProjectConfig(currentText);
+	if (!parsed.ok) return parsed;
+	return {
+		content: ensureTrailingNewline(applyOpenCodeProjection(currentText, parsed.value, projection)),
+		ok: true
+	};
+}
+function parseOpenCodeProjectConfig(currentText) {
+	const errors = [];
+	const value = parse(currentText, errors, {
+		allowTrailingComma: true,
+		disallowComments: false
+	});
+	if (errors.length > 0 || !isRecord(value)) return {
+		errors,
+		ok: false
+	};
+	return {
+		ok: true,
+		value
+	};
+}
+function applyOpenCodeProjection(currentText, parsed, projection) {
+	return applyPluginProjection(applyMcpProjection(setIfMissing(setIfMissing(currentText, parsed, ["$schema"], projection.$schema), parsed, ["lsp"], projection.lsp), parsed, projection), parsed, projection);
+}
+function applyMcpProjection(content, parsed, projection) {
+	return Object.entries(projection.mcp ?? {}).reduce((nextContent, [name, server]) => setIfMissing(nextContent, parsed, ["mcp", name], server), content);
+}
+function applyPluginProjection(content, parsed, projection) {
+	const plugins = mergePluginEntries(parsed.plugin, projection.plugin ?? []);
+	return plugins.length > 0 ? applyJsonEdit(content, ["plugin"], plugins) : content;
+}
+function setIfMissing(content, parsed, path, value) {
+	if (value === void 0 || hasPath(parsed, path)) return content;
+	return applyJsonEdit(content, path, value);
+}
+function hasPath(value, path) {
+	let cursor = value;
+	for (const segment of path) {
+		if (!(isRecord(cursor) && segment in cursor)) return false;
+		cursor = cursor[segment];
+	}
+	return true;
+}
+function mergePluginEntries(existing, projected) {
+	const merged = Array.isArray(existing) ? [...existing] : [];
+	const seen = new Set(merged.map(pluginKey));
+	for (const plugin of projected) {
+		const key = pluginKey(plugin);
+		if (seen.has(key)) continue;
+		merged.push(plugin);
+		seen.add(key);
+	}
+	return merged;
+}
+function pluginKey(value) {
+	if (Array.isArray(value)) return typeof value[0] === "string" ? value[0] : JSON.stringify(value);
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+function applyJsonEdit(content, path, value) {
+	return applyEdits(content, modify(content, path, value, { formattingOptions: JSON_FORMAT_OPTIONS }));
+}
+function formatJson(value) {
+	return `${JSON.stringify(value, null, 2)}\n`;
+}
+function ensureTrailingNewline(value) {
+	return value.endsWith("\n") ? value : `${value}\n`;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { mergeOpenCodeProjectConfig };

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

@@ -2,6 +2,7 @@ import { PipelineRuntimeEvent } from "./runtime/contracts/contracts.js";
 import { z } from "zod";
 
 //#region src/runner-command-contract.d.ts
+declare const gitRemoteUrlSchema: z.ZodString;
 declare const runnerRunIdentitySchema: z.ZodObject<{
   id: z.ZodString;
   project: z.ZodString;
@@ -10,6 +11,17 @@ declare const runnerRunIdentitySchema: z.ZodObject<{
 declare const runnerWorkflowIdentitySchema: z.ZodObject<{
   id: z.ZodString;
 }, z.core.$strict>;
+declare const runnerTaskPromptSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"prompt">;
+  prompt: z.ZodString;
+  title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const runnerTaskTicketSchema: z.ZodObject<{
+  id: z.ZodString;
+  kind: z.ZodLiteral<"ticket">;
+  path: z.ZodOptional<z.ZodString>;
+  title: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 declare const runnerTaskSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"prompt">;
   prompt: z.ZodString;
@@ -31,8 +43,8 @@ declare const runnerDeliverySchema: z.ZodObject<{
 declare const mokaSubmissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"graph">;
   mode: z.ZodEnum<{
-    quick: "quick";
     full: "full";
+    quick: "quick";
   }>;
 }, z.core.$strict>, z.ZodObject<{
   argv: z.ZodArray<z.ZodString>;
@@ -76,8 +88,8 @@ declare const runnerCommandPayloadSchema: z.ZodObject<{
   submission: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"graph">;
     mode: z.ZodEnum<{
-      quick: "quick";
       full: "full";
+      quick: "quick";
     }>;
   }, z.core.$strict>, z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;
@@ -259,4 +271,4 @@ declare function buildRunnerCommandPayload(options: BuildRunnerCommandPayloadOpt
 declare function parseRunnerCommandPayload(rawPayload: string): RunnerCommandPayload;
 declare function mapRuntimeEventToRunnerEventRecords(event: PipelineRuntimeEvent, context: RunnerEventMappingContext): RunnerEventRecord[];
 //#endregion
-export { BuildRunnerCommandPayloadOptions, MokaSubmission, ResolveRunnerEventSinkAuthTokenOptions, RunnerArtifactDetails, RunnerArtifactStatus, RunnerCommandPayload, RunnerCommandPayloadValidationError, RunnerCommandPayloadValidationIssue, RunnerDelivery, RunnerEventMappingContext, RunnerEventRecord, RunnerEvents, RunnerFinalResultDetails, RunnerGateDetails, RunnerGateStatus, RunnerHookResultDetails, RunnerLogDetails, RunnerLogLevel, RunnerMomokayaContext, RunnerNodeDetails, RunnerNodeStatus, RunnerRepositoryContext, RunnerRunIdentity, RunnerTask, RunnerWorkflowEdgeDetails, RunnerWorkflowEdgeRecordDetails, RunnerWorkflowIdentity, RunnerWorkflowNodeDetails, RunnerWorkflowPlanDetails, buildRunnerCommandPayload, mapRuntimeEventToRunnerEventRecords, parseRunnerCommandPayload, resolveRunnerEventSinkAuthToken, runnerCommandPayloadSchema };
+export { BuildRunnerCommandPayloadOptions, MokaSubmission, ResolveRunnerEventSinkAuthTokenOptions, RunnerArtifactDetails, RunnerArtifactStatus, RunnerCommandPayload, RunnerCommandPayloadValidationError, RunnerCommandPayloadValidationIssue, RunnerDelivery, RunnerEventMappingContext, RunnerEventRecord, RunnerEvents, RunnerFinalResultDetails, RunnerGateDetails, RunnerGateStatus, RunnerHookResultDetails, RunnerLogDetails, RunnerLogLevel, RunnerMomokayaContext, RunnerNodeDetails, RunnerNodeStatus, RunnerRepositoryContext, RunnerRunIdentity, RunnerTask, RunnerWorkflowEdgeDetails, RunnerWorkflowEdgeRecordDetails, RunnerWorkflowIdentity, RunnerWorkflowNodeDetails, RunnerWorkflowPlanDetails, buildRunnerCommandPayload, gitRemoteUrlSchema, mapRuntimeEventToRunnerEventRecords, parseRunnerCommandPayload, resolveRunnerEventSinkAuthToken, runnerCommandPayloadSchema, runnerDeliverySchema, runnerEventsSchema, runnerRepositoryContextSchema, runnerRunIdentitySchema, runnerTaskPromptSchema, runnerTaskSchema, runnerTaskTicketSchema, runnerWorkflowIdentitySchema };

package/dist/runner-command-contract.js

@@ -433,4 +433,4 @@ function throwUnhandledRuntimeEvent(value) {
 	throw new Error(`Unhandled runtime event: ${value.type}`);
 }
 //#endregion
-export { RunnerCommandPayloadValidationError, buildRunnerCommandPayload, mapRuntimeEventToRunnerEventRecords, parseRunnerCommandPayload, resolveRunnerEventSinkAuthToken, runnerCommandPayloadSchema };
+export { RunnerCommandPayloadValidationError, buildRunnerCommandPayload, gitRemoteUrlSchema, mapRuntimeEventToRunnerEventRecords, parseRunnerCommandPayload, resolveRunnerEventSinkAuthToken, runnerCommandPayloadSchema, runnerDeliverySchema, runnerEventsSchema, runnerRepositoryContextSchema, runnerRunIdentitySchema, runnerTaskPromptSchema, runnerTaskSchema, runnerTaskTicketSchema, runnerWorkflowIdentitySchema };

package/dist/workflow-submit-contract.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+//#region src/workflow-submit-contract.d.ts
+declare const workflowSubmitResultSchema: z.ZodObject<{
+  namespace: z.ZodString;
+  payloadConfigMapName: z.ZodString;
+  scheduleConfigMapName: z.ZodString;
+  taskDescriptorConfigMapName: z.ZodString;
+  workflowName: z.ZodString;
+  workflowUid: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+//#endregion
+export { workflowSubmitResultSchema };

package/dist/workflow-submit-contract.js

@@ -0,0 +1,12 @@
+import { z } from "zod";
+//#region src/workflow-submit-contract.ts
+const workflowSubmitResultSchema = z.object({
+	namespace: z.string().min(1),
+	payloadConfigMapName: z.string().min(1),
+	scheduleConfigMapName: z.string().min(1),
+	taskDescriptorConfigMapName: z.string().min(1),
+	workflowName: z.string().min(1),
+	workflowUid: z.string().min(1).optional()
+}).strict();
+//#endregion
+export { workflowSubmitResultSchema };

package/docs/mcp-gateway.md

@@ -94,8 +94,14 @@ contains only `pipeline-gateway`.
 OpenCode receives that gateway through `.opencode/opencode.json` alongside the
 package-owned runtime projection: `lsp: true`, pinned plugin entries, generated
 agents, projected skills, explicit permissions, and local TypeScript plugins.
-Those resources give OpenCode richer runtime assistance without changing MCP
-ownership: upstream servers still live behind the gateway.
+`moka init` and `moka install-commands` merge this OpenCode project config:
+existing repo-local plugin entries are preserved while missing package defaults
+such as `oc-codex-multi-auth` are appended. Existing `mcp.pipeline-gateway`
+settings are also preserved; use `moka mcp gateway configure-host` when the
+host MCP config must be deliberately rewritten. Restart OpenCode after config
+changes because it loads config at startup. These resources give OpenCode richer
+runtime assistance without changing MCP ownership: upstream servers still live
+behind the gateway.
 
 ## Candidate Gateway Implementations
 
@@ -112,7 +118,9 @@ local ToolHive availability for local mode, and legacy direct MCP entries. Use
 singleton `pipeline-gateway` remote entry. Use `moka install-commands --host all`
 to refresh generated host files after package upgrades, and use
 `moka mcp gateway configure-host` as an explicit migration or repair command
-when existing host MCP config must be rewritten with a backup.
+when existing host MCP config must be rewritten with a backup. The hosted gateway
+requires `PIPELINE_MCP_GATEWAY_AUTHORIZATION` to be set in the OpenCode
+environment.
 
 The package-owned MCP inventory exposed through the ecosystem manifest includes
 `pipeline-gateway`, Context7, uidotsh, Qdrant, Fallow, Serena, Backlog, GitHub,

package/docs/operator-guide.md

@@ -342,10 +342,15 @@ moka mcp gateway local-status
 moka mcp gateway local-start
 ```
 
-`moka init` writes generated command surfaces and the singleton gateway server
-into project host config. Use `moka mcp gateway configure-host` as an explicit
-migration or repair command when direct upstream MCP entries need to be removed
-from existing host config with a backup.
+`moka init` writes generated command surfaces and merges the singleton gateway
+server into project host config. For OpenCode, existing repo-local plugin entries
+are preserved while missing package defaults such as `oc-codex-multi-auth` are
+appended, and an existing `mcp.pipeline-gateway` entry is preserved. Use
+`moka mcp gateway configure-host` as an explicit migration or repair command
+when direct upstream MCP entries need to be removed from existing host config
+with a backup. The hosted gateway requires `PIPELINE_MCP_GATEWAY_AUTHORIZATION`
+in the OpenCode environment. Restart OpenCode after config changes because it
+loads config at startup.
 
 ## Profile Grant Rules
 

package/package.json

@@ -8,15 +8,16 @@
     "execa": "^9.5.2",
     "git-url-parse": "^16.1.0",
     "gray-matter": "^4.0.3",
+    "jsonc-parser": "^3.3.1",
     "ky": "^2.0.2",
     "micromatch": "^4.0.8",
     "p-limit": "^7.3.0",
     "package-manager-detector": "^1.6.0",
     "secure-json-parse": "^4.1.0",
     "simple-git": "^3.36.0",
-    "zod": "^4.4.3",
     "xstate": "^5.31.1",
-    "yaml": "^2.9.0"
+    "yaml": "^2.9.0",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.15",
@@ -65,6 +66,10 @@
       "types": "./dist/hooks.d.ts",
       "import": "./dist/hooks.js"
     },
+    "./moka-submit": {
+      "types": "./dist/moka-submit.d.ts",
+      "import": "./dist/moka-submit.js"
+    },
     "./planner": {
       "types": "./dist/workflow-planner.d.ts",
       "import": "./dist/workflow-planner.js"
@@ -115,7 +120,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",