@oisincoveney/pipeline 2.7.0 → 2.8.0

package/dist/runtime/parallel-worktrees/parallel-worktrees.js

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { execFileSync } from "node:child_process";
 //#region src/runtime/parallel-worktrees/parallel-worktrees.ts
 /**
@@ -13,6 +13,50 @@ import { execFileSync } from "node:child_process";
 const WORKTREE_ROOT = ".pipeline/worktrees";
 const REGISTRY_DIR = join(WORKTREE_ROOT, "registry");
 const OWNER = "oisin-pipeline";
+const GENERATED_WORKTREE_RESOURCES = [join(".opencode", "agents"), join(".opencode", "command")];
+function provisionGeneratedResources(repoRoot, worktreePath) {
+	for (const relativePath of GENERATED_WORKTREE_RESOURCES) {
+		const source = join(repoRoot, relativePath);
+		const target = join(worktreePath, relativePath);
+		if (existsSync(source) && !existsSync(target)) cpSync(source, target, { recursive: true });
+	}
+}
+function childWorktreeRelPath(runId, parentNodeId, childNodeId) {
+	return join(WORKTREE_ROOT, "trees", sanitize(runId ?? "local"), sanitize(parentNodeId), sanitize(childNodeId));
+}
+function changedWorktreeFiles(worktreePath) {
+	const modified = git(worktreePath, [
+		"diff",
+		"--name-only",
+		"HEAD"
+	]);
+	const untracked = git(worktreePath, [
+		"ls-files",
+		"--others",
+		"--exclude-standard"
+	]);
+	return [...modified.split("\n"), ...untracked.split("\n")].filter(Boolean);
+}
+function copyFileInto(fromRoot, toRoot, relativePath) {
+	const source = join(fromRoot, relativePath);
+	if (!existsSync(source)) return;
+	const dest = join(toRoot, relativePath);
+	mkdirSync(dirname(dest), { recursive: true });
+	cpSync(source, dest, { recursive: true });
+}
+/**
+* PIPE-83.14: promote a best-of-N winner's edits from its (retained) worktree
+* back into the main worktree, so downstream nodes (tests, verification) see the
+* selected candidate's changes. Copies modified + untracked files; no-op if the
+* worktree is gone. Returns the promoted file paths.
+*/
+function promoteWorktreeChanges(repoRoot, runId, parentNodeId, childNodeId) {
+	const worktreePath = join(repoRoot, childWorktreeRelPath(runId, parentNodeId, childNodeId));
+	if (!existsSync(worktreePath)) return [];
+	const files = changedWorktreeFiles(worktreePath);
+	for (const relativePath of files) copyFileInto(worktreePath, repoRoot, relativePath);
+	return files;
+}
 function git(cwd, args) {
 	return execFileSync("git", args, {
 		cwd,
@@ -33,7 +77,7 @@ function createChildWorktree(opts) {
 	const parentSeg = sanitize(opts.parentNodeId);
 	const childSeg = sanitize(opts.childNodeId);
 	const baseSha = git(opts.repoRoot, ["rev-parse", "HEAD"]);
-	const relPath = join(WORKTREE_ROOT, "trees", runSeg, parentSeg, childSeg);
+	const relPath = childWorktreeRelPath(opts.runId, opts.parentNodeId, opts.childNodeId);
 	const absPath = join(opts.repoRoot, relPath);
 	const branch = `pipeline/worktrees/${runSeg}/${parentSeg}/${childSeg}`;
 	const leaseId = `${runSeg}__${parentSeg}__${childSeg}`;
@@ -61,6 +105,7 @@ function createChildWorktree(opts) {
 		absPath,
 		baseSha
 	]);
+	provisionGeneratedResources(opts.repoRoot, absPath);
 	writeManifest(manifestPath, {
 		...manifest,
 		state: "active"
@@ -129,4 +174,4 @@ function gcParallelWorktrees(repoRoot) {
 	return results;
 }
 //#endregion
-export { createChildWorktree, gcParallelWorktrees };
+export { createChildWorktree, gcParallelWorktrees, promoteWorktreeChanges };

package/dist/runtime/run-journal.js

@@ -0,0 +1,21 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+//#region src/runtime/run-journal.ts
+function passedOnly(results) {
+	return results.filter((result) => result.status === "passed");
+}
+function readJournalFile(path) {
+	if (!existsSync(path)) return [];
+	return readFileSync(path, "utf8").split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+}
+function fileRunJournal(path) {
+	return {
+		record: (result) => {
+			mkdirSync(dirname(path), { recursive: true });
+			appendFileSync(path, `${JSON.stringify(result)}\n`);
+		},
+		resumeCompleted: () => passedOnly(readJournalFile(path))
+	};
+}
+//#endregion
+export { fileRunJournal };

package/dist/runtime/scheduler.js

@@ -1,44 +1,16 @@
 import { uniqueStrings } from "../strings.js";
-import { runWorkflowLifecycle } from "./workflow-lifecycle.js";
+import { Effect, Fiber, Queue } from "effect";
 //#region src/runtime/scheduler.ts
-var LocalScheduler = class {
-	options;
-	constructor(options) {
-		this.options = options;
-	}
-	async runWorkflow(plan, context) {
-		const options = this.options;
-		if (!options) throw new Error("LocalScheduler requires runtime options to run workflow");
-		return (await runWorkflowLifecycle({
-			buildResult: options.buildResult,
-			emitWorkflowPlanned: () => options.emitWorkflowPlanned(context),
-			emitWorkflowStarted: () => options.emitWorkflowStarted(context),
-			executeWorkflow: () => runWorkflowScheduler({
-				failFast: plan.execution.failFast,
-				fanOutWidth: context.config.token_budget?.fan_out_width,
-				isCancelled: () => options.isCancelled(context),
-				markNodeReady: (nodeId) => options.markNodeReady(nodeId, context),
-				maxParallelNodes: context.maxParallelNodes,
-				nodes: plan.topologicalOrder.map((node) => ({
-					category: node.category,
-					dependents: node.dependents,
-					id: node.id,
-					index: node.index,
-					needs: node.needs
-				})),
-				runNode: (nodeId) => options.executeNode(nodeId, context),
-				shouldContinueAfterNodeResult: (result) => options.shouldContinueAfterNodeResult(result, context),
-				skipNode: (nodeId, reason) => options.skipNode(nodeId, reason, context)
-			}),
-			isCancelled: () => options.isCancelled(context),
-			runWorkflowHook: (event, failure) => options.runWorkflowHook(event, failure, context)
-		})).result;
-	}
-};
-async function runWorkflowScheduler(input) {
-	const state = {
+function resumeFromJournal(input) {
+	return input.journal?.resumeCompleted() ?? [];
+}
+function recordToJournal(input, result) {
+	input.journal?.record(result);
+}
+function initialSchedulerState(input) {
+	return {
 		blocked: [],
-		completed: [],
+		completed: resumeFromJournal(input),
 		failFast: input.failFast,
 		fanOutWidth: input.fanOutWidth,
 		maxParallelNodes: input.maxParallelNodes,
@@ -46,50 +18,120 @@ async function runWorkflowScheduler(input) {
 		running: [],
 		shouldContinueAfterNodeResult: input.shouldContinueAfterNodeResult
 	};
-	const running = /* @__PURE__ */ new Map();
-	let failure;
-	while (true) {
-		if (input.isCancelled()) return {
-			completed: state.completed,
-			outcome: "CANCELLED"
-		};
-		launchReadyNodes(input, state, running);
-		if (running.size === 0) return {
-			completed: state.completed,
-			failure,
-			outcome: failure ? "FAIL" : "PASS"
-		};
-		let result;
-		try {
-			result = await Promise.race([...running.values()].map(({ promise }) => promise));
-		} catch (error) {
-			return {
-				completed: state.completed,
-				failure: workflowServiceFailure(error, "workflow.node"),
-				outcome: "FAIL"
-			};
-		}
-		running.delete(result.nodeId);
-		state.running = state.running.filter((nodeId) => nodeId !== result.nodeId);
-		state.completed = [...state.completed, result];
-		if (!isBlockingFailure(result, state)) continue;
-		failure ??= nodeRuntimeFailure(result);
-		if (input.failFast) {
-			const reason = `skipped because workflow fail_fast stopped after node '${result.nodeId}' failed`;
-			const skipped = unstartedNodeIds(state);
-			state.blocked = uniqueStrings([...state.blocked, ...skipped]);
-			for (const nodeId of skipped) input.skipNode(nodeId, reason);
-			continue;
+}
+function cancelledResult(state) {
+	return {
+		completed: state.completed,
+		outcome: "CANCELLED"
+	};
+}
+function terminalResult(state, failure) {
+	return {
+		completed: state.completed,
+		failure,
+		outcome: failure ? "FAIL" : "PASS"
+	};
+}
+function nodeErrorResult(state, error) {
+	return {
+		completed: state.completed,
+		failure: workflowServiceFailure(error, "workflow.node"),
+		outcome: "FAIL"
+	};
+}
+function runNodeFiber(ctx, nodeId) {
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => ctx.input.runNode(nodeId)
+	}).pipe(Effect.matchEffect({
+		onFailure: (error) => Queue.offer(ctx.completions, {
+			error,
+			kind: "error"
+		}),
+		onSuccess: (result) => Queue.offer(ctx.completions, {
+			kind: "ok",
+			result
+		})
+	}));
+}
+function launchReady(ctx) {
+	return Effect.gen(function* () {
+		const capacity = workflowNodeCapacity(ctx.state);
+		if (capacity <= 0) return;
+		for (const nodeId of selectLaunchableNodes(ctx.state, capacity)) {
+			ctx.input.markNodeReady(nodeId);
+			ctx.state.running = [...ctx.state.running, nodeId];
+			const fiber = yield* Effect.fork(runNodeFiber(ctx, nodeId));
+			ctx.running.set(nodeId, fiber);
 		}
-		const blocked = unstartedBlockingDescendants(result.nodeId, state);
-		state.blocked = uniqueStrings([...state.blocked, ...blocked]);
+	});
+}
+function applyFailFastSkip(ctx, result) {
+	const reason = `skipped because workflow fail_fast stopped after node '${result.nodeId}' failed`;
+	const skipped = unstartedNodeIds(ctx.state);
+	ctx.state.blocked = uniqueStrings([...ctx.state.blocked, ...skipped]);
+	for (const nodeId of skipped) ctx.input.skipNode(nodeId, reason);
+}
+function applyCompletion(ctx, result) {
+	ctx.running.delete(result.nodeId);
+	ctx.state.running = ctx.state.running.filter((id) => id !== result.nodeId);
+	ctx.state.completed = [...ctx.state.completed, result];
+	recordToJournal(ctx.input, result);
+	if (!isBlockingFailure(result, ctx.state)) return;
+	ctx.failure ??= nodeRuntimeFailure(result);
+	if (ctx.input.failFast) {
+		applyFailFastSkip(ctx, result);
+		return;
 	}
+	const blocked = unstartedBlockingDescendants(result.nodeId, ctx.state);
+	ctx.state.blocked = uniqueStrings([...ctx.state.blocked, ...blocked]);
+}
+function applyOutcome(ctx, outcome) {
+	return Effect.gen(function* () {
+		if (outcome.kind === "error") {
+			yield* Fiber.interruptAll(ctx.running.values());
+			return nodeErrorResult(ctx.state, outcome.error);
+		}
+		applyCompletion(ctx, outcome.result);
+	});
+}
+function schedulerTick(ctx) {
+	return Effect.gen(function* () {
+		if (ctx.input.isCancelled()) {
+			yield* Fiber.interruptAll(ctx.running.values());
+			return cancelledResult(ctx.state);
+		}
+		yield* launchReady(ctx);
+		if (ctx.running.size === 0) return terminalResult(ctx.state, ctx.failure);
+		return yield* applyOutcome(ctx, yield* Queue.take(ctx.completions));
+	});
+}
+function schedulerProgram(input) {
+	return Effect.gen(function* () {
+		const ctx = {
+			completions: yield* Queue.unbounded(),
+			input,
+			running: /* @__PURE__ */ new Map(),
+			state: initialSchedulerState(input)
+		};
+		while (true) {
+			const done = yield* schedulerTick(ctx);
+			if (done) return done;
+		}
+	});
+}
+function runWorkflowScheduler(input) {
+	return Effect.runPromise(schedulerProgram(input));
+}
+function settledNodeIds(context) {
+	const ids = new Set((context.completed ?? []).map((result) => result.nodeId));
+	for (const nodeId of context.running) ids.add(nodeId);
+	return ids;
 }
 function readyNodeIds(context) {
+	const settled = settledNodeIds(context);
 	const blocked = new Set(context.blocked ?? []);
-	const completed = new Set((context.completed ?? []).map((result) => result.nodeId));
-	const running = new Set(context.running);
-	return orderedNodes(context.nodes).filter((node) => !completed.has(node.id)).filter((node) => !running.has(node.id)).filter((node) => !blocked.has(node.id)).filter((node) => node.needs.every((need) => dependencyPassed(need, context))).map((node) => node.id);
+	return orderedNodes(context.nodes).filter((node) => !(settled.has(node.id) || blocked.has(node.id))).filter((node) => node.needs.every((need) => dependencyPassed(need, context))).map((node) => node.id);
 }
 function workflowNodeCapacity(context) {
 	const limit = context.failFast ? 1 : context.maxParallelNodes ?? context.nodes.length;
@@ -107,18 +149,6 @@ function unstartedBlockingDescendants(nodeId, context) {
 	}
 	return orderedNodes(context.nodes).map((node) => node.id).filter((descendantId) => descendants.has(descendantId)).filter((descendantId) => unstarted.has(descendantId));
 }
-function launchReadyNodes(input, state, running) {
-	const capacity = workflowNodeCapacity(state);
-	if (capacity <= 0) return;
-	for (const nodeId of selectLaunchableNodes(state, capacity)) {
-		input.markNodeReady(nodeId);
-		state.running = [...state.running, nodeId];
-		running.set(nodeId, {
-			nodeId,
-			promise: input.runNode(nodeId)
-		});
-	}
-}
 /**
 * Choose which ready nodes to launch this tick within the global capacity and
 * the per-category fan-out caps. A category at its cap defers its remaining
@@ -171,9 +201,8 @@ function isBlockingFailure(result, context) {
 	return result.status === "failed" && !(context.shouldContinueAfterNodeResult?.(result) ?? false);
 }
 function unstartedNodeIds(context) {
-	const completed = new Set((context.completed ?? []).map((result) => result.nodeId));
-	const running = new Set(context.running);
-	return orderedNodes(context.nodes).map((node) => node.id).filter((nodeId) => !completed.has(nodeId)).filter((nodeId) => !running.has(nodeId));
+	const settled = settledNodeIds(context);
+	return orderedNodes(context.nodes).map((node) => node.id).filter((nodeId) => !settled.has(nodeId));
 }
 function directDependents(nodeId, nodes) {
 	const declared = nodes.find((node) => node.id === nodeId)?.dependents ?? [];
@@ -201,4 +230,4 @@ function workflowServiceFailure(error, gate) {
 	};
 }
 //#endregion
-export { LocalScheduler };
+export { runWorkflowScheduler };

package/dist/runtime/select-candidate/select-candidate.js

@@ -2,6 +2,7 @@ import { createRunnerLaunchPlan } from "../../runner.js";
 import { normalizeRunnerOutput } from "../../runner-output.js";
 import { parseJsonObject } from "../json-validation/json-validation.js";
 import "../json-validation/index.js";
+import { promoteWorktreeChanges } from "../parallel-worktrees/parallel-worktrees.js";
 //#region src/runtime/select-candidate/select-candidate.ts
 const SCORE_RE = /-?\d+(?:\.\d+)?/;
 function selectBestCandidate(candidates) {
@@ -17,12 +18,23 @@ async function executeSelectCandidateBuiltin(context, node) {
 		exitCode: 1,
 		output: ""
 	};
+	const promoted = promoteWinner(context, node, selected.nodeId);
 	return {
-		evidence: [`select-candidate: selected '${selected.nodeId}' (judge=${selected.judgeScore ?? "n/a"}) from ${candidates.length} candidates`],
+		evidence: selectionEvidence(selected, candidates.length, promoted),
 		exitCode: 0,
 		output: selected.output
 	};
 }
+function selectionEvidence(selected, candidateCount, promoted) {
+	const lines = [`select-candidate: selected '${selected.nodeId}' (judge=${selected.judgeScore ?? "n/a"}) from ${candidateCount} candidates`];
+	if (promoted.length > 0) lines.push(`promoted ${promoted.length} file(s) from the winning worktree`);
+	return lines;
+}
+function promoteWinner(context, node, winnerNodeId) {
+	const parentNodeId = node?.needs.at(0);
+	if (!(context.config.parallel_worktrees?.enabled && parentNodeId)) return [];
+	return promoteWorktreeChanges(context.worktreePath, context.runId, parentNodeId, winnerNodeId);
+}
 async function scoreCandidates(context, candidates) {
 	const model = context.config.best_of_n?.judge_model;
 	const runner = Object.keys(context.config.runners).at(0);

package/dist/runtime/services/worktree-service.js

@@ -0,0 +1,18 @@
+import { createChildWorktree, gcParallelWorktrees } from "../parallel-worktrees/parallel-worktrees.js";
+import { Context, Effect, Layer } from "effect";
+//#region src/runtime/services/worktree-service.ts
+/**
+* Effect service over the git-worktree lifecycle (PIPE-83 follow-up). The Live
+* layer delegates to the synchronous porcelain helpers in parallel-worktrees;
+* the Effect-native parallel-node runtime composes `createChild`/`gc` through
+* this injectable seam instead of calling the helpers directly. This is the
+* canonical service shape for the Effect conversion: a `Context.Tag` whose Live
+* `Layer` wraps the underlying IO, provided once at the runPromise boundary.
+*/
+var WorktreeService = class extends Context.Tag("WorktreeService")() {};
+const WorktreeServiceLive = Layer.succeed(WorktreeService, {
+	createChild: (opts) => Effect.sync(() => createChildWorktree(opts)),
+	gc: (repoRoot) => Effect.sync(() => gcParallelWorktrees(repoRoot))
+});
+//#endregion
+export { WorktreeService, WorktreeServiceLive };

package/dist/schedule/passes/candidates.js

@@ -19,24 +19,33 @@ function expandBestOfNCandidates(config, artifact) {
 		}]))
 	};
 }
+function candidateChild(node, index) {
+	const child = {
+		...node,
+		id: `${node.id}--c${index + 1}`,
+		needs: []
+	};
+	child.task_context = void 0;
+	return child;
+}
 function expandNode(node, categories, n) {
 	if (node.kind !== "agent" || !categories.some((category) => node.id.includes(category))) return [node];
 	const candidatesId = `${node.id}--candidates`;
 	return [{
 		id: candidatesId,
 		kind: "parallel",
-		nodes: Array.from({ length: n }, (_, index) => ({
-			...node,
-			id: `${node.id}--c${index + 1}`,
-			needs: []
-		})),
+		nodes: Array.from({ length: n }, (_, index) => candidateChild(node, index)),
 		...node.needs ? { needs: node.needs } : {}
-	}, {
+	}, selectCandidateNode(node, candidatesId)];
+}
+function selectCandidateNode(node, candidatesId) {
+	return {
 		builtin: "select-candidate",
 		id: node.id,
 		kind: "builtin",
-		needs: [candidatesId]
-	}];
+		needs: [candidatesId],
+		...node.task_context ? { task_context: node.task_context } : {}
+	};
 }
 //#endregion
 export { expandBestOfNCandidates };

package/docs/config-architecture.md

@@ -164,6 +164,13 @@ Project-authored skill and rule paths resolve from the project root and must
 exist for runtime use. If default skill files are missing, run `moka init` to
 install them before executing workflows.
 
+`moka init --skill-scope` (PIPE-83.12) chooses how the default set is installed:
+`project` (default) vendors a repo-local copy (`skills add … --copy`,
+`skills-lock.json`); `personal` installs once at user/global scope
+(`skills add … --global`) so every repo the user opens inherits the skills with
+no per-repo copy and no project lockfile — the standardization path for a single
+user across many projects.
+
 MCP-enabled profiles use one gateway grant:
 
 ```yaml
@@ -352,6 +359,104 @@ The toposort uses `@dagrejs/graphlib` for the graph model but an iterative
 traversal for the topological sort, because graphlib's recursive topsort can
 overflow the call stack on deep generated workflow chains.
 
+## Context, durability & best-of-N features (PIPE-83)
+
+The shipped `defaults/pipeline.yaml` turns **`context_handoff`, `repo_map`,
+`durability`, `best_of_n` (n=2 on green), and `parallel_worktrees` ON** — moka
+uses its architecture by default. `best_of_n` is the cost/quality dial: n=2
+~doubles green-node spend, so lower `n` or set `enabled: false` to spend the
+minimum. Each block can be overridden in `pipeline.yaml`; the per-block
+`# default …` notes below mark the *schema* default that applies when a block is
+omitted entirely.
+
+### `context_handoff` — curated node-to-node handoffs
+
+```yaml
+context_handoff:
+  enabled: true          # default false
+  model: openai/gpt-5.5-fast   # optional cheap model for the deriving call
+```
+
+When enabled, each agent node derives a structured `NodeHandoff`
+(`summary`, `decisions`, `artifacts`, `testNames`, `openQuestions`) from its raw
+output via a cheap read-only finalizer. Downstream nodes then receive that
+curated handoff in their prompt instead of the upstream node's full transcript
+(`renderAgentPrompt`), which kills the prompt-bloat from re-hydrating every
+ancestor's output. When a node produces no handoff, consumers fall back to the
+raw output text, so disabling the flag is byte-identical to prior behaviour.
+
+### `parallel_worktrees` — isolated parallel children
+
+```yaml
+parallel_worktrees:
+  enabled: true          # default false
+```
+
+When enabled, every child of a `kind: parallel` node runs in its own git
+worktree on an auto-named branch (`.pipeline/worktrees/...`), so concurrent
+candidate edits cannot collide. Teardown is idempotent and crash-safe: a
+worktree with dirty or unpushed work is retained (never deleted), and orphaned
+worktrees are GC'd on the next parallel node under the same guard. A worktree is
+*not* a sandbox (node_modules/build state are shared) — real isolation remains
+k8s mode. SDK-runner nodes honour the per-child directory via `plan.cwd`.
+
+### `best_of_n` — generate N candidates and select the winner
+
+```yaml
+best_of_n:
+  enabled: true          # default false
+  n: 3                   # candidates per matching node (default 1 = off)
+  categories: [green]    # which node categories fan out (id-substring match)
+  judge_model: openai/gpt-5.5   # optional LLM judge; omit for status-only
+```
+
+When enabled with `n > 1`, the `candidates` schedule pass expands each matching
+agent node into a `kind: parallel` of N candidate children
+(`<node>--candidates`) feeding a `select-candidate` builtin that keeps the
+original node id. Each candidate builds in its own worktree (pair with
+`parallel_worktrees`) and is throttled by its category's
+`token_budget.fan_out_width` cap. The selector scores candidates by a hybrid of
+execution status (PASS/FAIL) and, when `judge_model` is set, a 0..1 LLM judge
+score; it emits the winner's output and **never self-fixes** — if no candidate
+passes, the node fails with evidence.
+
+### `durability` — durable crash-resume
+
+```yaml
+durability:
+  enabled: true              # default false
+  dir: .pipeline/journal     # default
+```
+
+When enabled, the scheduler journals each terminal node result to an
+append-only JSONL log under `dir`, keyed by run id (`<dir>/<runId>.jsonl`). A
+killed run, re-invoked with the same run id, resumes from the last **passed**
+node — finished nodes are not re-run and their tokens are not re-spent — while a
+failed node and everything downstream replay so fail-fast and blocked-descendant
+handling stay live. The journal is a swappable seam (`RunJournal`): the shipped
+`fileRunJournal` needs zero external infra; a future `@effect/workflow` / cluster
+provider can implement the same interface without touching the scheduler. Off by
+default → the scheduler runs purely in-memory, exactly as before.
+
+### `mcp_gateway.host_scope` — register the gateway once globally
+
+```yaml
+mcp_gateway:
+  provider: toolhive
+  mode: hosted
+  host_scope: global       # default "project"
+```
+
+The singleton pipeline gateway is normally synthesized into each repo's
+`.opencode/opencode.json` (`host_scope: project`, the default — unchanged
+goldens). Setting `host_scope: global` stops that per-project synthesis: the
+generated project config omits the `pipeline-gateway` MCP entry and instead
+inherits one global registration written once via
+`moka gateway configure-host --scope global` (which targets
+`$OPENCODE_CONFIG_DIR`/`$XDG_CONFIG_HOME/opencode/opencode.json`). This is the
+PIPE-83.11 standardization path — register the MCP gateway once per machine
+rather than re-emitting it into every project.
+
 ## Troubleshooting
 
 - Missing host resources: run `moka install-commands`; `moka run` loads the

package/package.json

@@ -6,18 +6,23 @@
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
     "commander": "^14.0.3",
+    "effect": "^3.21.3",
     "execa": "^9.5.2",
     "git-url-parse": "^16.1.0",
+    "graphology": "0.26.0",
+    "graphology-metrics": "2.4.0",
     "gray-matter": "^4.0.3",
     "js-tiktoken": "^1.0.21",
     "jsonc-parser": "^3.3.1",
     "ky": "^2.0.2",
     "micromatch": "^4.0.8",
-    "p-limit": "^7.3.0",
     "package-manager-detector": "^1.6.0",
     "pino": "^10.3.1",
     "secure-json-parse": "^4.1.0",
     "simple-git": "^3.36.0",
+    "tree-sitter-javascript": "0.25.0",
+    "tree-sitter-typescript": "0.23.2",
+    "web-tree-sitter": "0.26.9",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
@@ -121,7 +126,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "2.7.0",
+  "version": "2.8.0",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",