@oisincoveney/pipeline 3.9.1 → 3.10.1

package/README.md

@@ -65,7 +65,7 @@ moka install-commands --host all --check
 Check or refresh copied agent hooks after editing `oisin-ee/agent-hooks`:
 
 ```shell
-moka install-hooks --scope global --check
+moka install-hooks --check
 ```
 
 Check local prerequisites and config health:
@@ -105,8 +105,8 @@ Canonical commands:
 - `moka doctor`: check local prerequisites and config health.
 - `moka init`: install package-owned host resources for a repository.
 - `moka install-hooks`: copy manually authored hooks from `oisin-ee/agent-hooks`.
-- `moka refresh-harnesses`: force-refresh generated agent harnesses and commit
-  owned resource changes.
+- `moka refresh-harnesses`: force-refresh the per-machine (global) agent
+  harnesses. The harness is always installed globally; there is no `--scope`.
 
 ```shell
 moka run "Implement PIPE-123 user-facing behavior"

package/dist/cli/program.js

@@ -332,37 +332,27 @@ function createCliProgram(options = {}) {
 		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").addOption(new Option$1("--scope <scope>", "where to install the harness: global (one per-machine install in ~/.claude, ~/.config/opencode, ~/.codex; inherited by every repo) or project (repo-local copy)").choices(["global", "project"]).default("global")).action(async (flags) => {
-		const result = await initPipelineProject({
-			cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd(),
-			scope: flags.scope
-		});
+	program.command("init").description("Initialize package-owned pipeline support without repo-local config (global per-machine install: ~/.claude, ~/.config/opencode, ~/.codex)").action(async () => {
+		const result = await initPipelineProject({ cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd() });
 		console.log(formatPipelineInitResult(result));
 	});
-	program.command("refresh-harnesses").description("Force-refresh generated agent harnesses (global by default; commits owned resource changes only for project scope)").addOption(new Option$1("--scope <scope>", "where to refresh the harness: global (per-machine install) or project (repo-local copy, committed)").choices(["global", "project"]).default("global")).option("--message <message>", "git commit message for refreshed harness changes (project scope only)", "chore: update agent harnesses").action(async (flags) => {
-		const result = await refreshAgentHarnesses({
-			commitMessage: flags.message,
-			cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd(),
-			scope: flags.scope
-		});
+	program.command("refresh-harnesses").description("Force-refresh generated agent harnesses (global per-machine install: ~/.claude, ~/.config/opencode, ~/.codex)").action(async () => {
+		const result = await refreshAgentHarnesses({ cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd() });
 		console.log(formatRefreshAgentHarnessesResult(result));
 	});
-	program.command("install-commands").description("Install generated slash-command adapters (global per-machine by default)").addOption(new Option$1("--host <host>", "host command set to install").choices([
+	program.command("install-commands").description("Install generated slash-command adapters into per-machine host dirs (~/.claude, ~/.config/opencode, ~/.codex)").addOption(new Option$1("--host <host>", "host command set to install").choices([
 		"all",
 		"opencode",
 		"claude-code"
-	]).default("all").argParser(parseCommandHost)).addOption(new Option$1("--scope <scope>", "where to install: global (~/.claude, ~/.config/opencode, ~/.codex) or project (repo-local)").choices(["global", "project"]).default("global")).option("--dry-run", "show planned changes without writing files").option("--check", "fail if generated command files are missing or stale").option("--force", "overwrite manually edited command files").action(async (flags) => {
+	]).default("all").argParser(parseCommandHost)).option("--dry-run", "show planned changes without writing files").option("--check", "fail if generated command files are missing or stale").option("--force", "overwrite manually edited command files").action(async (flags) => {
 		const result = await installCommands({
 			...flags,
 			cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd()
 		});
 		console.log(formatInstallCommandsResult(result));
 	});
-	program.command("install-hooks").description("Install agent hooks from oisin-ee/agent-hooks (global per-machine by default)").addOption(new Option$1("--scope <scope>", "where to install: global (~/.claude, ~/.config/opencode, ~/.codex) or project (repo-local)").choices(["global", "project"]).default("global")).option("--dry-run", "show planned changes without writing files").option("--check", "fail if installed hook files are missing or stale").option("--force", "overwrite manually edited hook files").action(async (flags) => {
-		const result = await installHooks({
-			...flags,
-			cwd: process.env.PIPELINE_TARGET_PATH ?? process.cwd()
-		});
+	program.command("install-hooks").description("Install agent hooks from oisin-ee/agent-hooks into per-machine host dirs (~/.claude, ~/.config/opencode, ~/.codex)").option("--dry-run", "show planned changes without writing files").option("--check", "fail if installed hook files are missing or stale").option("--force", "overwrite manually edited hook files").action(async (flags) => {
+		const result = await installHooks({ ...flags });
 		console.log(formatInstallHooksResult(result));
 	});
 	program.command("codex-auth").description("Manage local Codex multi-auth integration").command("sync-local").description("Use one local oc-codex account pool and declare the plugin in dev repos").option("--root <path>", "directory containing repositories to sync").option("--dry-run", "show planned changes without writing files").option("--check", "fail if local Codex auth config is not synced").action((flags) => {

package/dist/hooks.d.ts

@@ -13,8 +13,8 @@ declare const hookResultSchema: z.ZodObject<{
     taskContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   }, z.core.$strict>>;
   status: z.ZodEnum<{
-    pass: "pass";
     fail: "fail";
+    pass: "pass";
     skip: "skip";
   }>;
   summary: z.ZodOptional<z.ZodString>;

package/dist/install-commands/shared.js

@@ -18,7 +18,6 @@ const ENTRYPOINT_PATH_PATTERNS = {
 	"claude-code": [/^\.claude\/commands\/(?:moka-)?([^/]+)\.md$/]
 };
 const COMMAND_HOSTS = ["opencode", "claude-code"];
-const DEFAULT_HARNESS_SCOPE = "global";
 /**
 * The per-machine host config dirs. Each honors the same env var the host tool
 * itself uses to relocate its config (so containers/CI can redirect, and so
@@ -43,18 +42,14 @@ function stripPrefix(value, prefix) {
 }
 /**
 * Resolve a repo-relative harness path (e.g. ".claude/agents/x.md",
-* ".opencode/opencode.json", "AGENTS.md") to its absolute on-disk target for
-* the given scope.
-*
-* - project: rooted at `cwd` (the repo) — the historical behaviour.
-* - global: rooted at the host-native per-machine config dirs. `.claude/*` →
-*   the Claude config dir, `.codex/*` → the Codex config dir, and `.opencode/*`
-*   plus bare root files (e.g. AGENTS.md, which OpenCode reads globally) → the
-*   OpenCode config dir. The global `.opencode` and `~/.config/opencode`
-*   layouts use identical subdir names, so this is a pure prefix rebase.
+* ".opencode/opencode.json") to its absolute on-disk target in the
+* per-machine host config dirs. `.claude/*` → the Claude config dir,
+* `.codex/*` → the Codex config dir, `.gemini/*` → the Gemini config dir,
+* and `.opencode/*` plus other root files → the OpenCode config dir. The
+* global `.opencode` and `~/.config/opencode` layouts use identical subdir
+* names, so this is a pure prefix rebase.
 */
-function resolveHarnessTarget(scope, cwd, relPath) {
-	if (scope === "project") return join(cwd, relPath);
+function resolveHarnessTarget(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"));
@@ -92,4 +87,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, 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 };

package/dist/install-commands.js

@@ -40,11 +40,11 @@ async function listFiles(root) {
 function generatedHostFor(content) {
 	return COMMAND_HOSTS.find((host) => content.includes(`<!-- @oisincoveney/pipeline:host=${host} -->`) || content.includes(`// @oisincoveney/pipeline:host=${host}`) || content.includes(`# @oisincoveney/pipeline:host=${host}`));
 }
-async function obsoleteGeneratedItems(cwd, host, wantedPaths, scope) {
+async function obsoleteGeneratedItems(host, wantedPaths) {
 	const hosts = new Set(selectedHosts(host));
 	const roots = selectedHosts(host).flatMap((selectedHost) => resourceRootsFor(selectedHost));
 	return (await Promise.all(roots.map(async (root) => {
-		const absRoot = resolveHarnessTarget(scope, cwd, root);
+		const absRoot = resolveHarnessTarget(root);
 		return (await listFiles(absRoot)).map((absolutePath) => ({
 			absolutePath,
 			path: join(root, relative(absRoot, absolutePath)).replaceAll("\\", "/")
@@ -138,8 +138,8 @@ async function writeDefinition(definition, target, content) {
 function shouldSkipInstallWrite(options, action) {
 	return Boolean(options.check || options.dryRun || action === "unchanged" || action === "conflict");
 }
-async function installDefinition(cwd, definition, options, scope) {
-	const target = resolveHarnessTarget(scope, cwd, definition.path);
+async function installDefinition(definition, options) {
+	const target = resolveHarnessTarget(definition.path);
 	const resolved = resolveDefinitionContent(definition, target);
 	const action = installActionForDefinition(definition, target, resolved, Boolean(options.force));
 	const item = commandInstallPlanItem(definition, action);
@@ -154,35 +154,29 @@ function commandInstallPlanItem(definition, action) {
 		path: definition.path
 	};
 }
-const PROJECT_ONLY_PATHS = new Set(["AGENTS.md"]);
-function scopedDefinitions(definitions, scope) {
-	if (scope === "global") return definitions.filter((definition) => !PROJECT_ONLY_PATHS.has(definition.path));
-	return definitions;
-}
+const GLOBAL_EXCLUDED_PATHS = new Set(["AGENTS.md"]);
 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 definitions = definitionsFor(host, loadPipelineConfig(cwd, { allowMissingLintFileReferences: true }), cwd).filter((definition) => !GLOBAL_EXCLUDED_PATHS.has(definition.path));
 	return {
 		cwd,
 		definitions,
 		host,
-		scope,
 		wantedPaths: new Set(definitions.map((definition) => definition.path))
 	};
 }
-async function installDefinitions(cwd, definitions, options, scope) {
+async function installDefinitions(definitions, options) {
 	const items = [];
-	for (const definition of definitions) items.push(await installDefinition(cwd, definition, options, scope));
+	for (const definition of definitions) items.push(await installDefinition(definition, options));
 	return items;
 }
 function shouldRemoveObsoleteItems(options) {
 	return !(options.check || options.dryRun);
 }
-async function removeObsoleteItems(cwd, items, options, scope) {
+async function removeObsoleteItems(items, options) {
 	if (!shouldRemoveObsoleteItems(options)) return;
-	for (const item of items) await rm(resolveHarnessTarget(scope, cwd, item.path), { force: true });
+	for (const item of items) await rm(resolveHarnessTarget(item.path), { force: true });
 }
 function actionIsConflict(item) {
 	return item.action === "conflict";
@@ -208,10 +202,10 @@ function assertInstallCheckCurrent(options, items) {
 }
 async function installCommands(options = {}) {
 	const context = installCommandsContext(options);
-	const items = await installDefinitions(context.cwd, context.definitions, options, context.scope);
-	const obsoleteItems = await obsoleteGeneratedItems(context.cwd, context.host, context.wantedPaths, context.scope);
+	const items = await installDefinitions(context.definitions, options);
+	const obsoleteItems = await obsoleteGeneratedItems(context.host, context.wantedPaths);
 	items.push(...obsoleteItems);
-	await removeObsoleteItems(context.cwd, obsoleteItems, options, context.scope);
+	await removeObsoleteItems(obsoleteItems, options);
 	assertNoInstallConflicts(options, items);
 	assertInstallCheckCurrent(options, items);
 	return { items };

package/dist/install-hooks.js

@@ -68,8 +68,8 @@ async function sourceHookFiles(source) {
 		});
 	}))).flat().sort((a, b) => a.path.localeCompare(b.path));
 }
-function manifestPath(scope, cwd, host) {
-	return resolveHarnessTarget(scope, cwd, `${HOST_TARGET_ROOT[host]}/${MANIFEST_FILE}`);
+function manifestPath(host) {
+	return resolveHarnessTarget(`${HOST_TARGET_ROOT[host]}/${MANIFEST_FILE}`);
 }
 function emptyManifest() {
 	return {
@@ -78,8 +78,8 @@ function emptyManifest() {
 		version: 1
 	};
 }
-function readManifest(scope, cwd, host) {
-	const path = manifestPath(scope, cwd, host);
+function readManifest(host) {
+	const path = manifestPath(host);
 	if (!existsSync(path)) return emptyManifest();
 	try {
 		return normalizeManifest(JSON.parse(readFileSync(path, "utf8")));
@@ -105,28 +105,28 @@ function normalizeManifest(value) {
 		version: 1
 	};
 }
-function targetPath(scope, cwd, path) {
-	return resolveHarnessTarget(scope, cwd, path);
+function targetPath(path) {
+	return resolveHarnessTarget(path);
 }
-function actionForFile(file, scope, cwd, force, manifests) {
-	const target = targetPath(scope, cwd, file.path);
+function actionForFile(file, force, manifests) {
+	const target = targetPath(file.path);
 	if (!existsSync(target)) return "create";
 	const currentHash = hashContent(readFileSync(target));
 	if (currentHash === file.hash) return "unchanged";
 	if (force) return "update";
 	return (manifests.get(file.host)?.files[file.path])?.hash === currentHash ? "update" : "conflict";
 }
-function planFiles(files, scope, cwd, force, manifests) {
+function planFiles(files, force, manifests) {
 	return files.map((file) => ({
 		...file,
-		action: actionForFile(file, scope, cwd, force, manifests)
+		action: actionForFile(file, force, manifests)
 	}));
 }
-function planObsoleteFiles(desiredPaths, scope, cwd, force, manifests) {
+function planObsoleteFiles(desiredPaths, force, manifests) {
 	const obsolete = [];
 	for (const [host, manifest] of manifests) for (const [path, entry] of Object.entries(manifest.files)) {
 		if (desiredPaths.has(path)) continue;
-		const target = targetPath(scope, cwd, path);
+		const target = targetPath(path);
 		if (!existsSync(target)) continue;
 		const currentHash = hashContent(readFileSync(target));
 		obsolete.push({
@@ -137,9 +137,9 @@ function planObsoleteFiles(desiredPaths, scope, cwd, force, manifests) {
 	}
 	return obsolete.sort((a, b) => a.path.localeCompare(b.path));
 }
-async function writePlannedFile(file, scope, cwd) {
+async function writePlannedFile(file) {
 	if (file.action === "conflict" || file.action === "unchanged") return;
-	const target = targetPath(scope, cwd, file.path);
+	const target = targetPath(file.path);
 	await mkdir(dirname(target), { recursive: true });
 	await writeFile(target, file.content);
 }
@@ -157,9 +157,9 @@ function itemForObsolete(file) {
 		path: file.path
 	};
 }
-async function removeObsoleteFile(file, scope, cwd) {
+async function removeObsoleteFile(file) {
 	if (file.action !== "delete") return;
-	await rm(targetPath(scope, cwd, file.path), { force: true });
+	await rm(targetPath(file.path), { force: true });
 }
 function assertNoConflicts(items, dryRun) {
 	if (dryRun) return;
@@ -177,7 +177,7 @@ function assertCheckCurrent(items, check) {
 	if (changed.length === 0) return;
 	throw new Error(["Installed hook files are not up to date.", ...changed.map((item) => `- ${item.path}: ${item.action}`)].join("\n"));
 }
-async function writeManifests(files, scope, cwd) {
+async function writeManifests(files) {
 	const byHost = /* @__PURE__ */ new Map();
 	for (const host of HOOK_HOSTS) byHost.set(host, emptyManifest());
 	for (const file of files) {
@@ -185,7 +185,7 @@ async function writeManifests(files, scope, cwd) {
 		if (manifest) manifest.files[file.path] = { hash: file.hash };
 	}
 	await Promise.all([...byHost.entries()].map(async ([host, manifest]) => {
-		const path = manifestPath(scope, cwd, host);
+		const path = manifestPath(host);
 		if (Object.keys(manifest.files).length === 0) {
 			await rm(path, { force: true });
 			return;
@@ -195,20 +195,18 @@ async function writeManifests(files, scope, cwd) {
 	}));
 }
 function installHooks(options = {}) {
-	const cwd = options.cwd ?? process.cwd();
-	const scope = options.scope ?? "global";
 	return withHookSource(async (source) => {
 		const files = await sourceHookFiles(source);
-		const manifests = new Map(HOOK_HOSTS.map((host) => [host, readManifest(scope, cwd, host)]));
-		const planned = planFiles(files, scope, cwd, Boolean(options.force), manifests);
-		const obsolete = planObsoleteFiles(new Set(files.map((file) => file.path)), scope, cwd, Boolean(options.force), manifests);
+		const manifests = new Map(HOOK_HOSTS.map((host) => [host, readManifest(host)]));
+		const planned = planFiles(files, Boolean(options.force), manifests);
+		const obsolete = planObsoleteFiles(new Set(files.map((file) => file.path)), Boolean(options.force), manifests);
 		const items = [...planned.map(itemFor), ...obsolete.map(itemForObsolete)];
 		assertCheckCurrent(items, Boolean(options.check));
 		assertNoConflicts(items, Boolean(options.dryRun));
 		if (!(options.check || options.dryRun)) {
-			for (const file of planned) await writePlannedFile(file, scope, cwd);
-			for (const file of obsolete) await removeObsoleteFile(file, scope, cwd);
-			await writeManifests(planned, scope, cwd);
+			for (const file of planned) await writePlannedFile(file);
+			for (const file of obsolete) await removeObsoleteFile(file);
+			await writeManifests(planned);
 		}
 		return {
 			items,

package/dist/install-rules.js

@@ -1,4 +1,3 @@
-import "./install-commands/shared.js";
 import { execa } from "execa";
 import { dirname, join } from "node:path";
 import { homedir, tmpdir } from "node:os";
@@ -51,7 +50,7 @@ async function defaultRulesyncRunner(args, opts) {
 		});
 	} catch (error) {
 		const cause = error instanceof Error ? `: ${error.message}` : "";
-		throw new Error(`Failed to generate global rules from ${DEFAULT_RULES_INSTALL_SOURCE}${cause}. If this is a private repository, authenticate GitHub access with \`gh auth login\` and rerun \`moka refresh-harnesses --scope global\`.`);
+		throw new Error(`Failed to generate global rules from ${DEFAULT_RULES_INSTALL_SOURCE}${cause}. If this is a private repository, authenticate GitHub access with \`gh auth login\` and rerun \`moka refresh-harnesses\`.`);
 	}
 }
 async function buildRootRule(source) {
@@ -74,10 +73,6 @@ ${(await Promise.all(entries.map(async (name) => {
 	await writeFile(join(rulesyncRulesDir, "_root.md"), rootContent);
 }
 function installRules(options = {}) {
-	if ((options.scope ?? "global") !== "global") return Promise.resolve({
-		items: [],
-		source: DEFAULT_RULES_INSTALL_SOURCE
-	});
 	const runner = options.rulesyncRunner ?? defaultRulesyncRunner;
 	return withRulesSource(options.sourceOverride, async (source) => {
 		await buildRootRule(source);

package/dist/pipeline-init.js

@@ -1,20 +1,8 @@
-import "./install-commands/shared.js";
 import { installCommands } from "./install-commands.js";
 import { installHooks } from "./install-hooks.js";
 import { installRules } from "./install-rules.js";
-import { existsSync } from "node:fs";
 import { execa } from "execa";
-import { join } from "node:path";
 //#region src/pipeline-init.ts
-/**
-* The harness scope drives every generated resource at once: skills, host
-* commands/agents, and config. "global" (default) installs the single
-* per-machine harness (user/global skills + ~/.claude, ~/.config/opencode,
-* ~/.codex host config); "project" vendors everything repo-local.
-*/
-function skillScopeFor(scope) {
-	return scope === "global" ? "personal" : "project";
-}
 const DEFAULT_SKILL_INSTALL_SOURCE = "oisin-ee/skills";
 const SKILL_INSTALL_AGENT_ARGS = [
 	"--agent",
@@ -25,35 +13,17 @@ const SKILL_INSTALL_AGENT_ARGS = [
 	"claude-code",
 	"--skill",
 	"*",
-	"--yes"
-];
-function skillInstallArgs(scope) {
-	return scope === "personal" ? [...SKILL_INSTALL_AGENT_ARGS, "--global"] : [...SKILL_INSTALL_AGENT_ARGS, "--copy"];
-}
-const DEFAULT_HARNESS_COMMIT_MESSAGE = "chore: update agent harnesses";
-const OWNED_HARNESS_PATHS = [
-	".agents/skills",
-	".claude/agents",
-	".claude/commands",
-	".claude/hooks",
-	".claude/.moka-agent-hooks.json",
-	".claude/settings.json",
-	".claude/skills",
-	".codex/hooks",
-	".codex/.moka-agent-hooks.json",
-	".codex/skills",
-	".opencode",
-	"AGENTS.md",
-	"skills-lock.json"
+	"--yes",
+	"--global"
 ];
-async function installDefaultSkills(cwd, scope) {
+async function installDefaultSkills(cwd) {
 	try {
 		await execa("npx", [
 			"--yes",
 			"skills",
 			"add",
 			DEFAULT_SKILL_INSTALL_SOURCE,
-			...skillInstallArgs(scope)
+			...SKILL_INSTALL_AGENT_ARGS
 		], {
 			cwd,
 			stdio: "inherit"
@@ -63,150 +33,44 @@ async function installDefaultSkills(cwd, scope) {
 		throw new Error(`Failed to install default skills from ${DEFAULT_SKILL_INSTALL_SOURCE}${cause}. If this is a private repository, authenticate GitHub access for npx skills add and rerun \`moka init\`.`);
 	}
 }
-function installDefaultHooks(cwd, scope) {
-	return installHooks({
-		cwd,
-		scope
-	});
+function installDefaultHooks() {
+	return installHooks({});
 }
 function hookInstallerFiles(result) {
 	return "items" in result ? result.items.map((item) => item.path) : result.files;
 }
 async function initPipelineProject(options = {}) {
 	const cwd = options.cwd ?? process.cwd();
-	const scope = options.scope ?? "global";
-	const skillInstaller = options.skillInstaller ?? ((target) => installDefaultSkills(target, skillScopeFor(scope)));
+	const skillInstaller = options.skillInstaller ?? installDefaultSkills;
 	const hookInstaller = options.hookInstaller ?? installDefaultHooks;
-	const rulesInstaller = options.rulesInstaller ?? ((target, s) => installRules({
-		cwd: target,
-		scope: s
-	}));
+	const rulesInstaller = options.rulesInstaller ?? ((_target) => installRules({}));
 	await skillInstaller(cwd);
 	const result = await installCommands({
 		cwd,
 		force: true,
-		host: "all",
-		scope
+		host: "all"
 	});
-	const hooks = await hookInstaller(cwd, scope);
-	const rulesResult = await rulesInstaller(cwd, scope);
-	return {
-		files: [
-			...result.items.map((item) => item.path),
-			...hookInstallerFiles(hooks),
-			...rulesResult.items.map((item) => item.path)
-		],
-		scope
-	};
+	const hooks = await hookInstaller(cwd);
+	const rulesResult = await rulesInstaller(cwd);
+	return { files: [
+		...result.items.map((item) => item.path),
+		...hookInstallerFiles(hooks),
+		...rulesResult.items.map((item) => item.path)
+	] };
 }
-async function refreshAgentHarnesses(options = {}) {
-	const context = refreshAgentHarnessesContext(options);
-	const init = await initPipelineProject({
-		cwd: context.cwd,
-		hookInstaller: options.hookInstaller,
-		rulesInstaller: options.rulesInstaller,
-		scope: options.scope,
-		skillInstaller: options.skillInstaller
-	});
-	const committed = init.scope === "project" ? await refreshAgentHarnessesCommitResult(context) : false;
-	return {
-		...init,
-		commitMessage: context.commitMessage,
-		committed
-	};
-}
-function refreshAgentHarnessesContext(options) {
-	return {
-		commandRunner: options.commandRunner ?? runCommand,
-		commitMessage: options.commitMessage ?? DEFAULT_HARNESS_COMMIT_MESSAGE,
-		cwd: options.cwd ?? process.cwd()
-	};
-}
-async function refreshAgentHarnessesCommitResult(context) {
-	await assertGitWorktree(context.cwd, context.commandRunner);
-	return stageableOwnedPathsExist(context.cwd) ? await commitOwnedHarnessRefresh(context.cwd, context.commandRunner, context.commitMessage) : false;
+function refreshAgentHarnesses(options = {}) {
+	return initPipelineProject(options);
 }
 function formatPipelineInitResult(result) {
 	return [
 		"Initialized package-owned pipeline support:",
-		result.scope === "global" ? "installed the per-machine harness globally (user/global skills + ~/.claude, ~/.config/opencode, ~/.codex); global instruction files generated via rulesync from oisin-ee/rules; inherited by every repo with no per-repo copy" : "installed default skills and host config repo-local",
+		"installed the per-machine harness globally (user/global skills + ~/.claude, ~/.config/opencode, ~/.codex); global instruction files generated via rulesync from oisin-ee/rules; inherited by every repo with no per-repo copy",
 		...result.files.map((path) => `generated ${path}`),
 		"no repo-local pipeline config files were created"
 	].join("\n");
 }
-function refreshCommitSummary(result) {
-	if (result.scope === "global") return "global harness refreshed; no repo commit (per-machine install)";
-	if (result.committed) return `committed refreshed harnesses: ${result.commitMessage}`;
-	return "refreshed harnesses already current; no commit created";
-}
 function formatRefreshAgentHarnessesResult(result) {
-	return [formatPipelineInitResult(result), refreshCommitSummary(result)].join("\n");
-}
-async function runCommand(command, args, options) {
-	const result = await execa(command, args, {
-		cwd: options.cwd,
-		reject: options.reject ?? true
-	});
-	return {
-		exitCode: result.exitCode ?? 0,
-		stderr: result.stderr,
-		stdout: result.stdout
-	};
-}
-async function assertGitWorktree(cwd, commandRunner) {
-	await commandRunner("git", ["rev-parse", "--is-inside-work-tree"], { cwd });
-}
-async function commitOwnedHarnessRefresh(cwd, commandRunner, commitMessage) {
-	await stageOwnedHarnessPaths(cwd, commandRunner);
-	await assertOnlyOwnedHarnessFilesStaged(cwd, commandRunner);
-	if (!await hasStagedChanges(cwd, commandRunner)) return false;
-	await commandRunner("git", [
-		"commit",
-		"--no-verify",
-		"-m",
-		commitMessage
-	], { cwd });
-	return true;
-}
-async function hasStagedChanges(cwd, commandRunner) {
-	return (await commandRunner("git", [
-		"diff",
-		"--cached",
-		"--quiet"
-	], {
-		cwd,
-		reject: false
-	})).exitCode !== 0;
-}
-async function assertOnlyOwnedHarnessFilesStaged(cwd, commandRunner) {
-	const unrelatedFiles = (await commandRunner("git", [
-		"diff",
-		"--cached",
-		"--name-only"
-	], { cwd })).stdout.split("\n").map((path) => path.trim()).filter(Boolean).filter((path) => !isOwnedHarnessPath(path));
-	if (unrelatedFiles.length === 0) return;
-	throw new Error([
-		"Refusing to commit because unrelated files are already staged.",
-		...unrelatedFiles.map((path) => `- ${path}`),
-		"Unstage unrelated files before running `moka refresh-harnesses`."
-	].join("\n"));
-}
-function isOwnedHarnessPath(path) {
-	return OWNED_HARNESS_PATHS.some((ownedPath) => path === ownedPath || path.startsWith(`${ownedPath}/`));
-}
-function existingOwnedPaths(cwd) {
-	return OWNED_HARNESS_PATHS.filter((path) => existsSync(join(cwd, path)));
-}
-function stageableOwnedPathsExist(cwd) {
-	return existingOwnedPaths(cwd).length > 0;
-}
-async function stageOwnedHarnessPaths(cwd, commandRunner) {
-	await commandRunner("git", [
-		"add",
-		"-A",
-		"--",
-		...existingOwnedPaths(cwd)
-	], { cwd });
+	return [formatPipelineInitResult(result), "global harness refreshed; no repo commit (per-machine install)"].join("\n");
 }
 //#endregion
 export { formatPipelineInitResult, formatRefreshAgentHarnessesResult, initPipelineProject, refreshAgentHarnesses };

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

@@ -108,8 +108,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
     nodeId: z.ZodOptional<z.ZodString>;
     outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     status: z.ZodEnum<{
-      pass: "pass";
       fail: "fail";
+      pass: "pass";
       skip: "skip";
     }>;
     summary: z.ZodOptional<z.ZodString>;
@@ -286,8 +286,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
       nodeId: z.ZodOptional<z.ZodString>;
       outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
       status: z.ZodEnum<{
-        pass: "pass";
         fail: "fail";
+        pass: "pass";
         skip: "skip";
       }>;
       summary: z.ZodOptional<z.ZodString>;

package/dist/schedule/baseline.js

@@ -118,6 +118,8 @@ function executeBaselineWorkflow() {
 							"**/__tests__/**",
 							"test/**",
 							"tests/**",
+							"**/test/**",
+							"**/tests/**",
 							"**/*.snap"
 						],
 						require_any: [
@@ -126,7 +128,9 @@ function executeBaselineWorkflow() {
 							"**/*_test.*",
 							"**/__tests__/**",
 							"test/**",
-							"tests/**"
+							"tests/**",
+							"**/test/**",
+							"**/tests/**"
 						]
 					},
 					id: "red-test-file-policy",

package/package.json

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