@oisincoveney/pipeline 3.6.1 → 3.7.1

package/defaults/instructions/global.md

@@ -0,0 +1,68 @@
+# Caveman Mode (default ON)
+
+Operate in caveman mode by default on every response: terse, smart-caveman phrasing — drop filler, keep ALL technical substance, code, commands, paths, and accuracy. This is active every response and does not drift off over a long session. Defer to the `caveman` skill for the exact compression rules and intensity levels. Turn off only when the user says "stop caveman" or "normal mode".
+
+# Global Behavior
+
+- Answer fully and stop. Never end with "Want me to do X?" or "Should I implement this?" — if the user wants more, they'll ask.
+- Research before acting — know how components and libraries work before making changes.
+- When uncertain, ask — don't guess.
+- The answer to "Why is X an improvement?" should never be "I'm not sure."
+
+## Before writing code
+
+- Search for existing implementations before creating new code.
+- Check for existing utilities before adding helpers.
+- Don't add dependencies without checking if functionality already exists in current deps.
+- Reuse patterns from similar files in the codebase.
+
+## Problem-solving
+
+- Is this a real problem? Reject over-engineering.
+- Is there a simpler way? Always seek the simplest solution.
+- Will it break anything? Backward compatibility matters.
+
+# Anti-Patterns
+
+## Code quality
+
+- NEVER manually edit auto-generated files — regenerate them instead.
+- NEVER suppress type errors (`as any`, `@ts-ignore`, `@ts-expect-error`).
+- NEVER use bandaids or hacks — proper fixes only.
+- NEVER create new Zod schemas when generated ones exist.
+- NEVER use `var` declarations.
+- NEVER add `.unwrap()` calls in Rust code.
+
+## Error handling
+
+- Silent error handling is NEVER permitted.
+- Every fallback and default value MUST have specific business-logic reasoning.
+- Unexpected errors MUST be logged, not swallowed.
+- Errors affecting user flow MUST surface to the user — never hide failures.
+
+## Testing
+
+- NEVER commit code without tests for new functionality.
+- NEVER skip tests or mark them skipped to make CI pass.
+- NEVER disable or delete existing tests — fix the code, not the tests.
+- Test both success and error cases.
+
+# Verification
+
+- Run tests, lint, and typecheck after every change.
+- Self-assessment is unreliable — use external signals (build output, test results) as ground truth.
+- Don't claim something works without running it.
+- If a test suite exists, run it. Don't skip it because "the change is small."
+
+# Coding Style
+
+- 120 char line width.
+- Trailing commas everywhere.
+
+## Git
+
+- NEVER commit/push directly to main.
+- NEVER amend commits or rewrite history after pushing.
+- NEVER use `--force` without explicit approval.
+- Always create new commits — never amend, squash, or rebase unless explicitly asked.
+- Conventional commit format: `feat|fix|chore|docs|test|refactor(scope): description`.

package/dist/config/schemas.d.ts

@@ -226,8 +226,8 @@ declare const configSchema: z.ZodObject<{
     policy: z.ZodOptional<z.ZodObject<{
       commands: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
-        deny: "deny";
         "trusted-only": "trusted-only";
+        deny: "deny";
       }>>;
       modules: z.ZodOptional<z.ZodEnum<{
         allow: "allow";
@@ -255,8 +255,8 @@ declare const configSchema: z.ZodObject<{
       global: "global";
     }>>;
     mode: z.ZodEnum<{
-      local: "local";
       hosted: "hosted";
+      local: "local";
     }>;
     provider: z.ZodLiteral<"toolhive">;
     authorization_env: z.ZodDefault<z.ZodString>;
@@ -299,10 +299,10 @@ declare const configSchema: z.ZodObject<{
     }, z.core.$strict>>;
     output: z.ZodOptional<z.ZodObject<{
       format: z.ZodEnum<{
-        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
+        json_schema: "json_schema";
       }>;
       repair: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
@@ -371,10 +371,10 @@ declare const configSchema: z.ZodObject<{
         disabled: "disabled";
       }>>>;
       output_formats: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        json_schema: "json_schema";
         text: "text";
         json: "json";
         jsonl: "jsonl";
+        json_schema: "json_schema";
       }>>>;
       rules: z.ZodOptional<z.ZodBoolean>;
       skills: z.ZodOptional<z.ZodBoolean>;
@@ -481,8 +481,8 @@ declare const configSchema: z.ZodObject<{
   schedules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     baseline: z.ZodEnum<{
-      quick: "quick";
       execute: "execute";
+      quick: "quick";
     }>;
     max_parallel_nodes: z.ZodOptional<z.ZodNumber>;
     node_catalog: z.ZodOptional<z.ZodString>;

package/dist/install-commands/instructions.js

@@ -0,0 +1,62 @@
+import { resolvePackageAssetPath } from "../package-assets.js";
+import { GENERATED_MARKER, INSTRUCTIONS_END, INSTRUCTIONS_START, OWNER_MARKER_PREFIX } from "./shared.js";
+import { readFileSync } from "node:fs";
+//#region src/install-commands/instructions.ts
+/**
+* The canonical global agent instruction body, package-owned so every machine,
+* k8s job, and host renders the same behavior. Shipped in `defaults/` (see
+* package.json `files`).
+*/
+const INSTRUCTION_BODY = readFileSync(resolvePackageAssetPath("defaults/instructions/global.md"), "utf8").trimEnd();
+/**
+* The global instruction memory file each host reads, and the repo-relative
+* path that `resolveHarnessTarget` rebases onto its per-machine config dir.
+* Distinct from the bare `AGENTS.md` project guidance file, so these coexist
+* with (and never trip) the PROJECT_ONLY AGENTS.md handling.
+*/
+const INSTRUCTION_TARGETS = [
+	{
+		host: "claude-code",
+		path: ".claude/CLAUDE.md"
+	},
+	{
+		host: "codex",
+		path: ".codex/AGENTS.md"
+	},
+	{
+		host: "gemini",
+		path: ".gemini/GEMINI.md"
+	}
+];
+/** Repo-relative paths of every generated instruction file (global scope). */
+const INSTRUCTION_PATHS = INSTRUCTION_TARGETS.map((target) => target.path);
+function instructionContent(host) {
+	return `${[
+		INSTRUCTIONS_START,
+		GENERATED_MARKER,
+		`${OWNER_MARKER_PREFIX}host=${host} -->`,
+		"",
+		INSTRUCTION_BODY,
+		"",
+		INSTRUCTIONS_END
+	].join("\n")}\n`;
+}
+/**
+* Per-host global instruction definitions. Each is upserted as a marker block
+* so any user-authored content outside the markers in the target file is
+* preserved. Emitted in global scope only (see GLOBAL_ONLY_PATHS).
+*/
+function globalInstructionDefinitions() {
+	return INSTRUCTION_TARGETS.map(({ host, path }) => ({
+		block: {
+			end: INSTRUCTIONS_END,
+			start: INSTRUCTIONS_START
+		},
+		content: instructionContent(host),
+		host,
+		invocation: "(global instructions)",
+		path
+	}));
+}
+//#endregion
+export { INSTRUCTION_PATHS, globalInstructionDefinitions };

package/dist/install-commands/shared.js

@@ -9,6 +9,8 @@ const OWNER_TS_MARKER_PREFIX = "// @oisincoveney/pipeline:";
 const OWNER_YAML_MARKER_PREFIX = "# @oisincoveney/pipeline:";
 const AGENTS_MD_START = "<!-- @oisincoveney/pipeline:agents:start -->";
 const AGENTS_MD_END = "<!-- @oisincoveney/pipeline:agents:end -->";
+const INSTRUCTIONS_START = "<!-- @oisincoveney/pipeline:instructions:start -->";
+const INSTRUCTIONS_END = "<!-- @oisincoveney/pipeline:instructions:end -->";
 const SINGLE_OPENCODE_PLUGIN_ARRAY_RE = /\n {2}"plugin": \[\n {4}("[^"]+")\n {2}\]/;
 const OPENCODE_PROJECT_CONFIG_PATH = ".opencode/opencode.json";
 const CLAUDE_PROJECT_CONFIG_PATH = ".claude/settings.json";
@@ -34,6 +36,9 @@ function codexGlobalConfigDir() {
 function opencodeGlobalConfigDir() {
 	return process.env.OPENCODE_CONFIG_DIR ?? join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "opencode");
 }
+function geminiGlobalConfigDir() {
+	return process.env.GEMINI_CONFIG_DIR ?? join(homedir(), ".gemini");
+}
 function stripPrefix(value, prefix) {
 	if (value === prefix) return "";
 	return value.startsWith(`${prefix}/`) ? value.slice(prefix.length + 1) : value;
@@ -55,6 +60,7 @@ function resolveHarnessTarget(scope, cwd, relPath) {
 	const normalized = relPath.replaceAll("\\", "/");
 	if (normalized === ".claude" || normalized.startsWith(".claude/")) return join(claudeGlobalConfigDir(), stripPrefix(normalized, ".claude"));
 	if (normalized === ".codex" || normalized.startsWith(".codex/")) return join(codexGlobalConfigDir(), stripPrefix(normalized, ".codex"));
+	if (normalized === ".gemini" || normalized.startsWith(".gemini/")) return join(geminiGlobalConfigDir(), stripPrefix(normalized, ".gemini"));
 	return join(opencodeGlobalConfigDir(), stripPrefix(normalized, ".opencode"));
 }
 function profileEntries(config) {
@@ -88,4 +94,4 @@ function commandIdForHost(host, entrypointId) {
 	return entrypointId;
 }
 //#endregion
-export { AGENTS_MD_END, AGENTS_MD_START, CLAUDE_PROJECT_CONFIG_PATH, COMMAND_HOSTS, DEFAULT_HARNESS_SCOPE, ENTRYPOINT_PATH_PATTERNS, GENERATED_MARKER, GENERATED_TS_MARKER, GENERATED_YAML_MARKER, OPENCODE_PROJECT_CONFIG_PATH, OWNER_MARKER_PREFIX, OWNER_TS_MARKER_PREFIX, OWNER_YAML_MARKER_PREFIX, SINGLE_OPENCODE_PLUGIN_ARRAY_RE, commandIdForHost, compactLines, entrypointDescription, entrypointEntries, instructionsPointer, invocationForHost, profileEntries, resolveHarnessTarget };
+export { AGENTS_MD_END, AGENTS_MD_START, CLAUDE_PROJECT_CONFIG_PATH, COMMAND_HOSTS, DEFAULT_HARNESS_SCOPE, ENTRYPOINT_PATH_PATTERNS, GENERATED_MARKER, GENERATED_TS_MARKER, GENERATED_YAML_MARKER, INSTRUCTIONS_END, INSTRUCTIONS_START, OPENCODE_PROJECT_CONFIG_PATH, OWNER_MARKER_PREFIX, OWNER_TS_MARKER_PREFIX, OWNER_YAML_MARKER_PREFIX, SINGLE_OPENCODE_PLUGIN_ARRAY_RE, commandIdForHost, compactLines, entrypointDescription, entrypointEntries, instructionsPointer, invocationForHost, profileEntries, resolveHarnessTarget };

package/dist/install-commands.js

@@ -3,6 +3,7 @@ import "./config.js";
 import { COMMAND_HOSTS, ENTRYPOINT_PATH_PATTERNS, invocationForHost, resolveHarnessTarget } from "./install-commands/shared.js";
 import { opencodeAdapter } from "./install-commands/opencode.js";
 import { claudeCodeAdapter } from "./install-commands/claude-code.js";
+import { INSTRUCTION_PATHS, globalInstructionDefinitions } from "./install-commands/instructions.js";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
@@ -75,7 +76,7 @@ function entrypointIdFromGeneratedPath(host, path) {
 }
 function resolveDefinitionContent(definition, target) {
 	const adapter = ADAPTERS[definition.host];
-	if (!(adapter.mergeDefinition && existsSync(target))) return {
+	if (!(adapter?.mergeDefinition && existsSync(target))) return {
 		conflict: false,
 		content: definition.content
 	};
@@ -120,7 +121,7 @@ function upsertGeneratedBlock(current, content, block) {
 	return `${current.trimEnd()}${separator}${content}`;
 }
 function adapterForcesDefinition(definition) {
-	const fn = ADAPTERS[definition.host].isAlwaysForced;
+	const fn = ADAPTERS[definition.host]?.isAlwaysForced;
 	return fn ? fn(definition) : false;
 }
 function installActionForDefinition(definition, target, resolved, force) {
@@ -155,15 +156,18 @@ function commandInstallPlanItem(definition, action) {
 	};
 }
 const PROJECT_ONLY_PATHS = new Set(["AGENTS.md"]);
+const GLOBAL_ONLY_PATHS = new Set(INSTRUCTION_PATHS);
 function scopedDefinitions(definitions, scope) {
-	if (scope !== "global") return definitions;
-	return definitions.filter((definition) => !PROJECT_ONLY_PATHS.has(definition.path));
+	if (scope === "global") return definitions.filter((definition) => !PROJECT_ONLY_PATHS.has(definition.path));
+	return definitions.filter((definition) => !GLOBAL_ONLY_PATHS.has(definition.path));
 }
 function installCommandsContext(options) {
 	const cwd = options.cwd ?? process.cwd();
 	const host = options.host ?? "all";
 	const scope = options.scope ?? "global";
-	const definitions = scopedDefinitions(definitionsFor(host, loadPipelineConfig(cwd, { allowMissingLintFileReferences: true }), cwd), scope);
+	const config = loadPipelineConfig(cwd, { allowMissingLintFileReferences: true });
+	const instructionDefinitions = globalInstructionDefinitions().filter((definition) => host === "all" || definition.host === host);
+	const definitions = scopedDefinitions([...definitionsFor(host, config, cwd), ...instructionDefinitions], scope);
 	return {
 		cwd,
 		definitions,

package/dist/moka-submit.d.ts

@@ -160,8 +160,8 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   serviceAccountName: z.ZodOptional<z.ZodString>;
   mode: z.ZodEnum<{
-    full: "full";
     quick: "quick";
+    full: "full";
   }>;
   schedulePath: z.ZodOptional<z.ZodString>;
   scheduleYaml: z.ZodOptional<z.ZodString>;

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

@@ -43,8 +43,8 @@ declare const runnerDeliverySchema: z.ZodObject<{
 declare const mokaSubmissionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"graph">;
   mode: z.ZodEnum<{
-    full: "full";
     quick: "quick";
+    full: "full";
   }>;
 }, z.core.$strict>, z.ZodObject<{
   argv: z.ZodArray<z.ZodString>;
@@ -104,8 +104,8 @@ declare const runnerCommandPayloadSchema: z.ZodObject<{
   submission: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"graph">;
     mode: z.ZodEnum<{
-      full: "full";
       quick: "quick";
+      full: "full";
     }>;
   }, z.core.$strict>, z.ZodObject<{
     argv: z.ZodArray<z.ZodString>;
@@ -261,6 +261,7 @@ interface RunnerHookResultDetails {
 }
 interface RunnerEventEnvelope {
   at?: string;
+  runId: string;
   sequence: number;
   type: string;
 }

package/dist/runner-command-contract.js

@@ -143,6 +143,7 @@ function parseRunnerCommandPayloadWithIssues(rawPayload) {
 function mapRuntimeEventToRunnerEventRecords(event, context) {
 	const record = {
 		at: context.timestamp,
+		runId: context.runId,
 		sequence: context.sequence ?? 1
 	};
 	return mapWorkflowRunnerEvent(event, context, record) ?? mapNodeRunnerEvent(event, record) ?? mapGateRunnerEvent(event, record) ?? mapArtifactRunnerEvent(event, record) ?? mapLogRunnerEvent(event, record) ?? throwUnhandledRuntimeEvent(event);
@@ -164,6 +165,7 @@ function mapWorkflowRunnerEvent(event, context, record) {
 				source: edge.source,
 				target: edge.target
 			},
+			runId: context.runId,
 			sequence: (context.sequence ?? 1) + index + 1,
 			type: "workflow.edge"
 		}))];
@@ -188,6 +190,7 @@ function mapWorkflowRunnerEvent(event, context, record) {
 }
 function mapNodeRunnerEvent(event, record) {
 	switch (event.type) {
+		case "node.session": return [];
 		case "node.start": return [{
 			...record,
 			type: event.type,

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

@@ -8,6 +8,7 @@ import { z } from "zod";
  */
 declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
+  runId: z.ZodString;
   sequence: z.ZodNumber;
   type: z.ZodEnum<{
     "workflow.planned": "workflow.planned";
@@ -30,6 +31,7 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
+  runId: z.ZodString;
   sequence: z.ZodNumber;
   edge: z.ZodObject<{
     id: z.ZodString;
@@ -39,6 +41,7 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   type: z.ZodLiteral<"workflow.edge">;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
+  runId: z.ZodString;
   sequence: z.ZodNumber;
   node: z.ZodObject<{
     attempt: z.ZodNumber;
@@ -62,6 +65,7 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   }>;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
+  runId: z.ZodString;
   sequence: z.ZodNumber;
   gate: z.ZodObject<{
     event: z.ZodOptional<z.ZodString>;
@@ -89,6 +93,7 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   }>;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
+  runId: z.ZodString;
   sequence: z.ZodNumber;
   hookResult: z.ZodObject<{
     artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -113,6 +118,7 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   type: z.ZodLiteral<"hook.result">;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
+  runId: z.ZodString;
   sequence: z.ZodNumber;
   artifact: z.ZodObject<{
     kind: z.ZodLiteral<"artifact">;
@@ -135,6 +141,7 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   }>;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
+  runId: z.ZodString;
   sequence: z.ZodNumber;
   log: z.ZodObject<{
     attempt: z.ZodOptional<z.ZodNumber>;
@@ -160,6 +167,7 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   }>;
 }, z.core.$strip>, z.ZodObject<{
   at: z.ZodOptional<z.ZodString>;
+  runId: z.ZodString;
   sequence: z.ZodNumber;
   finalResult: z.ZodObject<{
     outcome: z.ZodEnum<{
@@ -178,6 +186,7 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
 declare const runnerEventBatchSchema: z.ZodObject<{
   events: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
     sequence: z.ZodNumber;
     type: z.ZodEnum<{
       "workflow.planned": "workflow.planned";
@@ -200,6 +209,7 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     }, z.core.$strip>;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
     sequence: z.ZodNumber;
     edge: z.ZodObject<{
       id: z.ZodString;
@@ -209,6 +219,7 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     type: z.ZodLiteral<"workflow.edge">;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
     sequence: z.ZodNumber;
     node: z.ZodObject<{
       attempt: z.ZodNumber;
@@ -232,6 +243,7 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     }>;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
     sequence: z.ZodNumber;
     gate: z.ZodObject<{
       event: z.ZodOptional<z.ZodString>;
@@ -259,6 +271,7 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     }>;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
     sequence: z.ZodNumber;
     hookResult: z.ZodObject<{
       artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -283,6 +296,7 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     type: z.ZodLiteral<"hook.result">;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
     sequence: z.ZodNumber;
     artifact: z.ZodObject<{
       kind: z.ZodLiteral<"artifact">;
@@ -305,6 +319,7 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     }>;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
     sequence: z.ZodNumber;
     log: z.ZodObject<{
       attempt: z.ZodOptional<z.ZodNumber>;
@@ -330,6 +345,7 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     }>;
   }, z.core.$strip>, z.ZodObject<{
     at: z.ZodOptional<z.ZodString>;
+    runId: z.ZodString;
     sequence: z.ZodNumber;
     finalResult: z.ZodObject<{
       outcome: z.ZodEnum<{

package/dist/runner-event-schema.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 //#region src/runner-event-schema.ts
 const runnerEventEnvelopeSchema = z.object({
 	at: z.string().optional(),
+	runId: z.string().min(1),
 	sequence: z.number().int().positive()
 });
 const runnerWorkflowNodeDetailsSchema = z.object({

package/dist/runner-event-sink.js

@@ -18,6 +18,7 @@ function createRunnerEventSink(options) {
 		nextSequence += 1;
 		return {
 			at: timestamp(options.now),
+			runId: options.runId,
 			sequence
 		};
 	};

package/package.json

@@ -126,7 +126,7 @@
     "prepack": "bun run build:cli"
   },
   "type": "module",
-  "version": "3.6.1",
+  "version": "3.7.1",
   "description": "Config-driven multi-agent pipeline runner for repository work",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",