@oisincoveney/pipeline 1.11.1 → 1.11.3

package/README.md

@@ -11,8 +11,8 @@ artifacts.
 - Bun 1.1 or newer
 - Node.js 22.13 or newer
 - `npx`, `backlog`, `uvx`, and Docker on `PATH` for default skills and MCP setup
-- At least one configured runner CLI on `PATH`: `codex`, `claude`,
-  `opencode`, `kimi`, `pi`, or a declared command runner
+- At least one configured runner CLI on `PATH`: `codex`, `opencode`, `kimi`,
+  `pi`, or a declared command runner
 
 Install dependencies:
 
@@ -307,7 +307,6 @@ The installer creates one command surface per configured entrypoint.
 
 | Host        | Generated files                                                   | Invocation                         |
 | ----------- | ----------------------------------------------------------------- | ---------------------------------- |
-| Claude Code | `.claude/commands/<entrypoint>.md`, `.claude/agents/*.md`         | `/pipe <task>`, `/inspect <task>`, `/epic <task>` |
 | Codex       | `.agents/skills/<entrypoint>/SKILL.md`, `.agents/plugins/oisin-pipeline/commands/<entrypoint>.md`, `.agents/plugins/oisin-pipeline/agents/*.md`, `.codex/config.toml` | `$pipe <task>`, `$inspect <task>`, `$epic <task>`, `/pipe <task>`, `/inspect <task>`, `/epic <task>` |
 | OpenCode    | `.opencode/commands/<entrypoint>.md`, `.opencode/agents/*.md`     | `/pipe <task>`, `/inspect <task>`, `/epic <task>` |
 | Kimi        | `.kimi/commands/<entrypoint>.md`, `.kimi/agents/*.yaml`           | `/pipe <task>`, `/inspect <task>`, `/epic <task>` |

package/dist/config.d.ts

@@ -101,6 +101,15 @@ declare const workflowNodeBaseSchema: z.ZodObject<{
       timeout: "timeout";
     }>>>;
   }, z.core.$strict>>;
+  task_context: z.ZodOptional<z.ZodObject<{
+    acceptance_criteria: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      text: z.ZodString;
+    }, z.core.$strict>>>;
+    description: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
   timeout_ms: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type WorkflowNodeBase = z.infer<typeof workflowNodeBaseSchema>;
@@ -222,10 +231,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>;
@@ -265,10 +274,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>;

package/dist/config.js

@@ -259,6 +259,15 @@ const hookSchema = z.object({
 	trusted: z.boolean().optional()
 }).strict();
 const taskContextResolverSchema = z.object({ type: z.string().min(1) }).passthrough();
+const nodeTaskContextSchema = z.object({
+	acceptance_criteria: z.array(z.object({
+		id: z.string().min(1),
+		text: z.string().min(1)
+	}).strict()).optional(),
+	description: z.string().optional(),
+	id: z.string().min(1).optional(),
+	title: z.string().optional()
+}).strict();
 const entrypointBaseSchema = z.object({
 	description: z.string().optional(),
 	task_context: taskContextResolverSchema.optional()
@@ -277,6 +286,7 @@ const workflowNodeBaseSchema = z.object({
 	id: z.string(),
 	needs: z.array(z.string()).optional(),
 	retries: retriesSchema.optional(),
+	task_context: nodeTaskContextSchema.optional(),
 	timeout_ms: z.number().int().positive().optional()
 });
 const workflowNodeSchema = z.lazy(() => z.discriminatedUnion("kind", [

package/dist/install-commands.js

@@ -3,7 +3,7 @@ import { loadPipelineConfig } from "./config.js";
 import { codexNativeMcpConfig } from "./mcp/native-config.js";
 import { compileWorkflowPlan } from "./workflow-planner.js";
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, join, relative } from "node:path";
+import { basename, dirname, join, relative } from "node:path";
 import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
 import matter from "gray-matter";
 import { stringify } from "smol-toml";
@@ -17,6 +17,8 @@ const OWNER_YAML_MARKER_PREFIX = "# @oisincoveney/pipeline:";
 const CODEX_PLUGIN_COMMAND_ROOT = ".agents/plugins/oisin-pipeline/commands";
 const CODEX_AGENT_CONFIG_START = "# @oisincoveney/pipeline:codex-agents:start";
 const CODEX_AGENT_CONFIG_END = "# @oisincoveney/pipeline:codex-agents:end";
+const CODEX_AGENTS_MD_START = "<!-- @oisincoveney/pipeline:agents:start -->";
+const CODEX_AGENTS_MD_END = "<!-- @oisincoveney/pipeline:agents:end -->";
 const ENTRYPOINT_PATH_PATTERNS = {
 	codex: [/^\.agents\/skills\/([^/]+)\/SKILL\.md$/, /^\.agents\/plugins\/oisin-pipeline\/commands\/([^/]+)\.md$/],
 	opencode: [/^\.opencode\/commands\/([^/]+)\.md$/]
@@ -261,7 +263,7 @@ function opencodePermission(actor, options = {}) {
 		write: allowed.has("write") ? "allow" : "deny"
 	};
 }
-function opencodeDefinitions(config) {
+function opencodeDefinitions(config, cwd) {
 	return [
 		...entrypointCommandDefinitions("opencode", config, (id, entrypoint) => ({
 			content: markdown({
@@ -315,7 +317,8 @@ function opencodeDefinitions(config) {
 			host: "opencode",
 			invocation: invocationForHost("opencode"),
 			path: `.opencode/agents/${id}.md`
-		}))
+		})),
+		projectAgentsMdDefinition(cwd, "opencode")
 	];
 }
 function codexDefinitions(config, cwd) {
@@ -357,10 +360,49 @@ function codexDefinitions(config, cwd) {
 			invocation: codexPluginInvocation(id),
 			path: `${CODEX_PLUGIN_COMMAND_ROOT}/${id}.md`
 		})),
+		projectAgentsMdDefinition(cwd, "codex"),
 		...nativeCodexProfiles.map(([id, profile]) => codexTomlAgentDefinition(config, cwd, id, profile)),
 		codexProjectConfigAgentDefinition()
 	];
 }
+function projectAgentsMdDefinition(cwd, host) {
+	const repoName = basename(cwd);
+	return {
+		block: {
+			end: CODEX_AGENTS_MD_END,
+			start: CODEX_AGENTS_MD_START
+		},
+		content: [
+			CODEX_AGENTS_MD_START,
+			GENERATED_MARKER,
+			`${OWNER_MARKER_PREFIX}host=codex -->`,
+			`${OWNER_MARKER_PREFIX}host=opencode -->`,
+			"",
+			"## Pipeline Guidance",
+			"",
+			"This repository is configured with `@oisincoveney/pipeline`.",
+			"",
+			"- Use `$pipe`, `$inspect`, or `$epic` for Codex skill entrypoints when the user asks for pipeline workflows.",
+			"- Use `/pipe`, `/inspect`, or `/epic` for Codex or OpenCode slash-command entrypoints when available.",
+			"- Load and follow the relevant skill from `.agents/skills` before doing specialized work.",
+			"- Prefer the generated pipeline profiles and command surfaces over ad hoc subagent prompts.",
+			"",
+			"## Pipeline Memory",
+			"",
+			`Use Qdrant collection \`${repoName}\` for this repository.`,
+			"",
+			`- Call \`qdrant-find\` before research with \`collection_name: ${repoName}\` unless the user explicitly disables memory.`,
+			`- Call \`qdrant-store\` during LEARN with \`collection_name: ${repoName}\` for durable lessons worth reusing.`,
+			"- Include metadata with at least `repo`, `phase`, `workflow` or `entrypoint`, `task`, and `outcome` when storing lessons.",
+			"",
+			CODEX_AGENTS_MD_END,
+			""
+		].join("\n"),
+		host,
+		invocation: invocationForHost(host),
+		path: "AGENTS.md"
+	};
+}
 function codexTomlAgentDefinition(config, cwd, id, profile) {
 	const profileWithResolvedModel = {
 		...profile,
@@ -462,9 +504,16 @@ function instructionsPointer(actor) {
 function definitionsFor(host, config, cwd) {
 	const definitions = {
 		codex: () => codexDefinitions(config, cwd),
-		opencode: () => opencodeDefinitions(config)
+		opencode: () => opencodeDefinitions(config, cwd)
 	};
-	return (host === "all" ? COMMAND_HOSTS : [host]).flatMap((name) => definitions[name]());
+	return dedupeDefinitionsByPath((host === "all" ? COMMAND_HOSTS : [host]).flatMap((name) => definitions[name]()));
+}
+function dedupeDefinitionsByPath(definitions) {
+	const lastIndexes = /* @__PURE__ */ new Map();
+	definitions.forEach((definition, index) => {
+		lastIndexes.set(definition.path, index);
+	});
+	return definitions.filter((definition, index) => lastIndexes.get(definition.path) === index);
 }
 function selectedHosts(host) {
 	return host === "all" ? [...COMMAND_HOSTS] : [host];

package/dist/pipeline-init.js

@@ -313,6 +313,8 @@ rules:
     path: .pipeline/rules/verification.md
 
 skills:
+  schedule-graph-shaping:
+    path: .pipeline/skills/schedule-graph-shaping/SKILL.md
   critique:
     path: .agents/skills/critique/SKILL.md
   diagnose:
@@ -423,7 +425,7 @@ profiles:
     description: Refine a baseline schedule into a specialized approved-plan artifact.
     instructions:
       path: .pipeline/prompts/schedule-planner.md
-    skills: [research, scope]
+    skills: [schedule-graph-shaping]
     mcp_servers: [serena, context7, backlog, qdrant, github-readonly]
     tools: [read, list, grep, glob, bash]
     filesystem:
@@ -636,6 +638,62 @@ const SCAFFOLD_FILES = {
 	[PIPELINE_CONFIG_PATH]: DEFAULT_PIPELINE_YAML,
 	[PROFILES_CONFIG_PATH]: DEFAULT_PROFILES_YAML,
 	[RUNNERS_CONFIG_PATH]: DEFAULT_RUNNERS_YAML,
+	".pipeline/skills/schedule-graph-shaping/SKILL.md": [
+		"---",
+		"name: schedule-graph-shaping",
+		"description: Use when generating or reviewing pipeline schedule graphs for a task or epic. Shapes explicit root DAGs by grouping related tickets and verification work by goal, dependency, and evidence instead of defaulting to one full RED/GREEN/VERIFY chain per ticket.",
+		"---",
+		"",
+		"# Schedule Graph Shaping",
+		"",
+		"Use this when producing a `pipeline-schedule` YAML artifact.",
+		"",
+		"## Contract",
+		"",
+		"- Return only the artifact requested by the schedule planner. Do not add prose.",
+		"- Generate exactly one workflow named `root`.",
+		"- Do not use `kind: workflow` or embed configured workflow copies such as `default`, `infra`, `track`, or `epic-drain`.",
+		"- Every generated agent node must declare a configured `profile`.",
+		"- Node IDs must be stable lowercase kebab-case and match `^[a-z][a-z0-9-]*$`.",
+		"- Do not invent profiles, node-level skills, or unconfigured gates.",
+		"",
+		"## Shaping Procedure",
+		"",
+		"1. Cluster work units by intent before drawing nodes.",
+		"   Group tickets that validate the same behavior, touch the same subsystem, share acceptance evidence, or must land in a fixed order.",
+		"",
+		"2. Use RED nodes for test strategy, not ticket counting.",
+		"   One RED node can cover several GREEN tickets when they share the same failing test suite or behavior contract. Split RED nodes only when the tests are meaningfully independent or different profiles are needed.",
+		"",
+		"3. Use GREEN nodes for independently implementable slices.",
+		"   A GREEN node may cover one ticket or a coherent group of tickets. Split GREEN nodes when the work can run in parallel, has different dependencies, has materially different ownership/risk, or would make one node too broad to review.",
+		"",
+		"4. Use acceptance nodes for user-visible outcomes.",
+		"   One acceptance node can cover multiple implementation nodes when they produce the same visible outcome or acceptance checklist.",
+		"",
+		"5. Use verifier nodes for shared evidence.",
+		"   One verifier can validate multiple tickets when the same real repository commands and checks prove them. Split verifiers only when evidence differs, one area needs specialized inspection, or a dependency boundary requires earlier proof.",
+		"",
+		"6. Preserve necessary serial order.",
+		"   Dependencies from the backlog, shared migrations/schema changes, public API changes, and foundational refactors should gate downstream implementation. Independent clusters should fan out and then fan in to shared acceptance, verifier, merge, or review nodes.",
+		"",
+		"## Task Context",
+		"",
+		"- Assign every backlog work unit to at least one explicit generated agent node with `task_context.id`.",
+		"- Prefer assigning ticket-specific context to GREEN nodes.",
+		"- RED, acceptance, and verifier nodes may omit `task_context` when they cover a group; include it only when the node is genuinely ticket-specific.",
+		"",
+		"## Efficiency Checks",
+		"",
+		"Before returning the graph, ask:",
+		"",
+		"- Did I create a RED/GREEN/VERIFY chain just because a ticket exists?",
+		"- Can several GREEN nodes share one RED node without losing test-first behavior?",
+		"- Can several GREEN nodes share one verifier because the same commands prove them?",
+		"- Are independent implementation slices parallelized?",
+		"- Are serial edges based on real dependencies rather than habit?",
+		""
+	].join("\n"),
 	".pipeline/prompts/orchestrator.md": [
 		"You are the orchestrator for the pipeline.",
 		"Use `.pipeline/pipeline.yaml` as the source of truth for workflow order, profiles, gates, hooks, and artifacts.",
@@ -646,6 +704,9 @@ const SCAFFOLD_FILES = {
 	].join("\n"),
 	".pipeline/prompts/researcher.md": [
 		"You are the research phase for the pipeline.",
+		"Call `qdrant-find` before local inspection when the qdrant MCP server is available.",
+		"Use collection_name equal to the repository directory basename, and skip this only when the user explicitly disables memory.",
+		"Surface relevant prior lessons briefly before continuing.",
 		"Inspect first-party source, tests, docs, and task context before proposing changes.",
 		"Write structured findings that identify relevant files, existing patterns, acceptance criteria, and risks.",
 		"Return only valid JSON matching `.pipeline/schemas/research.schema.json`: an object with `findings` and `ac` arrays, plus optional `files`, `risks`, and `target`.",
@@ -665,13 +726,20 @@ const SCAFFOLD_FILES = {
 	".pipeline/prompts/schedule-planner.md": [
 		"# Schedule planner",
 		"",
-		"Refine the provided baseline into a specialized `pipeline-schedule` YAML artifact for the user task.",
+		"Generate a constrained agent graph as a specialized `pipeline-schedule` YAML artifact for the user task.",
+		"",
+		"Keep the graph auditable: execution must include research, implementation, and verification.",
+		"",
+		"Generate exactly one workflow named `root`. Do not embed `default`, `epic-drain`, `infra`, `track`, or other configured workflow copies. Use explicit generated agent, builtin, command, parallel, or group nodes. Do not use `kind: workflow`.",
+		"",
+		"Use the provided backlog work units as the source of truth when present. Assign each work unit to explicit generated agent nodes with only its `task_context.id`, use only allowed configured profiles, and ensure implementation work has downstream acceptance, verification, or review coverage. Do not invent profiles or node-level skill overrides.",
+		"Do not copy backlog descriptions or acceptance criteria into output; the scheduler hydrates them from the assigned `task_context.id` after parsing.",
 		"",
-		"Keep the graph auditable: every workflow must be embedded in the artifact, every `kind: workflow` reference must point to an embedded workflow, and execution must include research, implementation, and verification.",
+		"Shape the graph by intent, not by ticket count. Do not create a full RED/GREEN/ACCEPTANCE/VERIFY chain for each backlog ticket unless each step needs ticket-specific evidence. Use one RED node for a group of tickets when they share a test strategy, fan out to parallel GREEN implementation nodes where the work can be implemented independently, and fan back in to shared acceptance or verifier nodes when the same acceptance checklist or real repository commands prove the group. Only serialize ticket nodes when the backlog, a shared migration/schema/API dependency, or implementation risk requires it.",
 		"",
-		"Use parallel branches only when they reduce coordination risk. Preserve configured profile ids, gates, hooks, retries, artifacts, and worktree policy unless the task clearly needs a different valid graph.",
+		"Return exactly one YAML document and nothing else. Do not wrap it in Markdown fences. Do not include commentary, plans, task lists, or explanations. Do not modify files. Do not invoke other agents.",
 		"",
-		"Return only YAML. Do not wrap it in Markdown fences. Do not modify files. Do not invoke other agents.",
+		"Use block-style YAML for objects and arrays. Do not use compact inline mappings like `{ id: PIPE-41.1, title: ... }`. Quote scalar strings that contain punctuation such as `:`, `#`, `[`, `]`, `{`, or `}`.",
 		""
 	].join("\n"),
 	".pipeline/prompts/test-writer.md": [
@@ -744,6 +812,8 @@ const SCAFFOLD_FILES = {
 	".pipeline/prompts/learner.md": [
 		"You are the LEARN phase for the pipeline.",
 		"Store durable lessons from the run when useful and report qdrant-store evidence.",
+		"Call `qdrant-store` with collection_name equal to the repository directory basename.",
+		"Include metadata with at least repo, phase, workflow or entrypoint, task, and outcome.",
 		"Do not write local markdown knowledge as the durable sink.",
 		"Return only valid JSON matching `.pipeline/schemas/learn.schema.json`: an object with `qdrant` and `evidence`.",
 		"Do not wrap the JSON in Markdown fences or add prose outside the JSON object.",

package/dist/pipeline-runtime.js

@@ -870,7 +870,7 @@ async function executeWorkflowNode(node, context) {
 		runId: context.runId,
 		signal: context.signal,
 		task: context.task,
-		taskContext: context.taskContext,
+		taskContext: effectiveTaskContext(node, context),
 		workflowId: node.workflow,
 		worktreePath: worktree.worktreePath ?? context.worktreePath
 	});
@@ -1155,7 +1155,7 @@ function renderAgentPrompt(node, context) {
 		`Workflow: ${context.workflowId}`,
 		`Node: ${node.id}`,
 		node.profile ? `Profile: ${node.profile}` : "",
-		renderTaskContext(context.taskContext),
+		renderTaskContext(effectiveTaskContext(node, context)),
 		"",
 		"Declared grants:",
 		`- tools: ${(profile?.tools ?? []).join(", ") || "none"}`,
@@ -1171,6 +1171,9 @@ function renderAgentPrompt(node, context) {
 		...node.needs.map((need) => `## ${need}\n${context.lastOutputByNode.get(need) ?? ""}`)
 	].filter(Boolean).join("\n");
 }
+function effectiveTaskContext(node, context) {
+	return node.taskContext ?? context.taskContext;
+}
 function inheritedOutputSections(node, context) {
 	const ownNeeds = new Set(node.needs);
 	const inherited = [...context.inheritedOutputNodeIds].filter((id) => !ownNeeds.has(id) && context.lastOutputByNode.has(id));
@@ -1692,12 +1695,13 @@ function emitAgentFinish(context, plan, attempt, result) {
 }
 function evaluateGate(gate, nodeId, context, attempt) {
 	const gateId = gate.id ?? `${gate.kind}:${nodeId}`;
+	const node = context.plan.graph.node(nodeId);
 	switch (gate.kind) {
 		case "command": return evaluateCommandGate(gate, gateId, nodeId, context);
 		case "artifact": return evaluateArtifactGate(gate, gateId, nodeId, context);
 		case "builtin": return evaluateBuiltinGate(gate, gateId, nodeId, context);
 		case "verdict": return evaluateVerdictGate(gate, gateId, nodeId, context, attempt);
-		case "acceptance": return evaluateAcceptanceGate(gate, gateId, nodeId, context, attempt);
+		case "acceptance": return evaluateAcceptanceGate(gate, gateId, nodeId, context, attempt, node);
 		case "changed_files": return evaluateChangedFilesGate(gate, gateId, nodeId, context);
 		case "json_schema": return evaluateJsonSchemaGate(gate, gateId, nodeId, context, attempt);
 		default: return assertNever(gate);
@@ -1781,8 +1785,8 @@ function evaluateVerdictGate(gate, gateId, nodeId, context, attempt) {
 		reason: passed ? void 0 : "verdict requirement failed"
 	};
 }
-function evaluateAcceptanceGate(gate, gateId, nodeId, context, attempt) {
-	const expected = context.taskContext?.acceptanceCriteria ?? [];
+function evaluateAcceptanceGate(gate, gateId, nodeId, context, attempt, node) {
+	const expected = (node ? effectiveTaskContext(node, context) : context.taskContext)?.acceptanceCriteria ?? [];
 	if (expected.length === 0) return {
 		evidence: ["no acceptance criteria in task context"],
 		gateId,
@@ -2076,7 +2080,7 @@ function hookPayload(context, failure, node, gateId) {
 		},
 		failure,
 		task: context.task,
-		taskContext: context.taskContext
+		taskContext: node ? effectiveTaskContext(node, context) : context.taskContext
 	};
 }
 function renderTemplate(value, context, failure, node, gateId) {