@oisincoveney/pipeline 2.6.0 → 2.8.0

package/dist/pipeline-init.js

@@ -2,7 +2,7 @@ import { installCommands } from "./install-commands.js";
 import { execa } from "execa";
 //#region src/pipeline-init.ts
 const DEFAULT_SKILL_INSTALL_SOURCE = "oisin-ee/skills";
-const DEFAULT_SKILL_INSTALL_ARGS = [
+const SKILL_INSTALL_AGENT_ARGS = [
 	"--agent",
 	"opencode",
 	"--agent",
@@ -11,17 +11,19 @@ const DEFAULT_SKILL_INSTALL_ARGS = [
 	"claude-code",
 	"--skill",
 	"*",
-	"--yes",
-	"--copy"
+	"--yes"
 ];
-async function installDefaultSkills(cwd) {
+function skillInstallArgs(scope) {
+	return scope === "personal" ? [...SKILL_INSTALL_AGENT_ARGS, "--global"] : [...SKILL_INSTALL_AGENT_ARGS, "--copy"];
+}
+async function installDefaultSkills(cwd, scope) {
 	try {
 		await execa("npx", [
 			"--yes",
 			"skills",
 			"add",
 			DEFAULT_SKILL_INSTALL_SOURCE,
-			...DEFAULT_SKILL_INSTALL_ARGS
+			...skillInstallArgs(scope)
 		], {
 			cwd,
 			stdio: "inherit"
@@ -33,17 +35,21 @@ async function installDefaultSkills(cwd) {
 }
 async function initPipelineProject(options = {}) {
 	const cwd = options.cwd ?? process.cwd();
-	await (options.skillInstaller ?? installDefaultSkills)(cwd);
-	return { files: (await installCommands({
-		cwd,
-		force: true,
-		host: "all"
-	})).items.map((item) => item.path) };
+	const scope = options.scope ?? "project";
+	await (options.skillInstaller ?? ((target) => installDefaultSkills(target, scope)))(cwd);
+	return {
+		files: (await installCommands({
+			cwd,
+			force: true,
+			host: "all"
+		})).items.map((item) => item.path),
+		scope
+	};
 }
 function formatPipelineInitResult(result) {
 	return [
 		"Initialized package-owned pipeline support:",
-		"installed default skills",
+		result.scope === "personal" ? "installed default skills at user/global scope (inherited by every repo, no per-repo copy)" : "installed default skills (repo-local copy)",
 		...result.files.map((path) => `generated ${path}`),
 		"no repo-local pipeline config files were created"
 	].join("\n");

package/dist/pipeline-runtime.js

@@ -18,12 +18,14 @@ import "./runtime/builtins/index.js";
 import { diffChangedFiles, snapshotChangedFiles } from "./runtime/changed-files/changed-files.js";
 import { evaluateNodeGates } from "./runtime/gates/gates.js";
 import "./runtime/gates/index.js";
+import { LocalScheduler } from "./runtime/local-scheduler.js";
 import { NodeStateTracker } from "./runtime/node-state-tracker.js";
 import { configUsesOpencode, leaseOpencodeRuntime } from "./runtime/opencode-runtime.js";
 import { executeParallelNode } from "./runtime/parallel-node/parallel-node.js";
 import "./runtime/parallel-node/index.js";
 import { decideNodeRetry, nodeRetryPolicy } from "./runtime/retry.js";
-import { LocalScheduler } from "./runtime/scheduler.js";
+import { fileRunJournal } from "./runtime/run-journal.js";
+import { join } from "node:path";
 //#region src/pipeline-runtime.ts
 function runPipelineFromConfig(options) {
 	return withOpencodeRuntime(options, (resolved) => runPipelineWithContext(createRuntimeContext(resolved)));
@@ -78,6 +80,14 @@ async function runWithLeasedOpencode(options, config, worktreePath, run) {
 		await lease.release();
 	}
 }
+function runJournalPath(context, dir) {
+	return join(context.worktreePath ?? process.cwd(), dir, `${context.runId}.jsonl`);
+}
+function resolveRunJournal(context) {
+	const durability = context.config.durability;
+	if (!(durability?.enabled && context.runId)) return;
+	return fileRunJournal(runJournalPath(context, durability.dir));
+}
 async function runPipelineWithContext(context) {
 	return finishRuntime(context, await new LocalScheduler({
 		buildResult: (outcome, nodes, failure) => workflowRuntimeResult(context, outcome, nodes, failure),
@@ -89,6 +99,7 @@ async function runPipelineWithContext(context) {
 			at: now(),
 			type: "READY"
 		}),
+		resolveJournal: (nextContext) => resolveRunJournal(nextContext),
 		runWorkflowHook: (event, failure, nextContext) => dispatchHooks(nextContext, event, failure),
 		shouldContinueAfterNodeResult: (result, nextContext) => shouldContinueAfterNodeResult(result, nextContext),
 		skipNode: (nodeId, reason, nextContext) => recordSkippedNodeState(nextContext, nodeId, reason, now())

package/dist/planning/compile.d.ts

@@ -7,9 +7,14 @@ interface WorkflowPlannerIssue {
   message: string;
   path?: string;
 }
-declare class WorkflowPlannerError extends Error {
-  code: WorkflowPlannerErrorCode;
-  issues: WorkflowPlannerIssue[];
+declare const WorkflowPlannerError_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: "WorkflowPlannerError";
+} & Readonly<A>;
+declare class WorkflowPlannerError extends WorkflowPlannerError_base<{
+  readonly code: WorkflowPlannerErrorCode;
+  readonly message: string;
+  readonly issues: WorkflowPlannerIssue[];
+}> {
   constructor(code: WorkflowPlannerErrorCode, message: string, issues?: WorkflowPlannerIssue[]);
 }
 interface PlannedWorkflowNode {

package/dist/planning/compile.js

@@ -1,15 +1,15 @@
 import { uniqueStrings } from "../strings.js";
 import { findDependencyCycles } from "./graph.js";
+import { Data } from "effect";
 import { Graph } from "@dagrejs/graphlib";
 //#region src/planning/compile.ts
-var WorkflowPlannerError = class extends Error {
-	code;
-	issues;
+var WorkflowPlannerError = class extends Data.TaggedError("WorkflowPlannerError") {
 	constructor(code, message, issues = []) {
-		super(message);
-		this.name = "WorkflowPlannerError";
-		this.code = code;
-		this.issues = issues;
+		super({
+			code,
+			message,
+			issues
+		});
 	}
 };
 function compileWorkflowPlan(config, workflowId = config.default_workflow) {

package/dist/planning/generate.d.ts

@@ -1594,7 +1594,12 @@ interface SchedulePlanningContext {
   workUnits: BacklogWorkUnit[];
 }
 declare function parseScheduleArtifact(source: string, sourcePath?: string): ScheduleArtifact;
-declare class ScheduleArtifactError extends Error {
+declare const ScheduleArtifactError_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: "ScheduleArtifactError";
+} & Readonly<A>;
+declare class ScheduleArtifactError extends ScheduleArtifactError_base<{
+  readonly message: string;
+}> {
   constructor(message: string);
 }
 declare function compileScheduleArtifact(config: PipelineConfig, artifact: ScheduleArtifact, projectRoot?: string): CompiledScheduleArtifact;

package/dist/planning/generate.js

@@ -17,6 +17,7 @@ import { plannerPrompt, plannerRepairPrompt } from "../schedule/prompts.js";
 import { compileWorkflowPlan } from "./compile.js";
 import { parseDocument, stringify } from "yaml";
 import { z } from "zod";
+import { Data } from "effect";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/planning/generate.ts
@@ -30,10 +31,12 @@ const SCHEDULE_BUILTINS = [
 	"duplication",
 	"fallow",
 	"lint",
+	"select-candidate",
 	"semgrep",
 	"test",
 	"typecheck"
 ];
+const PARALLEL_MERGE_BUILTINS = new Set(["drain-merge", "select-candidate"]);
 const scheduleArtifactSchema = z.object({
 	generated_at: z.string().datetime(),
 	kind: z.literal(SCHEDULE_KIND),
@@ -54,10 +57,9 @@ function parseScheduleArtifact(source, sourcePath = "schedule.yaml") {
 	if (!parsed.success) throw new ScheduleArtifactError([`Invalid schedule artifact ${sourcePath}:`, ...parsed.error.issues.map((issue) => issue.path.length > 0 ? `- ${issue.path.join(".")}: ${issue.message}` : `- ${issue.message}`)].join("\n"));
 	return parsed.data;
 }
-var ScheduleArtifactError = class extends Error {
+var ScheduleArtifactError = class extends Data.TaggedError("ScheduleArtifactError") {
 	constructor(message) {
-		super(message);
-		this.name = "ScheduleArtifactError";
+		super({ message });
 	}
 };
 function compileScheduleArtifact(config, artifact, projectRoot) {
@@ -255,11 +257,28 @@ function unsafeParallelWorktreeIssues(config, artifact) {
 		return [`parallel node '${workflowId}.${node.id}' has write-capable children sharing a worktree without isolated worktree roots or drain-merge integration`];
 	}));
 }
+function registerContainmentEdge(parent, child, index) {
+	const dependents = index.get(child.id) ?? [];
+	dependents.push(parent);
+	index.set(child.id, dependents);
+}
+function addParallelContainmentEdges(nodes, index) {
+	for (const node of nodes) {
+		if (node.kind !== "parallel") continue;
+		for (const child of node.nodes) registerContainmentEdge(node, child, index);
+		addParallelContainmentEdges(node.nodes, index);
+	}
+}
+function dependentsByNeedWithContainment(nested, flat) {
+	const index = dependentsByNeed(flat);
+	addParallelContainmentEdges(nested, index);
+	return index;
+}
 function workflowNodeIssues(artifact, collectIssues) {
 	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
 		const nodes = flattenWorkflowNodes(workflow.nodes);
 		return collectIssues({
-			dependentsByNeed: dependentsByNeed(nodes),
+			dependentsByNeed: dependentsByNeedWithContainment(workflow.nodes, nodes),
 			nodes,
 			workflowId
 		});
@@ -272,7 +291,7 @@ function isWriteCapableParallelChild(config, node) {
 	return false;
 }
 function hasDownstreamDrainMerge(nodeId, index) {
-	return hasReachableDependent(nodeId, index, (node) => node.kind === "builtin" && node.builtin === "drain-merge");
+	return hasReachableDependent(nodeId, index, (node) => node.kind === "builtin" && PARALLEL_MERGE_BUILTINS.has(node.builtin));
 }
 function generatedRootWorkflowIssues(artifact) {
 	const workflowIds = Object.keys(artifact.workflows);
@@ -324,9 +343,9 @@ function workUnitDependencyIssues(config, artifact, workUnits) {
 	const dependenciesByUnit = new Map(workUnits.map((unit) => [unit.id, (unit.dependencies ?? []).filter((id) => workUnitIds.has(id))]));
 	return Object.entries(artifact.workflows).flatMap(([workflowId, workflow]) => {
 		const nodes = flattenWorkflowNodes(workflow.nodes);
-		const index = dependentsByNeed(nodes);
+		const index = dependentsByNeedWithContainment(workflow.nodes, nodes);
 		const nodesByWorkUnit = nodesByAssignedWorkUnit(nodes);
-		return nodes.filter((node) => isImplementationNode(config, node)).flatMap((node) => {
+		return nodes.filter((node) => isImplementationNode(config, node) || isSelectCandidateNode(node)).flatMap((node) => {
 			const dependentId = node.task_context?.id;
 			if (!dependentId) return [];
 			return (dependenciesByUnit.get(dependentId) ?? []).flatMap((prerequisiteId) => {
@@ -336,6 +355,9 @@ function workUnitDependencyIssues(config, artifact, workUnits) {
 		});
 	});
 }
+function isSelectCandidateNode(node) {
+	return node.kind === "builtin" && node.builtin === "select-candidate";
+}
 function nodesByAssignedWorkUnit(nodes) {
 	const grouped = /* @__PURE__ */ new Map();
 	for (const node of nodes) {

package/dist/runner-command-contract.d.ts

@@ -140,8 +140,13 @@ interface RunnerCommandPayloadValidationIssue {
   message: string;
   path: string;
 }
-declare class RunnerCommandPayloadValidationError extends Error {
+declare const RunnerCommandPayloadValidationError_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: "RunnerCommandPayloadValidationError";
+} & Readonly<A>;
+declare class RunnerCommandPayloadValidationError extends RunnerCommandPayloadValidationError_base<{
+  readonly message: string;
   readonly issues: RunnerCommandPayloadValidationIssue[];
+}> {
   constructor(message: string, issues: RunnerCommandPayloadValidationIssue[]);
 }
 interface BuildRunnerCommandPayloadOptions {

package/dist/runner-command-contract.js

@@ -1,5 +1,6 @@
 import { parseJson } from "./safe-json.js";
 import { z } from "zod";
+import { Data } from "effect";
 import { readFileSync } from "node:fs";
 import parseGitUrl from "git-url-parse";
 //#region src/runner-command-contract.ts
@@ -71,12 +72,12 @@ const runnerCommandPayloadSchema = z.object({
 	task: runnerTaskSchema,
 	workflow: runnerWorkflowIdentitySchema
 }).strict();
-var RunnerCommandPayloadValidationError = class extends Error {
-	issues;
+var RunnerCommandPayloadValidationError = class extends Data.TaggedError("RunnerCommandPayloadValidationError") {
 	constructor(message, issues) {
-		super(message);
-		this.name = "RunnerCommandPayloadValidationError";
-		this.issues = issues;
+		super({
+			message,
+			issues
+		});
 	}
 };
 function resolveRunnerEventSinkAuthToken(options) {

package/dist/runner-event-schema.d.ts

@@ -10,8 +10,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
   sequence: z.ZodNumber;
   type: z.ZodEnum<{
-    "workflow.start": "workflow.start";
     "workflow.planned": "workflow.planned";
+    "workflow.start": "workflow.start";
   }>;
   workflowPlan: z.ZodObject<{
     edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -55,10 +55,10 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
     }>;
   }, z.core.$strip>;
   type: z.ZodEnum<{
-    "node.start": "node.start";
-    "node.finish": "node.finish";
     "agent.finish": "agent.finish";
     "agent.start": "agent.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
   }>;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
@@ -180,8 +180,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
     sequence: z.ZodNumber;
     type: z.ZodEnum<{
-      "workflow.start": "workflow.start";
       "workflow.planned": "workflow.planned";
+      "workflow.start": "workflow.start";
     }>;
     workflowPlan: z.ZodObject<{
       edges: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -225,10 +225,10 @@ declare const runnerEventBatchSchema: z.ZodObject<{
       }>;
     }, z.core.$strip>;
     type: z.ZodEnum<{
-      "node.start": "node.start";
-      "node.finish": "node.finish";
       "agent.finish": "agent.finish";
       "agent.start": "agent.start";
+      "node.finish": "node.finish";
+      "node.start": "node.start";
     }>;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;

package/dist/runner-event-sink.js

@@ -1,4 +1,5 @@
 import { mapRuntimeEventToRunnerEventRecords } from "./runner-command-contract.js";
+import { Data } from "effect";
 import ky, { isHTTPError } from "ky";
 //#region src/runner-event-sink.ts
 const DEFAULT_BATCH_SIZE = 50;
@@ -20,12 +21,12 @@ const RETRYABLE_STATUS_CODES = [
 	510,
 	511
 ];
-var EventSinkHttpError = class extends Error {
-	status;
+var EventSinkHttpError = class extends Data.TaggedError("EventSinkHttpError") {
 	constructor(status, message) {
-		super(message);
-		this.name = "EventSinkHttpError";
-		this.status = status;
+		super({
+			status,
+			message
+		});
 	}
 };
 function createRunnerEventSink(options) {

package/dist/runner.d.ts

@@ -80,7 +80,12 @@ interface RunnerLaunchInput {
   prompt: string;
   worktreePath: string;
 }
-declare class RunnerCapabilityError extends Error {
+declare const RunnerCapabilityError_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: "RunnerCapabilityError";
+} & Readonly<A>;
+declare class RunnerCapabilityError extends RunnerCapabilityError_base<{
+  readonly message: string;
+}> {
   constructor(message: string);
 }
 /**

package/dist/runner.js

@@ -1,11 +1,11 @@
+import { Data } from "effect";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { execa } from "execa";
 //#region src/runner.ts
-var RunnerCapabilityError = class extends Error {
+var RunnerCapabilityError = class extends Data.TaggedError("RunnerCapabilityError") {
 	constructor(message) {
-		super(message);
-		this.name = "RunnerCapabilityError";
+		super({ message });
 	}
 };
 const OPENCODE_EXCLUDES = [

package/dist/runtime/agent-node/agent-node.js

@@ -6,9 +6,10 @@ import { normalizeJsonSource, readJsonSchemaSource, validateJsonSchemaSource } f
 import "../json-validation/index.js";
 import { emit, emitAgentFinish, emitAgentStart } from "../events/events.js";
 import "../events/index.js";
+import { estimateTokens } from "../../token-estimator.js";
+import { buildRepoMapContext } from "../../context/repo-map.js";
 import { gatewayServerForProfile } from "../../mcp/gateway.js";
 import { selectNodeModel } from "../../model-resolver.js";
-import { estimateTokens } from "../../token-estimator.js";
 import { handoffFinalizerPrompt, parseHandoff, renderHandoff, synthesizeMinimalHandoff } from "../handoff.js";
 import { readFileSync } from "node:fs";
 //#region src/runtime/agent-node/agent-node.ts
@@ -18,7 +19,7 @@ async function executeAgentNode(node, context, attempt) {
 		exitCode: 1,
 		output: ""
 	};
-	const prompt = renderAgentPrompt(node, context);
+	const prompt = await renderAgentPrompt(node, context);
 	const decision = decideNodeModel(prompt, node, context.config.token_budget);
 	if (decision.overBudget) return {
 		evidence: [
@@ -307,11 +308,28 @@ function createOutputRepairPlan(inputs) {
 function normalizeAgentOutput(plan, stdout) {
 	return normalizeRunnerOutput(plan, stdout);
 }
-function renderAgentPrompt(node, context) {
+async function repoMapSection(node, context) {
+	const repoMap = context.config.repo_map;
+	if (!repoMap?.enabled) return "";
+	try {
+		return (await buildRepoMapContext({
+			artifacts: node.needs.flatMap((need) => context.nodeStateStore.handoff(need)?.artifacts ?? []),
+			taskText: context.task,
+			tokenBudget: repoMap.token_budget,
+			worktreePath: context.worktreePath
+		})).context;
+	} catch {
+		return "";
+	}
+}
+async function renderAgentPrompt(node, context) {
 	const profile = node.profile ? context.config.profiles[node.profile] : void 0;
+	const instructions = profile ? readInstructions(context.worktreePath, profile.instructions) : "";
+	const repoMap = await repoMapSection(node, context);
 	return [
-		(profile ? readInstructions(context.worktreePath, profile.instructions) : "").trim(),
+		instructions.trim(),
 		"",
+		repoMap,
 		`Task: ${context.task}`,
 		`Workflow: ${context.workflowId}`,
 		`Node: ${node.id}`,

package/dist/runtime/local-scheduler.js

@@ -0,0 +1,45 @@
+import { runWorkflowLifecycle } from "./workflow-lifecycle.js";
+import { runWorkflowScheduler } from "./scheduler.js";
+//#region src/runtime/local-scheduler.ts
+/**
+* The local, in-process scheduler seam. It owns workflow lifecycle hooks and
+* delegates the topological fan-out/gating loop to `runWorkflowScheduler`,
+* passing the durability journal (PIPE-83.10) through to it.
+*/
+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),
+				journal: options.resolveJournal?.(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;
+	}
+};
+//#endregion
+export { LocalScheduler };

package/dist/runtime/opencode-server.js

@@ -1,10 +1,13 @@
+import { Data } from "effect";
 import { createOpencode, createOpencodeClient } from "@opencode-ai/sdk";
 //#region src/runtime/opencode-server.ts
 const DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
-var OpencodeServerStartupError = class extends Error {
+var OpencodeServerStartupError = class extends Data.TaggedError("OpencodeServerStartupError") {
 	constructor(message, options) {
-		super(message, options);
-		this.name = "OpencodeServerStartupError";
+		super({
+			message,
+			cause: options?.cause
+		});
 	}
 };
 async function openOpencodeServer(options) {