@oisincoveney/pipeline 2.8.4 → 2.9.0

package/dist/commands/pipeline-command.js

@@ -1,3 +1,4 @@
+import { Context, Effect, Layer } from "effect";
 //#region src/commands/pipeline-command.ts
 const BUILTIN_PIPE_COMMANDS = new Set([
 	"run",
@@ -11,16 +12,32 @@ const BUILTIN_PIPE_COMMANDS = new Set([
 	"argo",
 	"runner-command"
 ]);
+var EntrypointCommandService = class extends Context.Tag("EntrypointCommandService")() {};
+const createEntrypointCommandServiceLive = (runEntrypoint) => Layer.succeed(EntrypointCommandService, { runEntrypoint: (entrypoint, task, opts) => Effect.tryPromise({
+	catch: (error) => error,
+	try: () => runEntrypoint(entrypoint, task, opts)
+}) });
+const runConfiguredEntrypointCommand = (entrypoint, descriptionParts, flags) => Effect.gen(function* () {
+	yield* (yield* EntrypointCommandService).runEntrypoint(entrypoint, descriptionParts.join(" "), flags);
+});
+const addScheduledEntrypointOptions = (command) => command.option("--namespace <namespace>", "Workflow namespace").option("--schedule <path>", "approved schedule YAML to submit").option("--kubeconfig <path>", "kubeconfig path").option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").option("--image-pull-policy <policy>", "runner image pull policy").option("--image-pull-secret <name>", "imagePullSecret name").option("--event-url <url>", "runner event sink URL");
+const configureEntrypointOptions = (command, entrypoint) => {
+	if ("schedule" in entrypoint) return addScheduledEntrypointOptions(command);
+	return command;
+};
+const createEntrypointCommand = (program, id, entrypoint) => {
+	return configureEntrypointOptions(program.command(id).description(entrypoint.description ?? `Run the ${id} workflow`).argument("<description...>", "task description"), entrypoint);
+};
+const registerEntrypointAction = (command, id, serviceLive) => {
+	command.action((descriptionParts, flags) => Effect.runPromise(Effect.provide(runConfiguredEntrypointCommand(id, descriptionParts, flags), serviceLive)));
+};
 function registerConfiguredEntrypointCommands(program, config, runEntrypoint) {
 	const registered = /* @__PURE__ */ new Set();
+	const serviceLive = createEntrypointCommandServiceLive(runEntrypoint);
 	const reservedCommands = new Set(program.commands.map((command) => command.name()));
 	for (const [id, entrypoint] of Object.entries(config.entrypoints)) {
 		if (reservedCommands.has(id)) continue;
-		const command = program.command(id).description(entrypoint.description ?? `Run the ${id} workflow`).argument("<description...>", "task description");
-		if ("schedule" in entrypoint) command.option("--namespace <namespace>", "Workflow namespace").option("--schedule <path>", "approved schedule YAML to submit").option("--kubeconfig <path>", "kubeconfig path").option("--service-account <name>", "Workflow service account").option("--image <image>", "runner image").option("--image-pull-policy <policy>", "runner image pull policy").option("--image-pull-secret <name>", "imagePullSecret name").option("--event-url <url>", "runner event sink URL");
-		command.action(async (descriptionParts, flags) => {
-			await runEntrypoint(id, descriptionParts.join(" "), flags);
-		});
+		registerEntrypointAction(createEntrypointCommand(program, id, entrypoint), id, serviceLive);
 		registered.add(id);
 		reservedCommands.add(id);
 	}

package/dist/commands/runner-command-command.js

@@ -1,17 +1,40 @@
 import { runRunnerCommand } from "../runner-command/run.js";
 import { runRunnerFinalize } from "../runner-command/finalize.js";
 import { runRunnerLifecycle } from "../runner-command/lifecycle.js";
+import { Context, Effect, Layer } from "effect";
 //#region src/commands/runner-command-command.ts
+var RunnerCommandService = class extends Context.Tag("RunnerCommandService")() {};
+const RunnerCommandServiceLive = Layer.succeed(RunnerCommandService, {
+	finalize: (options) => Effect.tryPromise({
+		catch: (error) => error,
+		try: () => runRunnerFinalize(options)
+	}),
+	lifecycle: (options) => Effect.tryPromise({
+		catch: (error) => error,
+		try: () => runRunnerLifecycle(options)
+	}),
+	run: (options) => Effect.tryPromise({
+		catch: (error) => error,
+		try: () => runRunnerCommand(options)
+	})
+});
+const setProcessExitCode = (exitCode) => Effect.sync(() => {
+	process.exitCode = exitCode;
+});
+const runRunnerCommandEffect = (options) => Effect.gen(function* () {
+	yield* setProcessExitCode(yield* (yield* RunnerCommandService).run(options));
+});
+const runRunnerLifecycleEffect = (options) => Effect.gen(function* () {
+	yield* setProcessExitCode(yield* (yield* RunnerCommandService).lifecycle(options));
+});
+const runRunnerFinalizeEffect = (options) => Effect.gen(function* () {
+	yield* setProcessExitCode(yield* (yield* RunnerCommandService).finalize(options));
+});
+const runRunnerProgram = (program) => Effect.runPromise(Effect.provide(program, RunnerCommandServiceLive));
 function registerRunnerCommandCommand(program) {
-	program.command("runner-command").description("Run one scheduled Argo Workflow task").requiredOption("--payload-file <path>", "Path to the runner payload JSON").requiredOption("--schedule-file <path>", "Path to the schedule artifact YAML").action(async (options) => {
-		process.exitCode = await runRunnerCommand(options);
-	});
-	program.command("runner-lifecycle").description("Run one Argo Workflow lifecycle phase").requiredOption("--phase <phase>", "Lifecycle phase to run").requiredOption("--payload-file <path>", "Path to the runner payload JSON").requiredOption("--schedule-file <path>", "Path to the schedule artifact YAML").action(async (options) => {
-		process.exitCode = await runRunnerLifecycle(options);
-	});
-	program.command("runner-finalize").description("Finalize one Argo Workflow run").requiredOption("--payload-file <path>", "Path to the runner payload JSON").requiredOption("--schedule-file <path>", "Path to the schedule artifact YAML").requiredOption("--argo-status <status>", "Argo Workflow status").action(async (options) => {
-		process.exitCode = await runRunnerFinalize(options);
-	});
+	program.command("runner-command").description("Run one scheduled Argo Workflow task").requiredOption("--payload-file <path>", "Path to the runner payload JSON").requiredOption("--schedule-file <path>", "Path to the schedule artifact YAML").action((options) => runRunnerProgram(runRunnerCommandEffect(options)));
+	program.command("runner-lifecycle").description("Run one Argo Workflow lifecycle phase").requiredOption("--phase <phase>", "Lifecycle phase to run").requiredOption("--payload-file <path>", "Path to the runner payload JSON").requiredOption("--schedule-file <path>", "Path to the schedule artifact YAML").action((options) => runRunnerProgram(runRunnerLifecycleEffect(options)));
+	program.command("runner-finalize").description("Finalize one Argo Workflow run").requiredOption("--payload-file <path>", "Path to the runner payload JSON").requiredOption("--schedule-file <path>", "Path to the schedule artifact YAML").requiredOption("--argo-status <status>", "Argo Workflow status").action((options) => runRunnerProgram(runRunnerFinalizeEffect(options)));
 }
 //#endregion
 export { registerRunnerCommandCommand };

package/dist/config/lint.js

@@ -1,15 +1,22 @@
 import { resolvePackageAssetPath } from "../package-assets.js";
 import { standardOutputSchemaNameFromPath } from "../standard-output-schemas.js";
+import { FileSystemService, FileSystemServiceLive, runFileSystemSync } from "../runtime/services/file-system-service.js";
 import { BUILTIN_PIPE_COMMANDS } from "../commands/pipeline-command.js";
-import { existsSync } from "node:fs";
+import { Effect } from "effect";
 import { resolve } from "node:path";
 //#region src/config/lint.ts
 function lintPipelineConfig(config, projectRoot) {
-	return [
-		...lintShadowedEntrypoints(config),
-		...lintMissingFileReferences(config, projectRoot),
-		...lintWorkflowNodes(config)
-	];
+	return runFileSystemSync(lintPipelineConfigEffect(config, projectRoot), FileSystemServiceLive);
+}
+function lintPipelineConfigEffect(config, projectRoot) {
+	return Effect.gen(function* () {
+		const missingFiles = yield* lintMissingFileReferencesEffect(config, projectRoot);
+		return [
+			...lintShadowedEntrypoints(config),
+			...missingFiles,
+			...lintWorkflowNodes(config)
+		];
+	});
 }
 function lintShadowedEntrypoints(config) {
 	return Object.keys(config.entrypoints).filter((id) => BUILTIN_PIPE_COMMANDS.has(id)).map((id) => ({
@@ -17,31 +24,42 @@ function lintShadowedEntrypoints(config) {
 		message: `entrypoint '${id}' is shadowed by the builtin subcommand; invoke via 'moka run --entrypoint ${id} ...'`
 	}));
 }
-function lintMissingFileReferences(config, projectRoot) {
-	const refs = [];
-	for (const [skillId, skill] of Object.entries(config.skills)) refs.push({
-		path: `skills.${skillId}.path`,
-		ref: skill
+function lintMissingFileReferencesEffect(config, projectRoot) {
+	return Effect.gen(function* () {
+		const fileSystem = yield* FileSystemService;
+		const warnings = [];
+		for (const ref of lintFileReferences(config)) if (!(yield* lintFileReferenceExists(projectRoot, ref, fileSystem.exists))) warnings.push(missingFileReferenceWarning(ref.path, ref.ref.path));
+		return warnings;
 	});
+}
+function lintFileReferences(config) {
+	const refs = [];
+	for (const [skillId, skill] of Object.entries(config.skills)) pushLintPathRef(refs, `skills.${skillId}.path`, skill);
 	for (const [profileId, profile] of Object.entries(config.profiles)) {
-		refs.push({
-			path: `profiles.${profileId}.instructions.path`,
-			ref: { path: profile.instructions.path }
-		});
-		refs.push({
-			path: `profiles.${profileId}.output.schema_path`,
-			ref: { path: profile.output?.schema_path }
-		});
+		pushLintPathRef(refs, `profiles.${profileId}.instructions.path`, { path: profile.instructions.path });
+		pushLintPathRef(refs, `profiles.${profileId}.output.schema_path`, { path: profile.output?.schema_path });
 	}
-	return refs.flatMap((ref) => {
-		const value = ref.ref?.path;
-		if (!value || standardOutputSchemaNameFromPath(value) || existsSync(resolveLintPathReference(projectRoot, ref.ref))) return [];
-		return [{
-			ruleId: "missing-file-reference",
-			message: missingFileReferenceMessage(ref.path, value)
-		}];
+	return refs;
+}
+function pushLintPathRef(refs, path, ref) {
+	if (ref.path) refs.push({
+		path,
+		ref: {
+			...ref,
+			path: ref.path
+		}
 	});
 }
+function lintFileReferenceExists(projectRoot, ref, exists) {
+	if (standardOutputSchemaNameFromPath(ref.ref.path)) return Effect.succeed(true);
+	return exists(resolveLintPathReference(projectRoot, ref.ref));
+}
+function missingFileReferenceWarning(path, value) {
+	return {
+		ruleId: "missing-file-reference",
+		message: missingFileReferenceMessage(path, value)
+	};
+}
 function missingFileReferenceMessage(path, value) {
 	const base = `${path} references missing file '${value}'`;
 	if (path.startsWith("skills.") && value.startsWith(".agents/skills/")) return `${base}. Run \`moka init\` to install project-local skills with \`npx --yes skills add oisin-ee/skills\`.`;

package/dist/context/repo-map.js

@@ -1,10 +1,11 @@
+import { RepoIoService, RepoIoServiceLive } from "../runtime/services/repo-io-service.js";
 import { estimateTokens } from "../token-estimator.js";
 import { createRequire } from "node:module";
-import { readFileSync, readdirSync, statSync } from "node:fs";
+import { Effect } from "effect";
 import { extname, join, relative } from "node:path";
+import { Query } from "web-tree-sitter";
 import Graph from "graphology";
 import pagerank from "graphology-metrics/centrality/pagerank.js";
-import { Language, Parser, Query } from "web-tree-sitter";
 //#region src/context/repo-map.ts
 const SOURCE_EXTENSIONS = new Set([
 	".cjs",
@@ -23,62 +24,71 @@ const SKIP_DIRS = new Set([
 const SEED_BONUS = 1;
 const WORD_RE = /[a-z_][a-z0-9_]+/gi;
 const require = createRequire(import.meta.url);
-let parserPromise = null;
-const languageCache = /* @__PURE__ */ new Map();
 const queryCache = /* @__PURE__ */ new Map();
-function getParser() {
-	parserPromise ??= Parser.init().then(() => new Parser());
-	return parserPromise;
-}
-function loadLanguage(grammar) {
-	const cached = languageCache.get(grammar);
-	if (cached) return cached;
-	const promise = Language.load(require.resolve(`tree-sitter-${grammar}/tree-sitter-${grammar}.wasm`));
-	languageCache.set(grammar, promise);
-	return promise;
-}
-function tagsQuery(language, grammar) {
+function tagsQueryEffect(language, grammar) {
 	const cached = queryCache.get(grammar);
-	if (cached) return cached;
-	const query = new Query(language, `${readFileSync(require.resolve("tree-sitter-javascript/queries/tags.scm"), "utf8")}\n${readFileSync(require.resolve("tree-sitter-typescript/queries/tags.scm"), "utf8")}`);
-	queryCache.set(grammar, query);
-	return query;
+	if (cached) return Effect.succeed(cached);
+	return Effect.gen(function* () {
+		const service = yield* RepoIoService;
+		const js = yield* service.readText(require.resolve("tree-sitter-javascript/queries/tags.scm"));
+		const ts = yield* service.readText(require.resolve("tree-sitter-typescript/queries/tags.scm"));
+		const query = yield* Effect.try({
+			catch: (error) => error,
+			try: () => new Query(language, `${js}\n${ts}`)
+		});
+		queryCache.set(grammar, query);
+		return query;
+	});
 }
 function grammarFor(file) {
 	const ext = extname(file);
 	return ext === ".ts" || ext === ".tsx" ? "typescript" : "javascript";
 }
-function discoverFiles(root) {
-	const found = [];
-	walkDir(root, found);
-	return found.sort();
+function discoverFilesEffect(root) {
+	return Effect.gen(function* () {
+		const found = [];
+		yield* walkDirEffect(root, found);
+		return found.sort();
+	});
 }
-function walkDir(dir, found) {
-	for (const entry of readdirSync(dir).sort()) handleEntry(join(dir, entry), entry, found);
+function walkDirEffect(dir, found) {
+	return Effect.gen(function* () {
+		const service = yield* RepoIoService;
+		for (const entry of yield* service.readDir(dir)) yield* handleEntryEffect(join(dir, entry.name), entry.name, found);
+	});
 }
-function handleEntry(full, name, found) {
-	if (SKIP_DIRS.has(name)) return;
-	if (statSync(full).isDirectory()) {
-		walkDir(full, found);
-		return;
-	}
+function handleEntryEffect(full, name, found) {
+	if (SKIP_DIRS.has(name)) return Effect.void;
+	return Effect.gen(function* () {
+		if (yield* (yield* RepoIoService).isDirectory(full)) return yield* walkDirEffect(full, found);
+		addSourceFile(full, name, found);
+	});
+}
+function addSourceFile(full, name, found) {
 	if (SOURCE_EXTENSIONS.has(extname(name))) found.push(full);
 }
-async function tagFile(root, file) {
-	const parser = await getParser();
+function tagFileEffect(root, file) {
+	return Effect.gen(function* () {
+		const service = yield* RepoIoService;
+		return yield* parseFileTags(root, file, yield* service.createParser(), yield* service.readText(file));
+	});
+}
+function parseFileTags(root, file, parser, content) {
 	const grammar = grammarFor(file);
-	const language = await loadLanguage(grammar);
-	parser.setLanguage(language);
 	const path = relative(root, file);
-	const tree = parser.parse(readFileSync(file, "utf8"));
-	const tags = {
-		definitions: [],
-		path,
-		references: []
-	};
-	if (!tree) return tags;
-	for (const match of tagsQuery(language, grammar).matches(tree.rootNode)) addMatch(tags, path, match);
-	return tags;
+	return Effect.gen(function* () {
+		const language = yield* (yield* RepoIoService).loadLanguage(require.resolve(`tree-sitter-${grammar}/tree-sitter-${grammar}.wasm`));
+		parser.setLanguage(language);
+		const tree = parser.parse(content);
+		const tags = {
+			definitions: [],
+			path,
+			references: []
+		};
+		const query = yield* tagsQueryEffect(language, grammar);
+		if (tree) for (const match of query.matches(tree.rootNode)) addMatch(tags, path, match);
+		return tags;
+	});
 }
 function addMatch(tags, path, match) {
 	const nameCapture = match.captures.find((c) => c.name === "name");
@@ -187,17 +197,23 @@ function selectWithinBudget(ranked, budget, estimateTokens) {
 		selected
 	};
 }
-async function buildRepoMapContext(input) {
-	const estimateTokens$1 = input.estimateTokens ?? estimateTokens;
-	const ranked = rankDefinitions(buildGraph(await Promise.all(discoverFiles(input.worktreePath).map((file) => tagFile(input.worktreePath, file))), input));
-	const { context, estimatedTokens, selected } = selectWithinBudget(ranked, input.tokenBudget, estimateTokens$1);
-	return {
-		budget: input.tokenBudget,
-		context,
-		estimatedTokens,
-		selected,
-		totalRanked: ranked.length
-	};
+function buildRepoMapContext(input) {
+	return Effect.runPromise(Effect.provide(buildRepoMapContextEffect(input), RepoIoServiceLive));
+}
+function buildRepoMapContextEffect(input) {
+	return Effect.gen(function* () {
+		const estimateTokens$1 = input.estimateTokens ?? estimateTokens;
+		const files = yield* discoverFilesEffect(input.worktreePath);
+		const ranked = rankDefinitions(buildGraph(yield* Effect.all(files.map((file) => tagFileEffect(input.worktreePath, file)), { concurrency: "unbounded" }), input));
+		const { context, estimatedTokens, selected } = selectWithinBudget(ranked, input.tokenBudget, estimateTokens$1);
+		return {
+			budget: input.tokenBudget,
+			context,
+			estimatedTokens,
+			selected,
+			totalRanked: ranked.length
+		};
+	});
 }
 //#endregion
 export { buildRepoMapContext };

package/dist/gates.js

@@ -1,7 +1,7 @@
 import "./safe-json.js";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import "execa";
+import { join } from "node:path";
 import "package-manager-detector/commands";
 import "package-manager-detector/detect";
 //#region src/gates.ts

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { createCliProgram, execute, quick, runCli, runDoctor } from "./cli/program.js";
+import { runDoctor } from "./cli/doctor.js";
+import { createCliProgram, execute, quick, runCli } from "./cli/program.js";
 
 //#region src/index.d.ts
 declare function isCliEntrypoint(argv: string[]): boolean;

package/dist/index.js

@@ -2,7 +2,9 @@
 import { PipelineConfigError } from "./config/schemas.js";
 import "./config.js";
 import { formatConfigError } from "./pipeline-runtime.js";
-import { createCliProgram, execute, quick, runCli, runDoctor } from "./cli/program.js";
+import { runDoctor } from "./cli/doctor.js";
+import { createCliProgram, execute, quick, runCli, runCliEffect } from "./cli/program.js";
+import { Cause, Effect, Exit } from "effect";
 import { existsSync, realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -21,20 +23,24 @@ function normalizeEntrypointPath(path) {
 	const resolved = resolve(path);
 	return existsSync(resolved) ? realpathSync(resolved) : resolved;
 }
-if (isCliEntrypoint(process.argv)) runCli(process.argv).catch((err) => {
-	if (err instanceof CommanderError) process.exit(err.exitCode);
-	if (hasExitCode(err)) {
-		if (err.message) console.error(err.message);
-		process.exit(err.exitCode);
-	}
-	if (err instanceof Error) {
-		if (err instanceof PipelineConfigError) console.error(formatConfigError(err));
-		else console.error(err.message);
-		process.exit(1);
-	}
-	console.error(String(err));
-	process.exit(1);
+if (isCliEntrypoint(process.argv)) Effect.runPromiseExit(runCliEffect(process.argv)).then((exit) => {
+	if (Exit.isFailure(exit)) handleCliFailure(Cause.squash(exit.cause));
 });
+function handleCliFailure(err) {
+	const message = cliErrorMessage(err);
+	if (message) console.error(message);
+	process.exit(cliErrorCode(err));
+}
+function cliErrorCode(err) {
+	if (err instanceof CommanderError || hasExitCode(err)) return err.exitCode;
+	return 1;
+}
+function cliErrorMessage(err) {
+	if (err instanceof CommanderError) return;
+	if (err instanceof PipelineConfigError) return formatConfigError(err);
+	if (err instanceof Error) return err.message;
+	return String(err);
+}
 function hasExitCode(err) {
 	return err instanceof Error && "exitCode" in err && typeof err.exitCode === "number";
 }

package/dist/install-commands/claude-code.js

@@ -2,10 +2,10 @@ import { renderClaudeGatewayMcpServers } from "../mcp/gateway.js";
 import { opencodeAgentName } from "../runtime/opencode-agent-name.js";
 import { mergeClaudeSettings } from "../claude-settings-config.js";
 import { CLAUDE_PROJECT_CONFIG_PATH, commandIdForHost, compactLines, entrypointDescription, entrypointEntries, instructionsPointer, invocationForHost } from "./shared.js";
-import { agentDispatchRoutes, entrypointDispatchBlock, grants, header, markdown, projectAgentsMdDefinition, resolvedHostModel, scheduledEntrypointK8sNote } from "./opencode.js";
+import { agentDispatchRoutes, entrypointDispatchBlock, grants, header, markdown, projectAgentsMdDefinition, resolvedHostModel } from "./opencode.js";
 //#region src/install-commands/claude-code.ts
 const CLAUDE_CODE_HOST = "claude-code";
-const CLAUDE_ALLOWED_TOOLS = "Task, Bash(opencode run *)";
+const CLAUDE_ALLOWED_TOOLS = "Bash(moka run *)";
 const CLAUDE_AGENT_TOOLS = "Bash, Read";
 const MOKA_PROFILE_PREFIX = "moka-";
 function claudeAgentNameForProfile(profileId) {
@@ -25,34 +25,7 @@ function distinctCliProfiles(config) {
 	return profiles.sort((a, b) => a.profileId.localeCompare(b.profileId));
 }
 function commandDispatchBody(config, id, entrypoint) {
-	if (!("workflow" in entrypoint)) return entrypointDispatchBlock(CLAUDE_CODE_HOST, config, id, entrypoint) ?? "";
-	const routes = agentDispatchRoutes(CLAUDE_CODE_HOST, config, entrypoint.workflow);
-	return [
-		`Run workflow \`${entrypoint.workflow}\` for the user task.`,
-		"",
-		"Delegate each agent node to a Claude Code `Task` subagent that wraps a local `opencode run` subprocess.",
-		"Spawn one node at a time respecting `needs`; run nodes whose dependencies are satisfied in parallel.",
-		"",
-		"Node routes:",
-		...routes.map(claudeNodeRouteLine),
-		"",
-		"For each node prompt include:",
-		"- user task",
-		`- workflow id: ${entrypoint.workflow}`,
-		"- node id",
-		"- profile id",
-		"- profile instructions reference",
-		"- profile grants",
-		"- dependency outputs",
-		"",
-		"Only package-configured gates are blocking. Do not invent RED, GREEN, full-suite, typecheck, or unrelated-drift gates.",
-		"If a node returns targeted evidence and has no configured blocking gate, advance to the next node.",
-		"The Task subagents wrap `opencode run` subprocesses; do not claim these worker nodes are Claude Code native agents."
-	].join("\n");
-}
-function claudeNodeRouteLine(route) {
-	const needs = route.needs.length > 0 ? route.needs.join(",") : "none";
-	return `- ${route.nodeId}: Task subagent_type=${claudeAgentNameForProfile(route.profileId)} runner=${route.runnerId} agent="${opencodeAgentName(route.profileId)}" needs=${needs}`;
+	return entrypointDispatchBlock(CLAUDE_CODE_HOST, config, id, entrypoint) ?? "";
 }
 function commandDefinitions(config) {
 	return entrypointEntries(config).map(([id, entrypoint]) => ({
@@ -67,8 +40,6 @@ function commandDefinitions(config) {
 			"",
 			"Load and follow the `execute` skill for the execution doctrine before dispatching work.",
 			"",
-			scheduledEntrypointK8sNote(entrypoint),
-			scheduledEntrypointK8sNote(entrypoint) ? "" : void 0,
 			commandDispatchBody(config, id, entrypoint)
 		]).join("\n")),
 		host: CLAUDE_CODE_HOST,
@@ -113,7 +84,7 @@ function agentDefinitions(config) {
 	});
 }
 function settingsDefinition(config) {
-	const settings = { permissions: { allow: ["Task", "Bash(opencode run *)"] } };
+	const settings = { permissions: { allow: ["Bash(moka run *)"] } };
 	if (config.mcp_gateway) settings.mcpServers = renderClaudeGatewayMcpServers(config);
 	return [{
 		content: `${JSON.stringify(settings, null, 2)}\n`,