@oisincoveney/pipeline 2.0.0 → 2.1.0

package/dist/config/defaults.js

@@ -73,6 +73,9 @@ skills:
   quick:
     path: .agents/skills/quick/SKILL.md
     source_root: package
+  claude-code-opencode-execute:
+    path: .agents/skills/claude-code-opencode-execute/SKILL.md
+    source_root: package
   critique:
     path: .agents/skills/critique/SKILL.md
     source_root: package
@@ -141,6 +144,7 @@ profiles:
       repair: { enabled: true, max_attempts: 1 }
   moka-inspector:
     runner: opencode
+    model: openai/gpt-5.5-low
     description: Inspect the repository without modifying files.
     instructions: { inline: "Inspect the repository without modifying files." }
     skills: [research]
@@ -150,6 +154,7 @@ profiles:
     network: { mode: inherit }
   moka-schedule-planner:
     runner: opencode
+    model: openai/gpt-5.5-xhigh
     description: Refine a baseline schedule into a specialized approved-plan artifact.
     instructions: { inline: "Generate exactly one workflow named root as an explicit schedule graph. Return YAML only." }
     timeout_ms: 300000
@@ -230,6 +235,7 @@ profiles:
       repair: { enabled: true, max_attempts: 1 }
   moka-learner:
     runner: opencode
+    model: openai/gpt-5.5-low
     description: Store durable lessons from the completed run.
     instructions: { inline: "Store durable lessons from the completed run when useful." }
     skills: [migrate]
@@ -289,54 +295,54 @@ scheduler:
         backlog-intake:
           category: intake
           profile: moka-researcher
-          models: [openai/gpt-5.5-fast]
+          models: [openai/gpt-5.5-medium]
         red-tests:
           category: red
           profile: moka-test-writer
-          models: [openai/gpt-5.5, kimi-for-coding/kimi-k2-thinking]
+          models: [openai/gpt-5.5-high, kimi-for-coding/kimi-k2-thinking]
         green-implementation:
           category: green
           profile: moka-code-writer
-          models: [openai/gpt-5.5, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
+          models: [openai/gpt-5.5-high, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
         verification:
           category: verification
           profile: moka-verifier
-          models: [openai/gpt-5.5]
+          models: [openai/gpt-5.5-medium]
     execute:
       required_categories: [intake, research, red, green, mechanical, acceptance, verification, learn]
       nodes:
         backlog-intake:
           category: intake
           profile: moka-researcher
-          models: [openai/gpt-5.5-fast]
+          models: [openai/gpt-5.5-medium]
         research:
           category: research
           profile: moka-researcher
-          models: [openai/gpt-5.5-fast, kimi-for-coding/k2p6]
+          models: [openai/gpt-5.5-medium, kimi-for-coding/k2p6]
         red-tests:
           category: red
           profile: moka-test-writer
-          models: [openai/gpt-5.5, kimi-for-coding/kimi-k2-thinking]
+          models: [openai/gpt-5.5-high, kimi-for-coding/kimi-k2-thinking]
         green-backend:
           category: green
           profile: moka-code-writer
-          models: [openai/gpt-5.5, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
+          models: [openai/gpt-5.5-high, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
         green-frontend:
           category: green
           profile: moka-code-writer
-          models: [openai/gpt-5.5, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
+          models: [openai/gpt-5.5-high, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
         acceptance-review:
           category: acceptance
           profile: moka-acceptance-reviewer
-          models: [openai/gpt-5.5]
+          models: [openai/gpt-5.5-medium]
         verification:
           category: verification
           profile: moka-verifier
-          models: [openai/gpt-5.5]
+          models: [openai/gpt-5.5-medium]
         learn:
           category: learn
           profile: moka-learner
-          models: [openai/gpt-5.5-fast]
+          models: [openai/gpt-5.5-low]
 schedules:
   quick-schedule:
     baseline: quick
@@ -385,6 +391,29 @@ const ecosystemCodeSchema = z.object({
 	role: z.string().min(1),
 	source: z.string().url()
 }).strict();
+const ecosystemProviderModelOptionsSchema = z.object({
+	include: ecosystemStringArraySchema,
+	reasoningEffort: z.enum([
+		"none",
+		"low",
+		"medium",
+		"high",
+		"xhigh"
+	]),
+	reasoningSummary: z.enum(["auto", "detailed"]),
+	store: z.literal(false),
+	textVerbosity: z.enum([
+		"low",
+		"medium",
+		"high"
+	])
+}).strict();
+const ecosystemProviderModelSchema = z.object({
+	id: z.string().min(1),
+	options: ecosystemProviderModelOptionsSchema,
+	provider: z.string().min(1),
+	role: z.string().min(1)
+}).strict();
 const ecosystemMcpBackendSchema = z.object({
 	credentials: ecosystemStringArraySchema,
 	id: z.string().min(1),
@@ -421,6 +450,7 @@ const openCodeEcosystemManifestSchema = z.object({
 	mcp_backends: z.array(ecosystemMcpBackendSchema).min(1),
 	official_dependencies: z.array(ecosystemDependencySchema).min(1),
 	prompts: z.array(ecosystemProfileResourceSchema).min(1),
+	provider_models: z.array(ecosystemProviderModelSchema).min(1),
 	runtime: ecosystemRuntimeSchema,
 	skills: z.array(ecosystemProfileResourceSchema).min(1),
 	sources: z.array(ecosystemSourceSchema).min(1),

package/dist/config/schemas.d.ts

@@ -310,6 +310,7 @@ declare const configSchema: z.ZodObject<{
     skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
     tools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+      task: "task";
       read: "read";
       list: "list";
       grep: "grep";
@@ -317,7 +318,6 @@ declare const configSchema: z.ZodObject<{
       bash: "bash";
       edit: "edit";
       write: "write";
-      task: "task";
     }>>>;
   }, z.core.$strict>>>;
   runner_command: z.ZodDefault<z.ZodObject<{
@@ -343,8 +343,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<{
@@ -369,6 +369,7 @@ declare const configSchema: z.ZodObject<{
       rules: z.ZodOptional<z.ZodBoolean>;
       skills: z.ZodOptional<z.ZodBoolean>;
       tools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        task: "task";
         read: "read";
         list: "list";
         grep: "grep";
@@ -376,7 +377,6 @@ declare const configSchema: z.ZodObject<{
         bash: "bash";
         edit: "edit";
         write: "write";
-        task: "task";
       }>>>;
     }, z.core.$strict>;
     command: z.ZodOptional<z.ZodString>;
@@ -471,8 +471,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>;
@@ -484,8 +484,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/claude-code.js

@@ -0,0 +1,24 @@
+import { resolvePackageAssetPath } from "../package-assets.js";
+import { GENERATED_MARKER, OWNER_MARKER_PREFIX, invocationForHost } from "./shared.js";
+import { readFileSync } from "node:fs";
+//#region src/install-commands/claude-code.ts
+const CLAUDE_CODE_OPENCODE_EXECUTE_SKILL = "claude-code-opencode-execute";
+const PACKAGE_SKILL_PATH = `.agents/skills/${CLAUDE_CODE_OPENCODE_EXECUTE_SKILL}/SKILL.md`;
+function generatedClaudeSkillContent() {
+	return readFileSync(resolvePackageAssetPath(PACKAGE_SKILL_PATH), "utf8").replace("# Claude Code OpenCode Execute", [
+		GENERATED_MARKER,
+		`${OWNER_MARKER_PREFIX}host=claude-code -->`,
+		"",
+		"# Claude Code OpenCode Execute"
+	].join("\n"));
+}
+function claudeCodeDefinitions() {
+	return [{
+		content: generatedClaudeSkillContent(),
+		host: "claude-code",
+		invocation: invocationForHost("claude-code", CLAUDE_CODE_OPENCODE_EXECUTE_SKILL),
+		path: `.claude/skills/${CLAUDE_CODE_OPENCODE_EXECUTE_SKILL}/SKILL.md`
+	}];
+}
+//#endregion
+export { claudeCodeDefinitions };

package/dist/install-commands/opencode.js

@@ -0,0 +1,434 @@
+import { DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST } from "../config/defaults.js";
+import { resolvePackageAssetPath } from "../package-assets.js";
+import "../config.js";
+import { compileWorkflowPlan } from "../workflow-planner.js";
+import { renderOpenCodeGatewayConfig } from "../mcp/gateway.js";
+import { AGENTS_MD_END, AGENTS_MD_START, COMMAND_HOSTS, GENERATED_MARKER, GENERATED_TS_MARKER, OWNER_MARKER_PREFIX, OWNER_TS_MARKER_PREFIX, SINGLE_OPENCODE_PLUGIN_ARRAY_RE, commandIdForHost, invocationForHost } from "./shared.js";
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import matter from "gray-matter";
+//#region src/install-commands/opencode.ts
+const OPENCODE_ORCHESTRATOR_AGENT_ID = "MoKa Orchestrator";
+const MOKA_PROFILE_PREFIX = "moka-";
+function header(host) {
+	return [
+		GENERATED_MARKER,
+		`${OWNER_MARKER_PREFIX}host=${host} -->`,
+		""
+	].join("\n");
+}
+function markdown(data, body) {
+	return `${matter.stringify(body.trimEnd(), data).trimEnd()}\n`;
+}
+function profileEntries(config) {
+	return Object.entries(config.profiles).sort(([a], [b]) => a.localeCompare(b));
+}
+function entrypointEntries(config) {
+	const entries = Object.entries(config.entrypoints);
+	return entries.length > 0 ? entries : [["execute", {
+		description: "Run the configured pipeline workflow",
+		workflow: config.default_workflow
+	}]];
+}
+function entrypointDescription(id, entrypoint) {
+	return entrypoint.description ?? `Run the ${id} workflow`;
+}
+function entrypointCommandDefinitions(_host, config, makeDefinition) {
+	return entrypointEntries(config).map(([id, entrypoint]) => makeDefinition(id, entrypoint));
+}
+function nativeProfileEntries(host, config) {
+	return profileEntries(config).filter(([id, profile]) => id !== config.orchestrator?.profile && canRunNatively(host, profile));
+}
+function orchestratorProfile(config) {
+	if (!config.orchestrator) return;
+	const profile = config.profiles[config.orchestrator.profile];
+	if (!profile) throw new Error(`Orchestrator profile '${config.orchestrator.profile}' is not declared.`);
+	return { ...profile };
+}
+function resolvedHostModel(config, host, profile) {
+	const runner = config.runners[profile.runner];
+	const hostRunner = config.runners[host];
+	if (profile.host_models?.[host]) return profile.host_models[host];
+	if (runner?.host_models?.[host]) return runner.host_models[host];
+	if (profile.runner === host) return profile.model ?? runner?.model;
+	return hostRunner?.model;
+}
+function canRunNatively(host, profile) {
+	if (profile.runner === host) return true;
+	return host === "opencode" && isModelRunner(profile.runner);
+}
+function isModelRunner(runnerId) {
+	return COMMAND_HOSTS.some((host) => host === runnerId);
+}
+function agentDispatchRoutes(host, config, workflowId = config.default_workflow) {
+	return compileWorkflowPlan(config, workflowId).topologicalOrder.flatMap((node) => {
+		if (!(node.kind === "agent" && node.profile)) return [];
+		const profile = config.profiles[node.profile];
+		if (!profile) return [];
+		return [dispatchRouteForAgent(host, config, {
+			needs: node.needs,
+			nodeId: node.id,
+			profile,
+			profileId: node.profile
+		})];
+	});
+}
+function dispatchRouteForAgent(host, config, route) {
+	const runnerId = route.profile.runner;
+	if (runnerId === host) {
+		const model = resolvedHostModel(config, host, route.profile);
+		return {
+			...route,
+			kind: "native-named-agent",
+			...model ? { model } : {},
+			nativeAgentId: nativeAgentIdForHost(host, route.profileId),
+			runnerId
+		};
+	}
+	if (host === "opencode" && isModelRunner(runnerId)) {
+		const model = resolvedHostModel(config, host, route.profile);
+		return {
+			...route,
+			kind: "native-model-agent",
+			...model ? { model } : {},
+			nativeAgentId: nativeAgentIdForHost(host, route.profileId),
+			runnerId
+		};
+	}
+	return {
+		...route,
+		kind: "cli",
+		runnerId
+	};
+}
+function nativeAgentIdForHost(host, profileId) {
+	return host === "opencode" ? opencodeAgentName(profileId) : profileId;
+}
+function opencodeAgentName(profileId) {
+	if (!profileId.startsWith(MOKA_PROFILE_PREFIX)) return profileId;
+	return `MoKa ${profileId.slice(5).split("-").map(opencodeAgentNamePart).join(" ")}`;
+}
+function opencodeAgentNamePart(part) {
+	if (part === "opencode") return "OpenCode";
+	return `${part.charAt(0).toUpperCase()}${part.slice(1)}`;
+}
+function grants(actor) {
+	return [
+		`model: ${actor.model ?? "default"}`,
+		`tools: ${(actor.tools ?? []).join(", ") || "none"}`,
+		`rules: ${(actor.rules ?? []).join(", ") || "none"}`,
+		`skills: ${(actor.skills ?? []).join(", ") || "none"}`,
+		`mcp_servers: ${(actor.mcp_servers ?? []).join(", ") || "none"}`,
+		`filesystem: ${actor.filesystem?.mode ?? "default"}`,
+		`network: ${actor.network?.mode ?? "default"}`,
+		..."output" in actor ? [`output: ${actor.output?.format ?? "text"}`] : []
+	].join("\n");
+}
+function orchestratorBlock(config) {
+	const profile = orchestratorProfile(config);
+	if (!profile) return "Configured orchestrator: none";
+	return [
+		"Configured orchestrator:",
+		grants(profile),
+		`hooks: ${Object.keys(config.hooks.functions).join(", ") || "none"}`,
+		"",
+		instructionsPointer(profile)
+	].join("\n");
+}
+function dispatchBlock(host, config, workflowId = config.default_workflow) {
+	const routes = agentDispatchRoutes(host, config, workflowId);
+	if (routes.length === 0) return;
+	const plan = compileWorkflowPlan(config, workflowId);
+	const nativeRoutes = routes.filter((route) => route.kind !== "cli");
+	const cliRoutes = routes.filter((route) => route.kind === "cli");
+	return [
+		`Run workflow \`${plan.workflowId}\` for the user task.`,
+		"",
+		nativeDispatchBlock(host, nativeRoutes),
+		cliDispatchBlock(host, cliRoutes),
+		nodePromptContract(plan.workflowId, routes),
+		"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.",
+		"Do not bypass configured runner subprocesses or package-configured gates when executing nodes.",
+		"Use the listed Task tool routes for native nodes, and run nodes with satisfied dependencies in parallel whenever the host supports concurrent subagent work.",
+		hostSpecificDispatchGuard(host, nativeRoutes, cliRoutes)
+	].filter((line) => Boolean(line)).join("\n");
+}
+function entrypointDispatchBlock(host, config, id, entrypoint) {
+	if ("workflow" in entrypoint) return dispatchBlock(host, config, entrypoint.workflow);
+	return [
+		`Generate a schedule for entrypoint \`${id}\` and the user task.`,
+		`The schedule policy is \`${entrypoint.schedule}\`.`,
+		id === "quick" ? "Run `moka submit --quick <task description>` to submit the graph as an Argo Workflow." : `Run \`moka submit <task description>\` to submit the \`${id}\` graph as an Argo Workflow.`,
+		"The pipeline runtime executes as Argo DAG tasks using the package-owned runner image.",
+		"Configure the target in `~/.config/moka/config.yaml`; use `--kubeconfig <path>` and `--namespace <namespace>` only for explicit command overrides.",
+		"Use `moka submit --schedule <schedule.yaml> <task description>` only when rerunning an existing schedule artifact."
+	].join("\n");
+}
+function scheduledEntrypointK8sNote(entrypoint) {
+	if ("workflow" in entrypoint) return;
+	return "Submit Momokaya work as Argo Workflows through `moka submit` and `moka submit --quick`.";
+}
+function orchestratorEntrypointDispatchBlock(host, config) {
+	const scheduledEntrypoints = entrypointEntries(config).filter(([, entrypoint]) => !("workflow" in entrypoint));
+	if (scheduledEntrypoints.length === 0) return dispatchBlock(host, config);
+	return scheduledEntrypoints.map(([id, entrypoint]) => entrypointDispatchBlock(host, config, id, entrypoint)).filter((block) => Boolean(block)).join("\n\n");
+}
+function nativeDispatchBlock(host, routes) {
+	if (routes.length === 0) return;
+	return [
+		`${hostDisplayName(host)} native routes:`,
+		...routes.map(nativeDispatchLine),
+		""
+	].join("\n");
+}
+function nativeDispatchLine(route) {
+	const needs = needsSummary(route.needs);
+	const model = route.model ? ` model=${route.model}` : "";
+	return `- ${route.nodeId}: Task tool subagent_type=${route.nativeAgentId}${model} runner=${route.runnerId} needs=${needs}`;
+}
+function cliDispatchBlock(host, routes) {
+	if (routes.length === 0) return;
+	return [
+		`These nodes are not ${hostDisplayName(host)} native routes.`,
+		"CLI routes:",
+		...routes.map(cliDispatchLine),
+		""
+	].join("\n");
+}
+function cliDispatchLine(route) {
+	return `- ${route.nodeId}: ${route.runnerId} CLI profile=${route.profileId} command=\`${runnerCliCommand(route)}\` needs=${needsSummary(route.needs)}`;
+}
+function runnerCliCommand(route) {
+	if (route.runnerId === "opencode") return `opencode run --agent "${opencodeAgentName(route.profileId)}" --format json --dir <repo-root> <node prompt>`;
+	throw new Error(`runner '${route.runnerId}' cannot be represented as a supported native or CLI route`);
+}
+function nodePromptContract(workflowId, routes) {
+	return [
+		routes.some((route) => route.kind === "cli") ? "For each CLI node prompt include:" : "For each native node prompt include:",
+		"- user task",
+		`- workflow id: ${workflowId}`,
+		"- node id",
+		"- profile id",
+		"- runner id",
+		"- profile instructions reference",
+		"- profile grants",
+		"- dependency outputs",
+		""
+	].join("\n");
+}
+function hostSpecificDispatchGuard(host, nativeRoutes, cliRoutes) {
+	if (cliRoutes.length > 0 && nativeRoutes.length > 0) return `Do not claim CLI routes are ${hostDisplayName(host)} native routes.`;
+	if (cliRoutes.length > 0 && nativeRoutes.length === 0) return `Do not claim these nodes are ${hostDisplayName(host)} subagents.`;
+}
+function hostDisplayName(host) {
+	return {
+		"claude-code": "Claude Code",
+		opencode: "OpenCode"
+	}[host];
+}
+function needsSummary(needs) {
+	return needs.length > 0 ? needs.join(",") : "none";
+}
+function compactLines(lines) {
+	return lines.filter((line) => line !== void 0);
+}
+const OPENCODE_PERMISSION_TOOLS = [
+	"bash",
+	"edit",
+	"glob",
+	"grep",
+	"list",
+	"read",
+	"write"
+];
+function opencodePermission(actor, options = {}) {
+	const allowed = new Set(actor.tools ?? []);
+	return {
+		...opencodeToolPermissions(allowed),
+		external_directory: "deny",
+		lsp: "allow",
+		skill: opencodeSkillPermission(actor.skills ?? []),
+		task: opencodeTaskPermission(allowed, options.allowedTaskAgents ?? [])
+	};
+}
+function opencodeToolPermissions(allowed) {
+	return Object.fromEntries(OPENCODE_PERMISSION_TOOLS.map((tool) => [tool, allowed.has(tool) ? "allow" : "deny"]));
+}
+function opencodeSkillPermission(skills) {
+	return namedOpencodePermissionMap(skills);
+}
+function opencodeTaskPermission(allowed, allowedTaskAgents) {
+	return allowedTaskAgents.length > 0 ? namedOpencodePermissionMap(allowedTaskAgents) : toolPermission(allowed, "task");
+}
+function namedOpencodePermissionMap(names) {
+	return names.length > 0 ? {
+		"*": "deny",
+		...Object.fromEntries(names.map((name) => [name, "allow"]))
+	} : "deny";
+}
+function toolPermission(allowed, tool) {
+	return allowed.has(tool) ? "allow" : "deny";
+}
+function renderOpenCodeProjectConfig(config) {
+	return formatOpenCodeProjectJson({
+		...config.mcp_gateway ? JSON.parse(renderOpenCodeGatewayConfig(config)) : { $schema: "https://opencode.ai/config.json" },
+		lsp: true,
+		...opencodePluginConfig(),
+		...opencodeProviderConfig()
+	});
+}
+function opencodeProviderConfig() {
+	const provider = {};
+	for (const model of DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST.provider_models) {
+		provider[model.provider] ??= { models: {} };
+		provider[model.provider].models[model.id] = { options: model.options };
+	}
+	return Object.keys(provider).length > 0 ? { provider } : {};
+}
+function opencodePluginConfig() {
+	const plugins = DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST.ecosystem_code.flatMap((item) => npmPluginPackage(item)).sort((a, b) => a.localeCompare(b));
+	return plugins.length > 0 ? { plugin: plugins } : {};
+}
+function npmPluginPackage(item) {
+	if (item.plugin?.kind === "npm") return [item.plugin.package];
+	return [];
+}
+function formatOpenCodeProjectJson(value) {
+	return `${JSON.stringify(value, null, 2).replace(SINGLE_OPENCODE_PLUGIN_ARRAY_RE, "\n  \"plugin\": [$1]")}\n`;
+}
+function localPluginDefinitions() {
+	return DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST.ecosystem_code.flatMap((item) => {
+		if (item.plugin?.kind !== "local") return [];
+		const plugin = readFileSync(resolvePackageAssetPath(item.plugin.source_path), "utf8").trimEnd();
+		return [{
+			content: [
+				GENERATED_TS_MARKER,
+				`${OWNER_TS_MARKER_PREFIX}host=opencode`,
+				"",
+				plugin,
+				""
+			].join("\n"),
+			host: "opencode",
+			invocation: invocationForHost("opencode"),
+			path: item.plugin.target_path
+		}];
+	});
+}
+function opencodeDefinitions(config, cwd) {
+	const orchestrator = orchestratorProfile(config);
+	return [
+		...entrypointCommandDefinitions("opencode", config, (id, entrypoint) => ({
+			content: markdown({
+				...orchestrator ? { agent: OPENCODE_ORCHESTRATOR_AGENT_ID } : {},
+				description: entrypointDescription(id, entrypoint)
+			}, compactLines([
+				header("opencode").trimEnd(),
+				"",
+				`Invoke this command with \`${invocationForHost("opencode", id)}\`.`,
+				"",
+				orchestratorBlock(config),
+				"",
+				scheduledEntrypointK8sNote(entrypoint),
+				scheduledEntrypointK8sNote(entrypoint) ? "" : void 0,
+				entrypointDispatchBlock("opencode", config, id, entrypoint)
+			]).join("\n")),
+			host: "opencode",
+			invocation: invocationForHost("opencode", id),
+			path: `.opencode/commands/${commandIdForHost("opencode", id)}.md`
+		})),
+		{
+			content: renderOpenCodeProjectConfig(config),
+			host: "opencode",
+			invocation: invocationForHost("opencode"),
+			path: ".opencode/opencode.json"
+		},
+		...orchestrator ? [{
+			content: markdown({
+				description: "Orchestrate the configured pipeline and enforce gates.",
+				mode: "primary",
+				name: OPENCODE_ORCHESTRATOR_AGENT_ID,
+				permission: opencodePermission(orchestrator, { allowedTaskAgents: agentDispatchRoutes("opencode", config).filter((route) => route.kind !== "cli").map((route) => route.nativeAgentId).filter((id) => Boolean(id)) })
+			}, compactLines([
+				header("opencode").trimEnd(),
+				"",
+				orchestratorBlock(config),
+				"",
+				orchestratorEntrypointDispatchBlock("opencode", config)
+			]).join("\n")),
+			host: "opencode",
+			invocation: invocationForHost("opencode"),
+			path: `.opencode/agents/${OPENCODE_ORCHESTRATOR_AGENT_ID}.md`
+		}] : [],
+		...nativeProfileEntries("opencode", config).map(([id, profile]) => ({
+			content: markdown({
+				name: nativeAgentIdForHost("opencode", id),
+				description: profile.description ?? id,
+				hidden: false,
+				mode: "all",
+				...opencodeModelProjection(config, profile),
+				permission: opencodePermission(profile)
+			}, [
+				header("opencode").trimEnd(),
+				"",
+				profile.description ?? id,
+				"",
+				"Configured grants:",
+				grants(profile),
+				"",
+				instructionsPointer(profile)
+			].join("\n")),
+			host: "opencode",
+			invocation: invocationForHost("opencode"),
+			path: `.opencode/agents/${nativeAgentIdForHost("opencode", id)}.md`
+		})),
+		...localPluginDefinitions(),
+		projectAgentsMdDefinition(cwd, "opencode")
+	];
+}
+function projectAgentsMdDefinition(cwd, host) {
+	const repoName = basename(cwd);
+	return {
+		block: {
+			end: AGENTS_MD_END,
+			start: AGENTS_MD_START
+		},
+		content: [
+			AGENTS_MD_START,
+			GENERATED_MARKER,
+			`${OWNER_MARKER_PREFIX}host=opencode -->`,
+			"",
+			"## Pipeline Guidance",
+			"",
+			"This repository uses package-owned `@oisincoveney/pipeline` config.",
+			"",
+			"- Use `/moka-quick`, `/moka-execute`, or `/moka-inspect` for OpenCode slash-command entrypoints when available.",
+			"- Load and follow the relevant skill from `.agents/skills` before doing specialized work.",
+			"- Prefer the package-defined pipeline profiles and generated command surfaces over ad hoc subagent prompts.",
+			"",
+			"## Pipeline Memory",
+			"",
+			`Use Qdrant collection \`${repoName}\` for this repository.`,
+			"",
+			`- Call \`qdrant-find\` before research with \`collection_name: ${repoName}\` unless the user explicitly disables memory.`,
+			`- Call \`qdrant-store\` during LEARN with \`collection_name: ${repoName}\` for durable lessons worth reusing.`,
+			"- Include metadata with at least `repo`, `phase`, `workflow` or `entrypoint`, `task`, and `outcome` when storing lessons.",
+			"",
+			AGENTS_MD_END,
+			""
+		].join("\n"),
+		host,
+		invocation: invocationForHost(host),
+		path: "AGENTS.md"
+	};
+}
+function opencodeModelProjection(config, profile) {
+	const model = resolvedHostModel(config, "opencode", profile);
+	return model ? { model } : {};
+}
+function instructionsPointer(actor) {
+	if (actor.instructions.path) return `Instructions: ${actor.instructions.path}`;
+	return `Instructions:\n${actor.instructions.inline ?? ""}`;
+}
+//#endregion
+export { opencodeDefinitions };