@oisincoveney/pipeline 2.6.0 → 2.8.0

package/defaults/pipeline.yaml

@@ -2,6 +2,31 @@ version: 1
 default_workflow: inspect
 orchestrator:
   profile: moka-orchestrator
+# PIPE-83 architecture hardening — ON by default so moka actually uses it.
+# context_handoff: nodes pass curated NodeHandoffs downstream instead of raw
+# transitive transcripts (kills the re-hydration latency/quality leak).
+context_handoff:
+  enabled: true
+# repo_map: prepend a tree-sitter + PageRank ranked code map to agent prompts,
+# seeded by the node's task + handoff artifacts, within token_budget.
+repo_map:
+  enabled: true
+# durability: journal each terminal node result so a killed run resumes from the
+# last passed node without re-running (or re-spending tokens on) finished work.
+durability:
+  enabled: true
+# best_of_n / parallel_worktrees: the verifier-pattern dial. Schedule generation
+# + selection are validated/tested, BUT a live end-to-end run (2026-06-16) proved
+# the EXECUTION is not yet production-ready, so it stays OFF by default (on-by-
+# default made real runs hang). Two runtime gaps remain — see PIPE-83.14:
+#   1. The leased opencode server is rooted at the main worktree and throws
+#      "Unexpected server error" when a candidate session runs with directory set
+#      to its isolated worktree → candidates exit 70, retries exhaust, green loops.
+#      Fix: lease a per-worktree opencode server for each candidate.
+#   2. The winning candidate's file changes live in its worktree and are never
+#      merged back to the main tree, so downstream nodes wouldn't see them.
+# Enable explicitly (best_of_n.enabled + n:2 + categories:[green] + parallel_
+# worktrees.enabled) once those land; n=2 also ~doubles green-node spend.
 token_budget:
   default_context_window: 200000
   max_context_pct: 50

package/dist/argo-graph.js

@@ -1,5 +1,6 @@
 import { uniqueStrings } from "./strings.js";
 import { z } from "zod";
+import { Data } from "effect";
 //#region src/argo-graph.ts
 const argoExecutableTaskSchema = z.object({
 	dependencies: z.array(z.string().min(1)),
@@ -18,14 +19,13 @@ const argoExecutionGraphSchema = z.object({
 * lowered to an Argo DAG task. Callers should surface this as a validation
 * failure before attempting a cluster submission.
 */
-var ArgoGraphCompilerError = class extends Error {
-	kind;
-	nodeId;
+var ArgoGraphCompilerError = class extends Data.TaggedError("ArgoGraphCompilerError") {
 	constructor(kind, nodeId) {
-		super(`Argo graph compiler: node kind '${kind}' on node '${nodeId}' cannot be lowered to an Argo DAG task`);
-		this.name = "ArgoGraphCompilerError";
-		this.kind = kind;
-		this.nodeId = nodeId;
+		super({
+			kind,
+			nodeId,
+			message: `Argo graph compiler: node kind '${kind}' on node '${nodeId}' cannot be lowered to an Argo DAG task`
+		});
 	}
 };
 function compileArgoExecutionGraph(plan) {

package/dist/bench/eval-report.js

@@ -0,0 +1,27 @@
+//#region src/bench/eval-report.ts
+function buildEvalReport(results) {
+	const variants = [...new Set(results.map((r) => r.variant))].sort();
+	return {
+		tasks: new Set(results.map((r) => r.task)).size,
+		variants: variants.map((variant) => summarizeVariant(variant, results.filter((r) => r.variant === variant)))
+	};
+}
+function summarizeVariant(variant, runs) {
+	const resolved = runs.filter((r) => r.resolved).length;
+	const totalWall = runs.reduce((sum, r) => sum + r.wallMs, 0);
+	return {
+		avgWallMs: runs.length ? Math.round(totalWall / runs.length) : 0,
+		count: runs.length,
+		resolutionRate: runs.length ? resolved / runs.length : 0,
+		resolved,
+		totalCostTokens: runs.reduce((sum, r) => sum + r.costTokens, 0),
+		variant
+	};
+}
+function renderEvalReport(report) {
+	const lines = [`Eval over ${report.tasks} task(s):`, "variant | resolved | rate | tokens | avg ms"];
+	for (const v of report.variants) lines.push(`${v.variant} | ${v.resolved}/${v.count} | ${(v.resolutionRate * 100).toFixed(0)}% | ${v.totalCostTokens} | ${v.avgWallMs}`);
+	return lines.join("\n");
+}
+//#endregion
+export { buildEvalReport, renderEvalReport };

package/dist/cli/program.js

@@ -7,8 +7,11 @@ import { compileScheduleArtifact, generateScheduleArtifact, parseScheduleArtifac
 import { loadMokaGlobalConfig } from "../moka-global-config.js";
 import { defaultClusterDoctorNamespace, runClusterDoctor } from "../cluster-doctor.js";
 import { formatCodexAuthSyncResult, syncLocalCodexAuth } from "../codex-auth-sync.js";
+import { registerBenchCommand } from "../commands/bench-command.js";
 import { registerConfiguredEntrypointCommands } from "../commands/pipeline-command.js";
 import { configureGatewayHosts, localGatewayStatus, reconcileGateway, renderGatewayConfig, runGatewayDoctor, startLocalGateway } from "../mcp/gateway.js";
+import { generateRuntimeRunId } from "../runtime/context/context.js";
+import "../runtime/context/index.js";
 import { runPipelineFromConfig } from "../pipeline-runtime.js";
 import { registerRunnerCommandCommand } from "../commands/runner-command-command.js";
 import { formatConfigLintWarning, lintPipelineConfig } from "../config/lint.js";
@@ -47,7 +50,14 @@ function quick(description, options = {}) {
 		entrypoint: "quick"
 	});
 }
-async function runConfiguredPipeline(inputs) {
+function withRunId(inputs) {
+	return {
+		...inputs,
+		runId: inputs.runId ?? generateRuntimeRunId()
+	};
+}
+async function runConfiguredPipeline(rawInputs) {
+	const inputs = withRunId(rawInputs);
 	const config = loadPipelineConfig(inputs.worktreePath, { allowMissingLintFileReferences: true });
 	if (inputs.schedule) {
 		const compiled = compileScheduleArtifact(config, parseScheduleArtifact(readFileSync(inputs.schedule, "utf8"), inputs.schedule), inputs.worktreePath);
@@ -70,6 +80,7 @@ async function runConfiguredPipeline(inputs) {
 		const result = await generateScheduleArtifact({
 			config,
 			entrypointId: scheduledEntrypoint,
+			runId: inputs.runId,
 			task: inputs.task,
 			worktreePath: inputs.worktreePath
 		});
@@ -94,6 +105,7 @@ async function runAndPrintPipeline(inputs) {
 		config: inputs.config,
 		reporter,
 		entrypoint: inputs.entrypoint,
+		runId: inputs.runId,
 		task: inputs.task,
 		workflowId: inputs.workflow,
 		worktreePath: inputs.worktreePath
@@ -177,8 +189,11 @@ function createCliProgram() {
 		const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
 		console.log(await localGatewayStatus(cwd));
 	});
-	program.command("init").description("Initialize package-owned pipeline support without repo-local config").action(async () => {
-		const result = await initPipelineProject({ cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd() });
+	program.command("init").description("Initialize package-owned pipeline support without repo-local config").addOption(new Option("--skill-scope <scope>", "where to install default skills: project (repo-local copy) or personal (one inherited user/global install)").choices(["project", "personal"]).default("project")).action(async (flags) => {
+		const result = await initPipelineProject({
+			cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd(),
+			scope: flags.skillScope
+		});
 		console.log(formatPipelineInitResult(result));
 	});
 	program.command("install-commands").description("Install generated slash-command adapters into this repository").addOption(new Option("--host <host>", "host command set to install").choices([
@@ -207,6 +222,7 @@ function createCliProgram() {
 		if (result.workflowUid) console.log(`Workflow UID: ${result.workflowUid}`);
 	});
 	registerRunnerCommandCommand(program);
+	registerBenchCommand(program);
 	const configuredEntrypointCommands = registerConfiguredEntrypointCommands(program, omitConfiguredEntrypoints(configuredPipeline, ["execute", "quick"]), async (entrypoint, task, _opts) => {
 		await execute(task, { entrypoint });
 	});

package/dist/commands/bench-command.js

@@ -0,0 +1,18 @@
+import { buildEvalReport, renderEvalReport } from "../bench/eval-report.js";
+import { readFileSync } from "node:fs";
+//#region src/commands/bench-command.ts
+/**
+* PIPE-83.6: `moka bench` — score a flat single-agent baseline vs the pipeline
+* (and ablations) over a recorded run set. Runs are produced by executing the
+* bench task set (bench/tasks) through `moka run` for each variant and recording
+* one EvalRunResult per task+variant; this command turns those records into the
+* comparison report.
+*/
+function registerBenchCommand(program) {
+	program.command("bench").description("Score a flat single-agent baseline vs the pipeline over recorded bench runs").requiredOption("--results <path>", "JSON file: array of { task, variant, resolved, costTokens, wallMs }").action((options) => {
+		const records = JSON.parse(readFileSync(options.results, "utf8"));
+		process.stdout.write(`${renderEvalReport(buildEvalReport(records))}\n`);
+	});
+}
+//#endregion
+export { registerBenchCommand };

package/dist/config/load.js

@@ -28,6 +28,21 @@ 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,
@@ -38,6 +53,8 @@ function parsePipelineConfigParts(sources, projectRoot, sourcePaths = {
 	const pipeline = parseYamlAs(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 } : {},

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<{
@@ -245,6 +250,10 @@ 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";
@@ -344,8 +353,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<{
@@ -485,8 +494,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<{
@@ -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.js

@@ -1,5 +1,6 @@
 import { resolveRepoLocalBackendSpecs } from "./repo-local-backends.js";
 import { renderToolHiveVmcpInventory } from "./toolhive-vmcp.js";
+import { Data } from "effect";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
@@ -9,10 +10,9 @@ const PIPELINE_GATEWAY_SERVER_ID = "pipeline-gateway";
 const DEFAULT_LOCAL_GATEWAY_URL = "http://127.0.0.1:4483/mcp";
 const LEGACY_OPENCODE_MCP_RE = /"mcp"\s*:\s*{(?!\s*"pipeline-gateway")/s;
 const LEGACY_PIPELINE_MCP_RE = /path:\s*\.mcp\.json|uvx\s+mcpm|mcpm\s+run/;
-var PipelineMcpGatewayError = class extends Error {
+var PipelineMcpGatewayError = class extends Data.TaggedError("PipelineMcpGatewayError") {
 	constructor(message) {
-		super(message);
-		this.name = "PipelineMcpGatewayError";
+		super({ message });
 	}
 };
 function profileNeedsMcpGateway(actor) {

package/dist/moka-submit.d.ts

@@ -5,13 +5,13 @@ import { z } from "zod";
 //#region src/moka-submit.d.ts
 declare const mokaSubmitDirectHooksSchema: z.ZodRecord<z.ZodEnum<{
   "workflow.start": "workflow.start";
+  "node.finish": "node.finish";
+  "node.start": "node.start";
   "workflow.success": "workflow.success";
   "workflow.failure": "workflow.failure";
   "workflow.complete": "workflow.complete";
-  "node.start": "node.start";
   "node.success": "node.success";
   "node.error": "node.error";
-  "node.finish": "node.finish";
   "gate.failure": "gate.failure";
 }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
   failure: z.ZodDefault<z.ZodEnum<{
@@ -94,13 +94,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
-    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
-    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{
@@ -206,13 +206,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
-    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
-    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{