@oisincoveney/pipeline 2.7.0 → 2.8.1

package/dist/config/defaults.js

@@ -1,7 +1,6 @@
-import { PipelineConfigError, configIssuesFromZodError, validationError } from "./schemas.js";
-import { parseDocument } from "yaml";
+import { ConfigIoService, parseConfigYamlAs, runConfigIoSync } from "../runtime/services/config-io-service.js";
 import { z } from "zod";
-import { readFileSync } from "node:fs";
+import { Effect } from "effect";
 //#region src/config/defaults.ts
 const PIPELINE_CONFIG_PATH = ".pipeline/pipeline.yaml";
 const RUNNERS_CONFIG_PATH = ".pipeline/runners.yaml";
@@ -9,7 +8,9 @@ const PROFILES_CONFIG_PATH = ".pipeline/profiles.yaml";
 const OPENCODE_ECOSYSTEM_MANIFEST_PATH = "defaults/opencode-ecosystem.yaml";
 const DEFAULT_PACKAGE_DEFAULTS_ROOT = new URL("../../defaults/", import.meta.url);
 function loadDefaultYaml(filename) {
-	return readFileSync(new URL(filename, DEFAULT_PACKAGE_DEFAULTS_ROOT), "utf8");
+	return runConfigIoSync(Effect.gen(function* () {
+		return yield* (yield* ConfigIoService).readText(new URL(filename, DEFAULT_PACKAGE_DEFAULTS_ROOT));
+	}));
 }
 const PACKAGE_DEFAULT_RUNNERS_YAML = loadDefaultYaml("runners.yaml");
 const PACKAGE_DEFAULT_PROFILES_YAML = loadDefaultYaml("profiles.yaml");
@@ -111,24 +112,13 @@ const openCodeEcosystemManifestSchema = z.object({
 	version: z.literal(1)
 }).strict();
 function parseOpenCodeEcosystemManifest(source, sourcePath = OPENCODE_ECOSYSTEM_MANIFEST_PATH) {
-	return parseYamlAs(source, sourcePath, openCodeEcosystemManifestSchema);
+	return runConfigIoSync(parseConfigYamlAs(source, sourcePath, openCodeEcosystemManifestSchema));
 }
 function loadDefaultOpenCodeEcosystemManifest() {
-	return parseOpenCodeEcosystemManifest(readFileSync(DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST_URL, "utf8"));
+	return runConfigIoSync(Effect.gen(function* () {
+		return yield* parseConfigYamlAs(yield* (yield* ConfigIoService).readText(DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST_URL), OPENCODE_ECOSYSTEM_MANIFEST_PATH, openCodeEcosystemManifestSchema);
+	}));
 }
 const DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST = loadDefaultOpenCodeEcosystemManifest();
-function parseYamlAs(source, sourcePath, schema) {
-	const document = parseDocument(source, {
-		prettyErrors: false,
-		uniqueKeys: true
-	});
-	if (document.errors.length > 0) throw new PipelineConfigError("PIPELINE_CONFIG_PARSE_ERROR", `Failed to parse ${sourcePath}`, document.errors.map((err) => ({
-		message: err.message,
-		path: sourcePath
-	})));
-	const parsed = schema.safeParse(document.toJS());
-	if (!parsed.success) throw validationError(configIssuesFromZodError(parsed.error));
-	return parsed.data;
-}
 //#endregion
 export { DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST, OPENCODE_ECOSYSTEM_MANIFEST_PATH, PACKAGE_DEFAULT_PIPELINE_YAML, PACKAGE_DEFAULT_PROFILES_YAML, PACKAGE_DEFAULT_RUNNERS_YAML, PIPELINE_CONFIG_PATH, PROFILES_CONFIG_PATH, RUNNERS_CONFIG_PATH, parseOpenCodeEcosystemManifest };

package/dist/config/load.js

@@ -1,13 +1,14 @@
-import { PipelineConfigError, configIssuesFromZodError, pipelineFileSchema, profilesFileSchema, runnersFileSchema, validationError } from "./schemas.js";
+import { pipelineFileSchema, profilesFileSchema, runnersFileSchema } from "./schemas.js";
+import { parseConfigYamlAs, runConfigIoSync } from "../runtime/services/config-io-service.js";
 import { PACKAGE_DEFAULT_PIPELINE_YAML, PACKAGE_DEFAULT_PROFILES_YAML, PACKAGE_DEFAULT_RUNNERS_YAML, PIPELINE_CONFIG_PATH, PROFILES_CONFIG_PATH, RUNNERS_CONFIG_PATH } from "./defaults.js";
 import { validatePipelineConfig } from "./validate.js";
-import { parseDocument } from "yaml";
+import { Effect } from "effect";
 //#region src/config/load.ts
 function loadPipelineConfig(projectRoot, options = {}) {
 	return loadPackagePipelineConfig(projectRoot, options);
 }
 function loadPackagePipelineConfig(projectRoot, options = {}) {
-	return parsePipelineConfigParts({
+	return runConfigIoSync(parsePipelineConfigPartsEffect({
 		pipeline: PACKAGE_DEFAULT_PIPELINE_YAML,
 		profiles: PACKAGE_DEFAULT_PROFILES_YAML,
 		runners: PACKAGE_DEFAULT_RUNNERS_YAML
@@ -15,7 +16,7 @@ function loadPackagePipelineConfig(projectRoot, options = {}) {
 		pipeline: "@oisincoveney/pipeline/defaults/pipeline.yaml",
 		profiles: "@oisincoveney/pipeline/defaults/profiles.yaml",
 		runners: "@oisincoveney/pipeline/defaults/runners.yaml"
-	}, options);
+	}, options));
 }
 function parsePipelineConfigYaml(source, sourcePath = PIPELINE_CONFIG_PATH, projectRoot) {
 	return parsePipelineConfigParts({
@@ -28,46 +29,55 @@ function parsePipelineConfigYaml(source, sourcePath = PIPELINE_CONFIG_PATH, proj
 		runners: RUNNERS_CONFIG_PATH
 	});
 }
+function durabilityField(durability) {
+	return durability ? { durability } : {};
+}
+function pipe83Fields(pipeline) {
+	const keys = [
+		"best_of_n",
+		"context_handoff",
+		"parallel_worktrees",
+		"repo_map"
+	];
+	const source = pipeline;
+	const out = {};
+	for (const key of keys) if (source[key] !== void 0) out[key] = source[key];
+	return out;
+}
 function parsePipelineConfigParts(sources, projectRoot, sourcePaths = {
 	pipeline: PIPELINE_CONFIG_PATH,
 	profiles: PROFILES_CONFIG_PATH,
 	runners: RUNNERS_CONFIG_PATH
 }, options = {}) {
-	const runners = parseYamlAs(sources.runners, sourcePaths.runners, runnersFileSchema);
-	const profiles = parseYamlAs(sources.profiles, sourcePaths.profiles, profilesFileSchema);
-	const pipeline = parseYamlAs(sources.pipeline, sourcePaths.pipeline, pipelineFileSchema);
-	return validatePipelineConfig({
-		default_workflow: pipeline.default_workflow,
-		entrypoints: pipeline.entrypoints,
-		hooks: pipeline.hooks,
-		...profiles.mcp_gateway ? { mcp_gateway: profiles.mcp_gateway } : {},
-		mcp_servers: profiles.mcp_servers,
-		...pipeline.orchestrator ? { orchestrator: pipeline.orchestrator } : {},
-		profiles: profiles.profiles,
-		runner_command: pipeline.runner_command,
-		rules: profiles.rules,
-		runners: runners.runners,
-		scheduler: pipeline.scheduler,
-		schedules: pipeline.schedules,
-		skills: profiles.skills,
-		...pipeline.task_context ? { task_context: pipeline.task_context } : {},
-		token_budget: pipeline.token_budget,
-		version: 1,
-		workflows: pipeline.workflows
-	}, projectRoot, options);
+	return runConfigIoSync(parsePipelineConfigPartsEffect(sources, projectRoot, sourcePaths, options));
 }
-function parseYamlAs(source, sourcePath, schema) {
-	const document = parseDocument(source, {
-		prettyErrors: false,
-		uniqueKeys: true
+function parsePipelineConfigPartsEffect(sources, projectRoot, sourcePaths, options) {
+	return Effect.gen(function* () {
+		const runners = yield* parseConfigYamlAs(sources.runners, sourcePaths.runners, runnersFileSchema);
+		const profiles = yield* parseConfigYamlAs(sources.profiles, sourcePaths.profiles, profilesFileSchema);
+		const pipeline = yield* parseConfigYamlAs(sources.pipeline, sourcePaths.pipeline, pipelineFileSchema);
+		return validatePipelineConfig({
+			default_workflow: pipeline.default_workflow,
+			...durabilityField(pipeline.durability),
+			...pipe83Fields(pipeline),
+			entrypoints: pipeline.entrypoints,
+			hooks: pipeline.hooks,
+			...profiles.mcp_gateway ? { mcp_gateway: profiles.mcp_gateway } : {},
+			mcp_servers: profiles.mcp_servers,
+			...pipeline.orchestrator ? { orchestrator: pipeline.orchestrator } : {},
+			profiles: profiles.profiles,
+			runner_command: pipeline.runner_command,
+			rules: profiles.rules,
+			runners: runners.runners,
+			scheduler: pipeline.scheduler,
+			schedules: pipeline.schedules,
+			skills: profiles.skills,
+			...pipeline.task_context ? { task_context: pipeline.task_context } : {},
+			token_budget: pipeline.token_budget,
+			version: 1,
+			workflows: pipeline.workflows
+		}, projectRoot, options);
 	});
-	if (document.errors.length > 0) throw new PipelineConfigError("PIPELINE_CONFIG_PARSE_ERROR", `Failed to parse ${sourcePath}`, document.errors.map((err) => ({
-		message: err.message,
-		path: sourcePath
-	})));
-	const parsed = schema.safeParse(document.toJS());
-	if (!parsed.success) throw validationError(configIssuesFromZodError(parsed.error));
-	return parsed.data;
 }
 //#endregion
 export { loadPackagePipelineConfig, loadPipelineConfig, parsePipelineConfigParts, parsePipelineConfigYaml };

package/dist/config/schemas.d.ts

@@ -14,9 +14,14 @@ interface PipelineConfigIssue {
   message: string;
   path?: string;
 }
-declare class PipelineConfigError extends Error {
-  code: PipelineConfigErrorCode;
-  issues: PipelineConfigIssue[];
+declare const PipelineConfigError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "PipelineConfigError";
+} & Readonly<A>;
+declare class PipelineConfigError extends PipelineConfigError_base<{
+  readonly code: PipelineConfigErrorCode;
+  readonly message: string;
+  readonly issues: PipelineConfigIssue[];
+}> {
   constructor(code: PipelineConfigErrorCode, message: string, issues?: PipelineConfigIssue[]);
 }
 declare const workflowNodeBaseSchema: z.ZodObject<{
@@ -221,8 +226,8 @@ declare const configSchema: z.ZodObject<{
     policy: z.ZodOptional<z.ZodObject<{
       commands: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
-        deny: "deny";
         "trusted-only": "trusted-only";
+        deny: "deny";
       }>>;
       modules: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
@@ -245,9 +250,13 @@ declare const configSchema: z.ZodObject<{
       }>>;
     }, z.core.$strict>>>;
     default_profile: z.ZodOptional<z.ZodString>;
+    host_scope: z.ZodDefault<z.ZodEnum<{
+      project: "project";
+      global: "global";
+    }>>;
     mode: z.ZodEnum<{
-      local: "local";
       hosted: "hosted";
+      local: "local";
     }>;
     provider: z.ZodLiteral<"toolhive">;
     authorization_env: z.ZodDefault<z.ZodString>;
@@ -290,10 +299,10 @@ declare const configSchema: z.ZodObject<{
     }, z.core.$strict>>;
     output: z.ZodOptional<z.ZodObject<{
       format: z.ZodEnum<{
-        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
+        json_schema: "json_schema";
       }>;
       repair: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
@@ -362,10 +371,10 @@ declare const configSchema: z.ZodObject<{
         disabled: "disabled";
       }>>>;
       output_formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
+        json_schema: "json_schema";
       }>>>;
       rules: z.ZodOptional<z.ZodBoolean>;
       skills: z.ZodOptional<z.ZodBoolean>;
@@ -502,9 +511,17 @@ declare const configSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     model: z.ZodOptional<z.ZodString>;
   }, z.core.$strict>>;
+  durability: z.ZodOptional<z.ZodObject<{
+    dir: z.ZodDefault<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strict>>;
   parallel_worktrees: z.ZodOptional<z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
   }, z.core.$strict>>;
+  repo_map: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    token_budget: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strict>>;
   token_budget: z.ZodDefault<z.ZodObject<{
     default_context_window: z.ZodDefault<z.ZodNumber>;
     max_context_pct: z.ZodDefault<z.ZodNumber>;

package/dist/config/schemas.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { Data } from "effect";
 //#region src/config/schemas.ts
 const ID_RE = /^[a-z][a-z0-9-]*$/;
 const RUNNER_TYPES = ["opencode", "command"];
@@ -58,14 +59,13 @@ const DEFAULT_RUNNER_COMMAND_GIT_COMMITTER = {
 	email: "git@oisin.ee",
 	name: "oisin-bot"
 };
-var PipelineConfigError = class extends Error {
-	code;
-	issues;
+var PipelineConfigError = class extends Data.TaggedError("PipelineConfigError") {
 	constructor(code, message, issues = []) {
-		super(message);
-		this.name = "PipelineConfigError";
-		this.code = code;
-		this.issues = issues;
+		super({
+			code,
+			message,
+			issues
+		});
 	}
 };
 const strictRecord = (valueSchema) => z.record(z.string(), valueSchema);
@@ -155,6 +155,7 @@ const mcpGatewayBackendSchema = z.object({
 const mcpGatewaySchema = z.object({
 	backends: strictRecord(mcpGatewayBackendSchema).default({}),
 	default_profile: z.string().min(1).optional(),
+	host_scope: z.enum(["project", "global"]).default("project"),
 	mode: z.enum(["hosted", "local"]),
 	provider: z.literal("toolhive"),
 	authorization_env: z.string().min(1).default("PIPELINE_MCP_GATEWAY_AUTHORIZATION"),
@@ -466,12 +467,20 @@ const contextHandoffSchema = z.object({
 	model: z.string().optional()
 }).strict();
 const parallelWorktreesSchema = z.object({ enabled: z.boolean().default(false) }).strict();
+const durabilitySchema = z.object({
+	dir: z.string().min(1).default(".pipeline/journal"),
+	enabled: z.boolean().default(false)
+}).strict();
 const bestOfNSchema = z.object({
 	categories: z.array(z.string()).default(["green"]),
 	enabled: z.boolean().default(false),
 	judge_model: z.string().optional(),
 	n: z.number().int().positive().default(1)
 }).strict();
+const repoMapSchema = z.object({
+	enabled: z.boolean().default(false),
+	token_budget: z.number().int().positive().default(2e3)
+}).strict();
 const pipelineFileSchema = z.object({
 	default_workflow: z.string(),
 	entrypoints: strictRecord(entrypointSchema).default({}),
@@ -495,7 +504,9 @@ const pipelineFileSchema = z.object({
 	task_context: taskContextResolverSchema.optional(),
 	best_of_n: bestOfNSchema.optional(),
 	context_handoff: contextHandoffSchema.optional(),
+	durability: durabilitySchema.optional(),
 	parallel_worktrees: parallelWorktreesSchema.optional(),
+	repo_map: repoMapSchema.optional(),
 	token_budget: tokenBudgetSchema.default(DEFAULT_TOKEN_BUDGET),
 	workflows: strictRecord(workflowSchema).default({}),
 	version: z.literal(1)
@@ -529,7 +540,9 @@ const configSchema = z.object({
 	task_context: taskContextResolverSchema.optional(),
 	best_of_n: bestOfNSchema.optional(),
 	context_handoff: contextHandoffSchema.optional(),
+	durability: durabilitySchema.optional(),
 	parallel_worktrees: parallelWorktreesSchema.optional(),
+	repo_map: repoMapSchema.optional(),
 	token_budget: tokenBudgetSchema.default(DEFAULT_TOKEN_BUDGET),
 	version: z.literal(1),
 	workflows: strictRecord(workflowSchema).default({})

package/dist/context/repo-map.js

@@ -0,0 +1,203 @@
+import { estimateTokens } from "../token-estimator.js";
+import { createRequire } from "node:module";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+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",
+	".js",
+	".jsx",
+	".mjs",
+	".ts",
+	".tsx"
+]);
+const SKIP_DIRS = new Set([
+	"node_modules",
+	".git",
+	"dist",
+	".pipeline"
+]);
+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) {
+	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;
+}
+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 walkDir(dir, found) {
+	for (const entry of readdirSync(dir).sort()) handleEntry(join(dir, entry), entry, found);
+}
+function handleEntry(full, name, found) {
+	if (SKIP_DIRS.has(name)) return;
+	if (statSync(full).isDirectory()) {
+		walkDir(full, found);
+		return;
+	}
+	if (SOURCE_EXTENSIONS.has(extname(name))) found.push(full);
+}
+async function tagFile(root, file) {
+	const parser = await getParser();
+	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;
+}
+function addMatch(tags, path, match) {
+	const nameCapture = match.captures.find((c) => c.name === "name");
+	if (!nameCapture) return;
+	const name = nameCapture.node.text;
+	const def = match.captures.find((c) => c.name.startsWith("definition."));
+	if (def) {
+		tags.definitions.push({
+			endLine: def.node.endPosition.row + 1,
+			kind: def.name.slice(11),
+			name,
+			path,
+			startLine: def.node.startPosition.row + 1
+		});
+		return;
+	}
+	if (match.captures.some((c) => c.name.startsWith("reference."))) tags.references.push(name);
+}
+function definitionKey(def) {
+	return `def:${def.path}#${def.name}#${def.startLine}`;
+}
+function isSeeded(def, seedNames, artifacts) {
+	if (seedNames.has(def.name.toLowerCase())) return true;
+	return artifacts.some((artifact) => artifact.path === def.path && (!artifact.lineRange || def.startLine <= artifact.lineRange[1] && def.endLine >= artifact.lineRange[0]));
+}
+function buildGraph(fileTags, input) {
+	const seedNames = new Set(input.taskText.toLowerCase().match(WORD_RE) ?? []);
+	const graph = new Graph({
+		allowSelfLoops: false,
+		type: "directed"
+	});
+	const defsByName = /* @__PURE__ */ new Map();
+	for (const file of fileTags) for (const def of file.definitions) addDefNode(graph, defsByName, def, isSeeded(def, seedNames, input.artifacts));
+	linkReferences(graph, fileTags, defsByName);
+	return graph;
+}
+function addDefNode(graph, defsByName, def, matchedSeed) {
+	const key = definitionKey(def);
+	graph.mergeNode(key, {
+		def,
+		matchedSeed
+	});
+	defsByName.set(def.name, [...defsByName.get(def.name) ?? [], key]);
+}
+function linkReferences(graph, fileTags, defsByName) {
+	for (const file of fileTags) {
+		const fileKey = `file:${file.path}`;
+		graph.mergeNode(fileKey);
+		linkFileReferences(graph, fileKey, file.references, defsByName);
+	}
+}
+function linkFileReferences(graph, fileKey, references, defsByName) {
+	for (const name of references) for (const target of defsByName.get(name) ?? []) graph.mergeEdge(fileKey, target, { weight: 1 });
+}
+function pagerankScores(graph) {
+	try {
+		return pagerank(graph, {
+			getEdgeWeight: "weight",
+			maxIterations: 200,
+			tolerance: 1e-4
+		});
+	} catch {
+		return {};
+	}
+}
+function rankDefinitions(graph) {
+	const scores = pagerankScores(graph);
+	const ranked = [];
+	graph.forEachNode((key, attrs) => {
+		if (key.startsWith("def:")) ranked.push(toSymbol(attrs.def, Boolean(attrs.matchedSeed), scores[key] ?? 0));
+	});
+	return ranked.sort(compareSymbols);
+}
+function toSymbol(def, matchedSeed, pageRankScore) {
+	return {
+		kind: def.kind,
+		lineRange: [def.startLine, def.endLine],
+		matchedSeed,
+		name: def.name,
+		path: def.path,
+		score: pageRankScore + (matchedSeed ? SEED_BONUS : 0)
+	};
+}
+function compareSymbols(a, b) {
+	return b.score - a.score || a.path.localeCompare(b.path) || a.name.localeCompare(b.name) || a.lineRange[0] - b.lineRange[0];
+}
+function renderContext(selected) {
+	return ["Repo map context:", ...selected.map((s) => `## ${s.path}:${s.lineRange[0]}-${s.lineRange[1]}\n${s.kind} ${s.name}`)].join("\n");
+}
+function selectWithinBudget(ranked, budget, estimateTokens) {
+	let low = 0;
+	let high = ranked.length;
+	let best = 0;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		if (estimateTokens(renderContext(ranked.slice(0, mid))) <= budget) {
+			best = mid;
+			low = mid + 1;
+		} else high = mid - 1;
+	}
+	const selected = ranked.slice(0, best);
+	const context = renderContext(selected);
+	return {
+		context,
+		estimatedTokens: estimateTokens(context),
+		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
+	};
+}
+//#endregion
+export { buildRepoMapContext };

package/dist/install-commands/opencode.js

@@ -257,9 +257,18 @@ function namedOpencodePermissionMap(names) {
 function toolPermission(allowed, tool) {
 	return allowed.has(tool) ? "allow" : "deny";
 }
+/**
+* PIPE-83.11: whether to synthesize the singleton pipeline gateway into this
+* repo's `.opencode/opencode.json`. A "global"-scoped gateway is registered
+* once in the global opencode config (via `moka gateway configure-host
+* --scope global`) and inherited, so it is not embedded per project.
+*/
+function shouldEmbedProjectGateway(config) {
+	return config.mcp_gateway !== void 0 && config.mcp_gateway.host_scope !== "global";
+}
 function renderOpenCodeProjectConfig(config) {
 	return formatOpenCodeProjectJson({
-		...config.mcp_gateway ? JSON.parse(renderOpenCodeGatewayConfig(config)) : { $schema: "https://opencode.ai/config.json" },
+		...shouldEmbedProjectGateway(config) ? JSON.parse(renderOpenCodeGatewayConfig(config)) : { $schema: "https://opencode.ai/config.json" },
 		lsp: true,
 		...opencodePluginConfig(),
 		...opencodeProviderConfig()

package/dist/mcp/gateway-error.js

@@ -0,0 +1,15 @@
+import { Data } from "effect";
+//#region src/mcp/gateway-error.ts
+/**
+* Tagged error for the MCP (ToolHive) gateway subsystem. Lives in its own module
+* so both the gateway facade (src/mcp/gateway.ts) and the Effect service
+* (src/runtime/services/mcp-gateway-service.ts) can import it without forming a
+* circular dependency between them.
+*/
+var PipelineMcpGatewayError = class extends Data.TaggedError("PipelineMcpGatewayError") {
+	constructor(message) {
+		super({ message });
+	}
+};
+//#endregion
+export { PipelineMcpGatewayError };