@oisincoveney/pipeline 2.1.0 → 2.2.0

package/dist/config/defaults.js

@@ -7,359 +7,13 @@ const PIPELINE_CONFIG_PATH = ".pipeline/pipeline.yaml";
 const RUNNERS_CONFIG_PATH = ".pipeline/runners.yaml";
 const PROFILES_CONFIG_PATH = ".pipeline/profiles.yaml";
 const OPENCODE_ECOSYSTEM_MANIFEST_PATH = "defaults/opencode-ecosystem.yaml";
-const PACKAGE_DEFAULT_RUNNERS_YAML = `version: 1
-runners:
-  opencode:
-    type: opencode
-    capabilities:
-      native_subagents: true
-      rules: true
-      skills: true
-      mcp_servers: true
-      tools: [read, list, grep, glob, bash, edit, write]
-      filesystem: [read-only, workspace-write]
-      network: [inherit, disabled]
-      output_formats: [text, json, jsonl, json_schema]
-  command:
-    type: command
-    capabilities:
-      native_subagents: false
-      rules: false
-      skills: false
-      mcp_servers: false
-      tools: [bash]
-      filesystem: [read-only, workspace-write]
-      network: [inherit, disabled]
-      output_formats: [text, json]
-`;
-const PACKAGE_DEFAULT_PROFILES_YAML = `version: 1
-mcp_gateway:
-  provider: toolhive
-  mode: local
-  url: https://pipeline-mcp.momokaya.ee/mcp/
-  url_env: PIPELINE_MCP_GATEWAY_URL
-  authorization_env: PIPELINE_MCP_GATEWAY_AUTHORIZATION
-  default_profile: default
-  backends:
-    context7:
-      locality: shared-remote
-      tool_prefixes: [context7]
-    uidotsh:
-      locality: shared-remote
-      tool_prefixes: [uidotsh]
-    qdrant:
-      locality: repo-scoped-remote
-      tool_prefixes: [qdrant]
-    fallow:
-      locality: repo-local
-      workspace_path_source: PIPELINE_TARGET_PATH
-      required: false
-      tool_prefixes: [fallow]
-    serena:
-      locality: repo-local
-      workspace_path_source: PIPELINE_TARGET_PATH
-      tool_prefixes: [serena]
-    backlog:
-      locality: repo-local
-      workspace_path_source: PIPELINE_TARGET_PATH
-      tool_prefixes: [backlog]
-skills:
-  execute:
-    path: .agents/skills/execute/SKILL.md
-    source_root: package
-  inspect:
-    path: .agents/skills/inspect/SKILL.md
-    source_root: package
-  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
-  doubt:
-    path: .agents/skills/doubt/SKILL.md
-    source_root: package
-  fix:
-    path: .agents/skills/fix/SKILL.md
-    source_root: package
-  library-first-development:
-    path: .agents/skills/library-first-development/SKILL.md
-    source_root: package
-  migrate:
-    path: .agents/skills/migrate/SKILL.md
-    source_root: package
-  optimize:
-    path: .agents/skills/optimize/SKILL.md
-    source_root: package
-  research:
-    path: .agents/skills/research/SKILL.md
-    source_root: package
-  schedule-graph-shaping:
-    path: .agents/skills/schedule-graph-shaping/SKILL.md
-    source_root: package
-  scope:
-    path: .agents/skills/scope/SKILL.md
-    source_root: package
-  secure:
-    path: .agents/skills/secure/SKILL.md
-    source_root: package
-  spec:
-    path: .agents/skills/spec/SKILL.md
-    source_root: package
-  test:
-    path: .agents/skills/test/SKILL.md
-    source_root: package
-  trace:
-    path: .agents/skills/trace/SKILL.md
-    source_root: package
-  verify:
-    path: .agents/skills/verify/SKILL.md
-    source_root: package
-profiles:
-  moka-orchestrator:
-    runner: opencode
-    description: Orchestrate the configured pipeline and enforce gates.
-    instructions: { inline: "Orchestrate the configured pipeline through package-defined entrypoints, native agents, and gates. Do not bypass configured runner subprocesses or package-configured gates." }
-    skills: [execute, quick, inspect]
-    mcp_servers: [pipeline-gateway]
-    tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
-    network: { mode: inherit }
-  moka-researcher:
-    runner: opencode
-    description: Research the requested task and produce structured findings.
-    instructions: { inline: "Inspect first-party source, tests, docs, and task context for the current task only. Produce concise findings with file references and stop; do not perform open-ended repository exploration." }
-    timeout_ms: 900000
-    skills: [research, spec, scope]
-    mcp_servers: [pipeline-gateway]
-    tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
-    network: { mode: inherit }
-    output:
-      format: json_schema
-      schema_path: .pipeline/schemas/research.schema.json
-      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]
-    mcp_servers: [pipeline-gateway]
-    tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
-    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
-    skills: [schedule-graph-shaping]
-    mcp_servers: [pipeline-gateway]
-    tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
-    network: { mode: inherit }
-  moka-test-writer:
-    runner: opencode
-    scheduling_roles: [implementation]
-    description: Add focused failing tests for the requested behavior.
-    instructions: { inline: "Add focused failing tests for the requested behavior only. Do not change production code. Only edit files matching test paths such as **/*.test.*, **/*.spec.*, **/*_test.*, **/__tests__/**, test/**, or tests/**. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
-    skills: [test]
-    mcp_servers: [pipeline-gateway]
-    tools: [read, list, grep, glob, bash, edit, write]
-    filesystem: { mode: workspace-write, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
-    network: { mode: inherit }
-    output:
-      format: json_schema
-      schema_path: .pipeline/schemas/implementation.schema.json
-      repair: { enabled: true, max_attempts: 1 }
-  moka-code-writer:
-    runner: opencode
-    scheduling_roles: [implementation]
-    description: Implement production code until the failing tests pass.
-    instructions: { inline: "Implement the smallest production change that satisfies the failing tests. Return only valid JSON with top-level changes and verification. Every changes entry must include summary, why, and files. Include risks, followups, and lessons when present. Do not use Markdown fences or prose outside the JSON object." }
-    skills: [trace, test, fix, library-first-development]
-    mcp_servers: [pipeline-gateway]
-    tools: [read, list, grep, glob, bash, edit, write]
-    filesystem: { mode: workspace-write, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
-    network: { mode: inherit }
-    output:
-      format: json_schema
-      schema_path: .pipeline/schemas/implementation.schema.json
-      repair: { enabled: true, max_attempts: 1 }
-  moka-acceptance-reviewer:
-    runner: opencode
-    scheduling_roles: [coverage]
-    description: Audit the finished change against every acceptance criterion.
-    instructions: { inline: 'Audit the completed change against each canonical acceptance criterion independently. Return only valid JSON with top-level "verdict", "evidence", "acceptance", and optional "violations". Each "acceptance" entry must include "id", "verdict", and non-empty "evidence". Do not use Markdown fences or prose outside the JSON object.' }
-    skills: [critique, doubt]
-    mcp_servers: [pipeline-gateway]
-    tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
-    network: { mode: inherit }
-    output:
-      format: json_schema
-      schema_path: .pipeline/schemas/acceptance.schema.json
-      repair: { enabled: true, max_attempts: 1 }
-  moka-thermo-nuclear-reviewer:
-    runner: opencode
-    scheduling_roles: [coverage]
-    description: Perform the final thermo-nuclear code quality review of the integration branch.
-    instructions: { inline: "Perform the final code quality review of the integration branch." }
-    skills: [critique]
-    mcp_servers: [pipeline-gateway]
-    tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
-    network: { mode: inherit }
-    output:
-      format: json_schema
-      schema_path: .pipeline/schemas/review.schema.json
-      repair: { enabled: true, max_attempts: 1 }
-  moka-verifier:
-    runner: opencode
-    scheduling_roles: [coverage]
-    description: Verify checks, implementation fit, and final evidence.
-    instructions: { inline: 'Verify checks, implementation fit, and final evidence. Return only valid JSON with top-level "verdict", "evidence", and optional "violations". Do not use Markdown fences or prose outside the JSON object.' }
-    skills: [verify, critique, secure, optimize]
-    mcp_servers: [pipeline-gateway]
-    tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
-    network: { mode: inherit }
-    output:
-      format: json_schema
-      schema_path: .pipeline/schemas/verify.schema.json
-      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]
-    mcp_servers: [pipeline-gateway]
-    tools: [read, list, grep, glob, bash]
-    filesystem: { mode: read-only, allow: ["**/*"], deny: ["node_modules/**", "dist/**", ".git/**"] }
-    network: { mode: inherit }
-    output:
-      format: json_schema
-      schema_path: .pipeline/schemas/learn.schema.json
-      repair: { enabled: true, max_attempts: 1 }
-`;
-const PACKAGE_DEFAULT_PIPELINE_YAML = `version: 1
-default_workflow: inspect
-orchestrator:
-  profile: moka-orchestrator
-entrypoints:
-  quick:
-    schedule: quick-schedule
-    description: Compact planner-generated pipeline for small work
-  execute:
-    schedule: execute-schedule
-    description: Full planner-generated pipeline for repository work
-  inspect:
-    workflow: inspect
-    description: Read-only repository inspection
-hooks:
-  functions:
-    generated-defaults-audit:
-      kind: command
-      command: [node, -e, "const fs=require('node:fs'); fs.writeFileSync(process.env.PIPELINE_HOOK_RESULT, JSON.stringify({status:'pass',summary:'Generated defaults audit passed'}));"]
-      trusted: true
-      timeout_ms: 5000
-      output_limit_bytes: 4096
-  on:
-    workflow.start:
-      - id: generated-defaults-audit
-        function: generated-defaults-audit
-        failure: fail
-runner_command:
-  environment:
-    setup:
-      - command: bun
-        args: [install, --frozen-lockfile]
-scheduler:
-  commands:
-    quick:
-      schedule: quick-schedule
-      catalog: quick
-    execute:
-      schedule: execute-schedule
-      catalog: execute
-  node_catalogs:
-    quick:
-      required_categories: [intake, red, green, mechanical, verification]
-      nodes:
-        backlog-intake:
-          category: intake
-          profile: moka-researcher
-          models: [openai/gpt-5.5-medium]
-        red-tests:
-          category: red
-          profile: moka-test-writer
-          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-high, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
-        verification:
-          category: verification
-          profile: moka-verifier
-          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-medium]
-        research:
-          category: research
-          profile: moka-researcher
-          models: [openai/gpt-5.5-medium, kimi-for-coding/k2p6]
-        red-tests:
-          category: red
-          profile: moka-test-writer
-          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-high, kimi-for-coding/k2p6, opencode-go/qwen3.7-max]
-        green-frontend:
-          category: green
-          profile: moka-code-writer
-          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-medium]
-        verification:
-          category: verification
-          profile: moka-verifier
-          models: [openai/gpt-5.5-medium]
-        learn:
-          category: learn
-          profile: moka-learner
-          models: [openai/gpt-5.5-low]
-schedules:
-  quick-schedule:
-    baseline: quick
-    planner_profile: moka-schedule-planner
-    node_catalog: quick
-  execute-schedule:
-    baseline: execute
-    planner_profile: moka-schedule-planner
-    node_catalog: execute
-workflows:
-  inspect:
-    description: Read-only repository inspection workflow.
-    nodes:
-      - id: inspect
-        kind: agent
-        profile: moka-inspector
-`;
+const DEFAULT_PACKAGE_DEFAULTS_ROOT = new URL("../../defaults/", import.meta.url);
+function loadDefaultYaml(filename) {
+	return readFileSync(new URL(filename, DEFAULT_PACKAGE_DEFAULTS_ROOT), "utf8");
+}
+const PACKAGE_DEFAULT_RUNNERS_YAML = loadDefaultYaml("runners.yaml");
+const PACKAGE_DEFAULT_PROFILES_YAML = loadDefaultYaml("profiles.yaml");
+const PACKAGE_DEFAULT_PIPELINE_YAML = loadDefaultYaml("pipeline.yaml");
 const DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST_URL = new URL(`../../${OPENCODE_ECOSYSTEM_MANIFEST_PATH}`, import.meta.url);
 const ecosystemStringArraySchema = z.array(z.string().min(1));
 const ecosystemRuntimeSchema = z.object({

package/dist/git-remote-url.js

@@ -0,0 +1,30 @@
+import parseGitUrl from "git-url-parse";
+//#region src/git-remote-url.ts
+const GITHUB_SOURCE = "github.com";
+function normalizeRunnerRepositoryForSubmit(repository) {
+	const url = normalizeRepositoryUrlForSubmit(repository.url);
+	if (url === repository.url) return repository;
+	return {
+		...repository,
+		url
+	};
+}
+function normalizeRepositoryUrlForSubmit(remoteUrl) {
+	const parsed = parseGitUrl(remoteUrl);
+	if (!isSshRemote(parsed)) return remoteUrl;
+	if (parsed.source !== GITHUB_SOURCE) throw new Error(`SSH git remote ${remoteUrl} is not supported for moka submit; use an HTTPS GitHub remote`);
+	return `https://${GITHUB_SOURCE}/${gitHubRepositoryPath(parsed, remoteUrl)}`;
+}
+function gitHubRepositoryPath(parsed, remoteUrl) {
+	return `${requiredGitHubPathSegment(parsed.owner, remoteUrl)}/${requiredGitHubPathSegment(parsed.name, remoteUrl)}.git`;
+}
+function requiredGitHubPathSegment(value, remoteUrl) {
+	const segment = value.trim();
+	if (segment.length > 0) return segment;
+	throw new Error(`GitHub SSH git remote ${remoteUrl} must include an owner and repository name`);
+}
+function isSshRemote(parsed) {
+	return parsed.protocols.includes("ssh");
+}
+//#endregion
+export { normalizeRunnerRepositoryForSubmit };

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<{
-    pass: "pass";
     fail: "fail";
+    pass: "pass";
     skip: "skip";
   }>;
   summary: z.ZodOptional<z.ZodString>;

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

@@ -1,24 +1,160 @@
-import { resolvePackageAssetPath } from "../package-assets.js";
-import { GENERATED_MARKER, OWNER_MARKER_PREFIX, invocationForHost } from "./shared.js";
-import { readFileSync } from "node:fs";
+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";
 //#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 -->`,
+const CLAUDE_CODE_HOST = "claude-code";
+const CLAUDE_ALLOWED_TOOLS = "Task, Bash(opencode run *)";
+const CLAUDE_AGENT_TOOLS = "Bash, Read";
+const MOKA_PROFILE_PREFIX = "moka-";
+function claudeAgentNameForProfile(profileId) {
+	return profileId.startsWith(MOKA_PROFILE_PREFIX) ? profileId : `${MOKA_PROFILE_PREFIX}${profileId}`;
+}
+function cliRoutesForConfig(config) {
+	return entrypointEntries(config).flatMap(([, entrypoint]) => "workflow" in entrypoint ? agentDispatchRoutes(CLAUDE_CODE_HOST, config, entrypoint.workflow) : []);
+}
+function distinctCliProfiles(config) {
+	const seen = /* @__PURE__ */ new Set();
+	const profiles = [];
+	for (const route of cliRoutesForConfig(config)) {
+		if (route.kind !== "cli" || seen.has(route.profileId)) continue;
+		seen.add(route.profileId);
+		profiles.push(route);
+	}
+	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",
 		"",
-		"# Claude Code OpenCode Execute"
-	].join("\n"));
+		"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 claudeCodeDefinitions() {
+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}`;
+}
+function commandDefinitions(config) {
+	return entrypointEntries(config).map(([id, entrypoint]) => ({
+		content: markdown({
+			"argument-hint": "<task description>",
+			"allowed-tools": CLAUDE_ALLOWED_TOOLS,
+			description: entrypointDescription(id, entrypoint)
+		}, compactLines([
+			header(CLAUDE_CODE_HOST).trimEnd(),
+			"",
+			`Invoke this command with \`${invocationForHost(CLAUDE_CODE_HOST, id)}\`.`,
+			"",
+			"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,
+		invocation: invocationForHost(CLAUDE_CODE_HOST, id),
+		path: `.claude/commands/${commandIdForHost(CLAUDE_CODE_HOST, id)}.md`
+	}));
+}
+function agentModelProjection(config, profile) {
+	const model = resolvedHostModel(config, CLAUDE_CODE_HOST, profile);
+	return model ? { model } : {};
+}
+function agentDefinitions(config) {
+	return distinctCliProfiles(config).map((route) => {
+		const profile = route.profile;
+		const agentName = claudeAgentNameForProfile(route.profileId);
+		const displayName = opencodeAgentName(route.profileId);
+		return {
+			content: markdown({
+				name: agentName,
+				description: profile.description ?? route.profileId,
+				tools: CLAUDE_AGENT_TOOLS,
+				...agentModelProjection(config, profile)
+			}, [
+				header(CLAUDE_CODE_HOST).trimEnd(),
+				"",
+				profile.description ?? route.profileId,
+				"",
+				`Run EXACTLY ONE \`opencode run --agent "${displayName}" --format json --dir "$PWD" '<node prompt>'\` subprocess for this node.`,
+				"Stay inside this node's scope and do not branch into adjacent nodes.",
+				"Do not claim completion without fresh evidence from the subprocess output.",
+				"Return only: { command, exit status, parsed evidence, touched files, blockers }.",
+				"",
+				"Configured grants:",
+				grants(profile),
+				"",
+				instructionsPointer(profile)
+			].join("\n")),
+			host: CLAUDE_CODE_HOST,
+			invocation: invocationForHost(CLAUDE_CODE_HOST),
+			path: `.claude/agents/${agentName}.md`
+		};
+	});
+}
+function settingsDefinition(config) {
+	const settings = { permissions: { allow: ["Task", "Bash(opencode run *)"] } };
+	if (config.mcp_gateway) settings.mcpServers = renderClaudeGatewayMcpServers(config);
 	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`
+		content: `${JSON.stringify(settings, null, 2)}\n`,
+		host: CLAUDE_CODE_HOST,
+		invocation: invocationForHost(CLAUDE_CODE_HOST),
+		path: CLAUDE_PROJECT_CONFIG_PATH
 	}];
 }
+function claudeCodeDefinitions(config, cwd) {
+	return [
+		...commandDefinitions(config),
+		...agentDefinitions(config),
+		...settingsDefinition(config),
+		projectAgentsMdDefinition(cwd, CLAUDE_CODE_HOST)
+	];
+}
+/**
+* The claude-code HostAdapter. Encapsulates all Claude Code-specific command
+* generation, resource roots, and settings-merge behaviour.
+*/
+const claudeCodeAdapter = {
+	host: "claude-code",
+	resourceRoots: [".claude/commands", ".claude/agents"],
+	definitions(config, cwd) {
+		return claudeCodeDefinitions(config, cwd);
+	},
+	mergeDefinition(definition, existingContent) {
+		if (definition.path !== ".claude/settings.json") return;
+		const merged = mergeClaudeSettings(existingContent, JSON.parse(definition.content));
+		if (!merged.ok) return {
+			ok: false,
+			content: definition.content
+		};
+		return {
+			ok: true,
+			content: merged.content
+		};
+	},
+	isAlwaysForced(definition) {
+		return definition.path === CLAUDE_PROJECT_CONFIG_PATH;
+	}
+};
 //#endregion
-export { claudeCodeDefinitions };
+export { claudeCodeAdapter };