@oisincoveney/pipeline 3.11.14 → 3.11.16

package/README.md

@@ -43,10 +43,12 @@ Initialize package-owned pipeline support:
 moka init
 ```
 
-`moka init` installs the package's default skills, generated host command
-surfaces, the singleton `pipeline-gateway` MCP entry, and copied hook files from
-the private `oisin-ee/agent-hooks` repository. OpenCode is the package default
-runtime. The command does not create repo-local `.pipeline` config files.
+`moka init` installs or refreshes the whole per-machine harness in one step:
+the package's default skills, generated host command surfaces, the singleton
+`pipeline-gateway` MCP entry, copied hook files from the private
+`oisin-ee/agent-hooks` repository, and global instruction files. OpenCode is the
+package default runtime. The command does not create repo-local `.pipeline`
+config files.
 
 The default MCP gateway can run locally or point at the hosted Momokaya gateway.
 Set `PIPELINE_MCP_GATEWAY_AUTHORIZATION` to the full HTTP `Authorization` header
@@ -56,16 +58,17 @@ value before starting OpenCode when using a protected gateway:
 export PIPELINE_MCP_GATEWAY_AUTHORIZATION="Basic $(printf '%s' 'user:password' | base64)"
 ```
 
-Check or refresh generated host files after package upgrades:
+Verify the generated harness (commands, hooks, rules) is current after package
+upgrades or edits to `oisin-ee/agent-hooks`, without writing anything:
 
 ```shell
-moka install-commands --host all --check
+moka init --check
 ```
 
-Check or refresh copied agent hooks after editing `oisin-ee/agent-hooks`:
+Refresh it, overwriting any locally edited harness files:
 
 ```shell
-moka install-hooks --check
+moka init --force
 ```
 
 Check local prerequisites and config health:
@@ -103,10 +106,10 @@ Canonical commands:
 - `moka stop <run-id> [node-id]`: abort a run or one active node.
 - `moka export <run-id> --sanitize`: print a portable evidence bundle.
 - `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 the per-machine (global) agent
-  harnesses. The harness is always installed globally; there is no `--scope`.
+- `moka init`: install or refresh the whole per-machine harness (skills,
+  command surfaces, hooks, rules). `--check` verifies without writing,
+  `--dry-run` previews, `--force` overwrites locally edited files. The harness
+  is always installed globally; there is no `--scope`.
 
 ```shell
 moka run "Implement PIPE-123 user-facing behavior"
@@ -118,7 +121,7 @@ moka run --effort normal "Implement a standard fix"
 moka run --target remote --effort thorough "Submit a full hosted graph run"
 moka run --read-only "Inspect the repository without edits"
 moka run --target remote --command -- opencode run "fix this bug"
-moka refresh-harnesses
+moka init --force
 ```
 
 Flag defaults and choices:

package/defaults/pipeline.yaml

@@ -83,12 +83,12 @@ runner_command:
       # Set up package-owned pipeline support + the opencode model registration
       # (.opencode/opencode.json, which declares the gpt-5.5-* reasoning selectors)
       # on every run, so opencode-backed agents in the pod resolve their models
-      # instead of failing with "Model not found". Both commands are idempotent
-      # and write no repo-local pipeline config.
+      # instead of failing with "Model not found". `moka init` installs the full
+      # per-machine harness (skills + commands + hooks + rules); --force refreshes
+      # a pre-baked/version-skewed settings.json instead of refusing it. Idempotent,
+      # writes no repo-local pipeline config.
       - command: moka
-        args: [init]
-      - command: moka
-        args: [install-commands]
+        args: [init, --force]
 scheduler:
   commands:
     quick:

package/dist/cli/program.js

@@ -15,9 +15,7 @@ import { registerRunnerCommandCommand } from "../commands/runner-command-command
 import { MOKA_RUN_EFFORTS, MOKA_RUN_TARGETS, resolveMokaRun } from "./run-resolver.js";
 import { registerTicketCommand } from "../commands/ticket-command.js";
 import { formatConfigLintWarning, lintPipelineConfig } from "../config/lint.js";
-import { formatInstallCommandsResult, installCommands, parseCommandHost } from "../install-commands.js";
-import { formatInstallHooksResult, installHooks } from "../install-hooks.js";
-import { formatPipelineInitResult, formatRefreshAgentHarnessesResult, initPipelineProject, refreshAgentHarnesses } from "../pipeline-init.js";
+import { formatPipelineInitResult, initPipelineProject } from "../pipeline-init.js";
 import { createRun, runControlStatusPaths, updateRunController } from "../run-control/store.js";
 import { registerRunControlCommands } from "../run-control/commands.js";
 import { startDetachedRunController } from "../run-control/detach.js";
@@ -304,12 +302,7 @@ function createCliProgram(options = {}) {
 		const config = loadPipelineConfig(process.env.PIPELINE_TARGET_PATH ?? process.cwd(), { allowMissingLintFileReferences: true });
 		console.log(renderGatewayConfig(config));
 	});
-	gatewayCommand.command("configure-host").description("Rewrite host MCP config to the singleton pipeline gateway").addOption(new Option$1("--host <host>", "host config to update").choices([
-		"all",
-		"opencode",
-		"claude-code",
-		"codex"
-	]).default("all").argParser(parseGatewayHost)).addOption(new Option$1("--scope <scope>", "config scope to update").choices(["project", "global"]).default("project").argParser(parseGatewayHostScope)).action((flags) => {
+	gatewayCommand.command("configure-host").description("Rewrite host MCP config to the singleton pipeline gateway").addOption(new Option$1("--host <host>", "host config to update").choices(["all", "opencode"]).default("all").argParser(parseGatewayHost)).addOption(new Option$1("--scope <scope>", "config scope to update").choices(["project", "global"]).default("project").argParser(parseGatewayHostScope)).action((flags) => {
 		const cwd = process.env.PIPELINE_TARGET_PATH ?? process.cwd();
 		const result = configureGatewayHosts(loadPipelineConfig(cwd, { allowMissingLintFileReferences: true }), {
 			cwd,
@@ -337,29 +330,15 @@ 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 (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 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 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",
-		"codex"
-	]).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({
+	program.command("init").description("Install or refresh package-owned pipeline support: per-machine harness (skills + slash-command adapters + agent hooks + global instruction files) installed globally to ~/.claude, ~/.config/opencode, ~/.codex with no repo-local config").option("--check", "verify the generated harness is current; fail if stale").option("--dry-run", "show planned changes without writing files").option("--force", "overwrite manually edited harness files").action(async (flags) => {
+		const result = await initPipelineProject({
 			...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 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));
+		console.log(formatPipelineInitResult(result, {
+			check: flags.check,
+			dryRun: flags.dryRun
+		}));
 	});
 	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) => {
 		const result = syncLocalCodexAuth({

package/dist/commands/pipeline-command.js

@@ -6,8 +6,6 @@ const BUILTIN_PIPE_COMMANDS = new Set([
 	"explain-plan",
 	"doctor",
 	"init",
-	"refresh-harnesses",
-	"install-commands",
 	"mcp",
 	"submit",
 	"argo",

package/dist/config/schemas.d.ts

@@ -233,8 +233,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";
@@ -262,8 +262,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>;
@@ -306,10 +306,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>;
@@ -385,10 +385,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/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<{
-    fail: "fail";
     pass: "pass";
+    fail: "fail";
     skip: "skip";
   }>;
   summary: z.ZodOptional<z.ZodString>;

package/dist/install-commands.js

@@ -31,9 +31,6 @@ function selectedInstallHosts(host) {
 function isActiveCommandHost(host) {
 	return host === "opencode" || host === "claude-code";
 }
-function isInstallHost(host) {
-	return INSTALL_HOSTS.some((candidate) => candidate === host);
-}
 function selectedCommandHosts(host) {
 	return selectedInstallHosts(host).filter(isActiveCommandHost);
 }
@@ -274,14 +271,5 @@ async function installCommands(options = {}) {
 	assertInstallCheckCurrent(options, items);
 	return { items };
 }
-function parseCommandHost(value) {
-	const host = value ?? "all";
-	if (host === "all") return host;
-	if (isInstallHost(host)) return host;
-	throw new Error(`Unsupported host "${host}". Supported values: all, ${INSTALL_HOSTS.join(", ")}.`);
-}
-function formatInstallCommandsResult(result) {
-	return result.items.map((item) => `${item.action} ${item.host}: ${item.path} (${item.invocation})`).join("\n");
-}
 //#endregion
-export { formatInstallCommandsResult, installCommands, parseCommandHost };
+export { installCommands };

package/dist/install-hooks.js

@@ -247,8 +247,5 @@ function installHooks(options = {}) {
 		};
 	});
 }
-function formatInstallHooksResult(result) {
-	return result.items.map((item) => `${item.action} ${item.host}: ${item.path}`).join("\n");
-}
 //#endregion
-export { formatInstallHooksResult, installHooks };
+export { installHooks };

package/dist/install-rules.js

@@ -48,7 +48,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\`.`);
+		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 init\`.`);
 	}
 }
 async function buildRootRule(source) {

package/dist/model-resolver.js

@@ -1,27 +1,37 @@
 //#region src/model-resolver.ts
 const DISABLED_MODELS_ENV = "PIPELINE_DISABLED_MODELS";
-function selectNodeModel(node, options) {
-	return fallbackModelSelection(node.models ?? [], options);
-}
-function fallbackModelSelection(models, options) {
+function selectNodeModelCandidates(node, options) {
+	const models = node.models ?? [];
 	if (models.length === 0) return {
+		models: [],
 		reason: "node declares no model fallback array",
 		skipped: []
 	};
 	const disabled = disabledModels();
 	const available = options?.available;
 	const enabled = models.filter((candidate) => !disabled.has(candidate) && isAvailable(candidate, available));
-	const skipped = models.filter((candidate) => disabled.has(candidate) || !isAvailable(candidate, available));
+	const baseSkipped = models.filter((candidate) => disabled.has(candidate) || !isAvailable(candidate, available));
 	const sizing = sizingFromOptions(options);
-	if (!sizing) {
-		const model = enabled[0];
-		return {
-			model,
-			reason: selectionReason(model),
-			skipped
-		};
-	}
-	return sizedSelection(enabled, skipped, sizing);
+	if (!sizing) return {
+		models: enabled,
+		reason: selectionReason(enabled[0]),
+		skipped: baseSkipped
+	};
+	return sizedCandidates(enabled, baseSkipped, sizing);
+}
+function sizedCandidates(enabled, baseSkipped, options) {
+	const { estimatedTokens, budget } = options;
+	const required = estimatedTokens / (budget.max_context_pct / 100);
+	const fits = [];
+	const tooSmall = [];
+	for (const candidate of enabled) if ((budget.model_context_windows[candidate] ?? budget.default_context_window) >= required) fits.push(candidate);
+	else tooSmall.push(candidate);
+	const head = fits[0];
+	return {
+		models: fits,
+		reason: head ? `selected '${head}' (window ${budget.model_context_windows[head] ?? budget.default_context_window}) — holds estimated ${estimatedTokens} tokens within the ${budget.max_context_pct}% context cap` : `estimated context ${estimatedTokens} tokens exceeds ${budget.max_context_pct}% of every available model window`,
+		skipped: [...baseSkipped, ...tooSmall]
+	};
 }
 function isAvailable(candidate, available) {
 	return available ? available.has(candidate) : true;
@@ -32,24 +42,6 @@ function sizingFromOptions(options) {
 		estimatedTokens: options.estimatedTokens
 	};
 }
-function sizedSelection(enabled, disabledSkipped, options) {
-	const { estimatedTokens, budget } = options;
-	const required = estimatedTokens / (budget.max_context_pct / 100);
-	const tooSmall = [];
-	for (const candidate of enabled) {
-		const window = budget.model_context_windows[candidate] ?? budget.default_context_window;
-		if (window >= required) return {
-			model: candidate,
-			reason: `selected '${candidate}' (window ${window}) — holds estimated ${estimatedTokens} tokens within the ${budget.max_context_pct}% context cap`,
-			skipped: [...disabledSkipped, ...tooSmall]
-		};
-		tooSmall.push(candidate);
-	}
-	return {
-		reason: `estimated context ${estimatedTokens} tokens exceeds ${budget.max_context_pct}% of every available model window`,
-		skipped: [...disabledSkipped, ...tooSmall]
-	};
-}
 function selectionReason(model) {
 	if (model) return "selected first enabled model from node fallback array";
 	return `all configured node models are disabled by ${DISABLED_MODELS_ENV}`;
@@ -58,4 +50,4 @@ function disabledModels() {
 	return new Set((process.env[DISABLED_MODELS_ENV] ?? "").split(",").map((value) => value.trim()).filter(Boolean));
 }
 //#endregion
-export { selectNodeModel };
+export { selectNodeModelCandidates };

package/dist/moka-submit.d.ts

@@ -5,13 +5,13 @@ import { z } from "zod";
 //#region src/moka-submit.d.ts
 declare const mokaSubmitDirectHooksSchema: z.ZodRecord<z.ZodEnum<{
   "workflow.start": "workflow.start";
+  "node.finish": "node.finish";
+  "node.start": "node.start";
   "workflow.success": "workflow.success";
   "workflow.failure": "workflow.failure";
   "workflow.complete": "workflow.complete";
-  "node.start": "node.start";
   "node.success": "node.success";
   "node.error": "node.error";
-  "node.finish": "node.finish";
   "gate.failure": "gate.failure";
 }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
   failure: z.ZodDefault<z.ZodEnum<{
@@ -94,13 +94,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
-    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
-    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{
@@ -207,13 +207,13 @@ declare const mokaSubmitOptionsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$strict>>;
   hooks: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
     "workflow.start": "workflow.start";
+    "node.finish": "node.finish";
+    "node.start": "node.start";
     "workflow.success": "workflow.success";
     "workflow.failure": "workflow.failure";
     "workflow.complete": "workflow.complete";
-    "node.start": "node.start";
     "node.success": "node.success";
     "node.error": "node.error";
-    "node.finish": "node.finish";
     "gate.failure": "gate.failure";
   }> & z.core.$partial, z.ZodDiscriminatedUnion<[z.ZodObject<{
     failure: z.ZodDefault<z.ZodEnum<{

package/dist/pipeline-init.js

@@ -33,44 +33,61 @@ async function installDefaultSkills(cwd) {
 		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() {
-	return installHooks({ force: true });
-}
 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 skillInstaller = options.skillInstaller ?? installDefaultSkills;
-	const hookInstaller = options.hookInstaller ?? installDefaultHooks;
-	const rulesInstaller = options.rulesInstaller ?? ((_target) => installRules({}));
-	await skillInstaller(cwd);
+	const { check, dryRun, force } = options;
+	const installerFlags = {
+		check,
+		dryRun,
+		force
+	};
+	if (!(check || dryRun)) await (options.skillInstaller ?? installDefaultSkills)(cwd);
 	const result = await installCommands({
 		cwd,
-		force: true,
-		host: "all"
+		host: "all",
+		...installerFlags
 	});
-	const hooks = await hookInstaller(cwd);
-	const rulesResult = await rulesInstaller(cwd);
+	const hooks = await (options.hookInstaller ?? (() => installHooks(installerFlags)))(cwd);
+	const rulesResult = await (options.rulesInstaller ?? (() => installRules(installerFlags)))(cwd);
 	return { files: [
 		...result.items.map((item) => item.path),
 		...hookInstallerFiles(hooks),
 		...rulesResult.items.map((item) => item.path)
 	] };
 }
-function refreshAgentHarnesses(options = {}) {
-	return initPipelineProject(options);
+const INIT_RESULT_COPY = {
+	install: {
+		headline: "Initialized package-owned pipeline support:",
+		fileVerb: "generated",
+		footer: "no repo-local pipeline config files were created"
+	},
+	check: {
+		headline: "Verified package-owned pipeline support is current:",
+		fileVerb: "current",
+		footer: "harness verified; no changes written"
+	},
+	dryRun: {
+		headline: "Planned package-owned pipeline support:",
+		fileVerb: "would generate",
+		footer: "dry run; no changes written"
+	}
+};
+function initResultMode(mode) {
+	if (mode.check) return "check";
+	if (mode.dryRun) return "dryRun";
+	return "install";
 }
-function formatPipelineInitResult(result) {
+function formatPipelineInitResult(result, mode = {}) {
+	const copy = INIT_RESULT_COPY[initResultMode(mode)];
 	return [
-		"Initialized package-owned pipeline support:",
-		"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"
+		copy.headline,
+		"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) => `${copy.fileVerb} ${path}`),
+		copy.footer
 	].join("\n");
 }
-function formatRefreshAgentHarnessesResult(result) {
-	return [formatPipelineInitResult(result), "global harness refreshed; no repo commit (per-machine install)"].join("\n");
-}
 //#endregion
-export { formatPipelineInitResult, formatRefreshAgentHarnessesResult, initPipelineProject, refreshAgentHarnesses };
+export { formatPipelineInitResult, initPipelineProject };

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

@@ -11,8 +11,8 @@ declare const runnerEventRecordSchema: z.ZodUnion<readonly [z.ZodObject<{
   runId: 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<{
@@ -58,10 +58,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>;
@@ -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<{
-      fail: "fail";
       pass: "pass";
+      fail: "fail";
       skip: "skip";
     }>;
     summary: z.ZodOptional<z.ZodString>;
@@ -189,8 +189,8 @@ declare const runnerEventBatchSchema: z.ZodObject<{
     runId: 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<{
@@ -236,10 +236,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>;
@@ -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<{
-        fail: "fail";
         pass: "pass";
+        fail: "fail";
         skip: "skip";
       }>;
       summary: z.ZodOptional<z.ZodString>;

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

@@ -1,7 +1,7 @@
 import { resolvePackageAssetPath } from "../../package-assets.js";
 import { resolveFileReference } from "../../path-refs.js";
 import { gatewayServerForProfile } from "../../mcp/gateway.js";
-import { selectNodeModel } from "../../model-resolver.js";
+import { selectNodeModelCandidates } from "../../model-resolver.js";
 import { createRunnerLaunchPlan } from "../../runner.js";
 import { normalizeRunnerOutput, runnerTextCandidates } from "../../runner-output.js";
 import { estimateTokens } from "../../token-estimator.js";
@@ -29,17 +29,72 @@ function executeAgentNodeEffect(node, context, attempt) {
 		if (decision.overBudget) return {
 			evidence: [
 				`agent boundary node=${node.id} profile=${node.profile}`,
-				`over token budget: ${decision.selection.reason}`,
-				...decision.selection.skipped.length ? [`model fallbacks skipped: ${decision.selection.skipped.join(", ")}`] : []
+				`over token budget: ${decision.reason}`,
+				...decision.skipped.length ? [`model fallbacks skipped: ${decision.skipped.join(", ")}`] : []
 			],
 			exitCode: 1,
 			output: ""
 		};
-		const modelSelection = decision.selection;
+		const profileId = node.profile;
+		const fallbackEvidence = [];
+		const lastIndex = decision.candidates.length - 1;
+		for (let index = 0; index < lastIndex; index += 1) {
+			const model = decision.candidates[index];
+			const attemptOutcome = yield* runModelAttemptEffect({
+				attempt,
+				context,
+				model,
+				node,
+				profileId,
+				prompt
+			});
+			if (attemptOutcome.result.exitCode !== 70) return yield* buildAgentAttemptResultEffect({
+				attempt,
+				context,
+				decision,
+				fallbackEvidence,
+				model,
+				node,
+				outcome: attemptOutcome,
+				profileId
+			});
+			fallbackEvidence.push(fallbackNote(model, decision.candidates[index + 1], attemptOutcome.result));
+		}
+		const lastModel = decision.candidates[lastIndex];
+		return yield* buildAgentAttemptResultEffect({
+			attempt,
+			context,
+			decision,
+			fallbackEvidence,
+			model: lastModel,
+			node,
+			outcome: yield* runModelAttemptEffect({
+				attempt,
+				context,
+				model: lastModel,
+				node,
+				profileId,
+				prompt
+			}),
+			profileId
+		});
+	});
+}
+function modelLabel(model) {
+	return model ?? "profile/default";
+}
+function fallbackNote(failed, next, result) {
+	const detail = result.stderr ? `: ${result.stderr}` : "";
+	return `model ${modelLabel(failed)} failed (infra exit ${result.exitCode}${detail}); falling back to ${modelLabel(next)}`;
+}
+function runModelAttemptEffect(inputs) {
+	return Effect.gen(function* () {
+		const { attempt, context, model, node, profileId, prompt } = inputs;
+		const service = yield* AgentNodeRuntimeService;
 		const plan = createRunnerLaunchPlan(context.config, {
-			model: modelSelection.model,
+			model,
 			nodeId: node.id,
-			profileId: node.profile,
+			profileId,
 			prompt,
 			reasoningEffort: node.reasoning_effort,
 			worktreePath: context.worktreePath
@@ -47,12 +102,22 @@ function executeAgentNodeEffect(node, context, attempt) {
 		if (node.timeoutMs) plan.timeoutMs = node.timeoutMs;
 		context.agentInvocations.push(plan);
 		emitAgentStart(context, plan, attempt);
-		const result = yield* (yield* AgentNodeRuntimeService).executeRunner(context.executor, plan, {
+		const result = yield* service.executeRunner(context.executor, plan, {
 			onOutput: agentOutputRecorder(context, node, attempt),
 			signal: context.signal
 		});
 		emitAgentFinish(context, plan, attempt, result);
 		if (result.sessionId) context.nodeStateStore.recordSessionId(node.id, result.sessionId);
+		return {
+			plan,
+			result
+		};
+	});
+}
+function buildAgentAttemptResultEffect(inputs) {
+	return Effect.gen(function* () {
+		const { attempt, context, decision, fallbackEvidence, model, node, outcome, profileId } = inputs;
+		const { plan, result } = outcome;
 		const finalized = yield* finalizeAgentOutputEffect({
 			context,
 			node,
@@ -64,10 +129,11 @@ function executeAgentNodeEffect(node, context, attempt) {
 		const handoff = yield* maybeDeriveHandoffEffect(context, node, finalized.output, attempt);
 		return withOptionalHandoff({
 			evidence: [
-				`agent boundary node=${node.id} profile=${node.profile} runner=${plan.runnerId}`,
+				`agent boundary node=${node.id} profile=${profileId} runner=${plan.runnerId}`,
 				`estimated context tokens: ${decision.estimatedTokens}`,
-				`model selection: ${modelSelection.model ?? "profile/default"} (${modelSelection.reason})`,
-				...modelSelection.skipped.length ? [`model fallbacks skipped: ${modelSelection.skipped.join(", ")}`] : [],
+				`model selection: ${modelLabel(model)} (${decision.reason})`,
+				...decision.skipped.length ? [`model fallbacks skipped: ${decision.skipped.join(", ")}`] : [],
+				...fallbackEvidence,
 				...finalized.evidence,
 				...result.stderr ? [`stderr: ${result.stderr}`] : [],
 				...result.timedOut ? ["agent timed out"] : []
@@ -151,27 +217,28 @@ function createHandoffFinalizerPlan(context, node, runner, rawOutput) {
 }
 /**
 * Pure model-routing decision for a node: estimate the assembled prompt size and
-* pick the smallest fallback model whose window holds it within the context cap.
-* A node with no fallback array keeps the legacy (size-unaware) selection. A node
-* with a fallback array but no fitting model is `overBudget` — the caller fails
-* it fast rather than truncating.
+* resolve the ordered fallback set of models whose window holds it within the
+* context cap. A node with no fallback array (or none surviving the filters)
+* falls back to the profile default (`undefined`). A node with a fallback array
+* but no fitting model under budget is `overBudget` — the caller fails it fast
+* rather than truncating.
 */
 function decideNodeModel(prompt, node, budget, availableModels) {
 	const estimatedTokens = estimateTokens(prompt);
-	if (!(budget && node.models?.length)) return {
-		estimatedTokens,
-		overBudget: false,
-		selection: selectNodeModel(node, { available: availableModels })
-	};
-	const selection = selectNodeModel(node, {
+	const candidates = selectNodeModelCandidates(node, {
 		available: availableModels,
-		budget,
-		estimatedTokens
+		...budget ? {
+			budget,
+			estimatedTokens
+		} : {}
 	});
+	const overBudget = Boolean(budget && node.models?.length) && candidates.models.length === 0;
 	return {
+		candidates: candidates.models.length ? candidates.models : [void 0],
 		estimatedTokens,
-		overBudget: !selection.model,
-		selection
+		overBudget,
+		reason: candidates.reason,
+		skipped: candidates.skipped
 	};
 }
 function finalizeAgentOutputEffect(inputs) {

package/dist/runtime/opencode-session-executor.js

@@ -7,15 +7,6 @@ function createOpencodeSessionRegistry() {
 	return { sessions: /* @__PURE__ */ new Map() };
 }
 /**
-* Distinguish infra failure (server/session error -> retry-eligible exit 70)
-* from a normal agent completion (the agent may still have produced a wrong
-* answer; gates decide that, exit 0). This mirrors the EXIT_STARTUP convention
-* in runner-command/run.ts and feeds retry.ts via the node's retry policy.
-*/
-const EXIT_OK = 0;
-const EXIT_AGENT_ERROR = 1;
-const EXIT_INFRA = 70;
-/**
 * SDK-backed replacement for the subprocess `runLaunchPlan`. Conforms to the
 * RuntimeContext.executor seam so agent-node never learns the transport.
 */
@@ -288,7 +279,7 @@ function successResult(plan, drive) {
 	};
 	return {
 		argv: plan.args,
-		exitCode: EXIT_OK,
+		exitCode: 0,
 		sessionId: drive.sessionId,
 		stdout
 	};
@@ -296,7 +287,7 @@ function successResult(plan, drive) {
 function failureResult(plan, error) {
 	return {
 		argv: plan.args,
-		exitCode: EXIT_INFRA,
+		exitCode: 70,
 		stderr: `opencode session failed: ${errorMessage(error)}`,
 		stdout: ""
 	};
@@ -309,8 +300,8 @@ function failureResult(plan, error) {
 function infraErrorExitCode(error) {
 	switch (error.name) {
 		case "MessageOutputLengthError":
-		case "MessageAbortedError": return EXIT_AGENT_ERROR;
-		default: return EXIT_INFRA;
+		case "MessageAbortedError": return 1;
+		default: return 70;
 	}
 }
 function describeMessageError(error) {
@@ -319,10 +310,58 @@ function describeMessageError(error) {
 	const detail = data && typeof data.message === "string" ? `: ${data.message}` : "";
 	return `${error.name}${detail}`;
 }
-function unwrap(response) {
-	if (response.error) throw new Error(typeof response.error === "string" ? response.error : JSON.stringify(response.error));
-	if (response.data === void 0) throw new Error("opencode response contained no data");
-	return response.data;
+function unwrap(result) {
+	if (result.error) throw new Error(resultErrorMessage(result));
+	if (result.data === void 0) throw new Error(`opencode response contained no data${httpContext(result)}`);
+	return result.data;
+}
+/**
+* Build the richest available message for a failed opencode result tuple. The
+* runner reads the result-tuple path (not throwOnError), so the SDK leaves
+* `error` as the raw parsed body — which for a 5xx/timeout is an empty `{}` that
+* stringifies to nothing useful. Walk an ordered precedence (body message →
+* raw string → non-empty JSON body → HTTP status line) so a gateway timeout
+* surfaces as "POST …/prompt → 504 Gateway Timeout" instead of "{}". Mirrors the
+* SDK's own error-interceptor describe().
+*/
+function resultErrorMessage(result) {
+	const detail = errorDetail(result.error);
+	if (detail) return `${detail}${httpContext(result)}`;
+	return httpStatusLine(result) ?? "opencode error with empty response body";
+}
+function errorDetail(error) {
+	return bodyMessage(error) ?? nonEmptyString(error) ?? nonEmptyJson(error);
+}
+function bodyMessage(error) {
+	if (!isRecord(error)) return;
+	return stringField(error.data, "message") ?? stringField(error, "message") ?? stringField(error, "name");
+}
+function nonEmptyString(error) {
+	return typeof error === "string" && error.length > 0 ? error : void 0;
+}
+function nonEmptyJson(error) {
+	if (error === void 0) return;
+	const json = JSON.stringify(error);
+	return json && json !== "{}" ? json : void 0;
+}
+function httpContext(result) {
+	const status = httpStatusLine(result);
+	return status ? ` (${status})` : "";
+}
+function httpStatusLine(result) {
+	const status = result.response?.status;
+	const { request } = result;
+	if (!(request?.method || request?.url || status)) return;
+	return `${requestTarget(request)}${statusSuffix(status)}`;
+}
+function requestTarget(request) {
+	return `${request?.method ?? "?"} ${request?.url ?? "?"}`;
+}
+function statusSuffix(status) {
+	return status ? ` → HTTP ${status}` : "";
+}
+function stringField(value, field) {
+	if (isRecord(value) && typeof value[field] === "string" && value[field]) return value[field];
 }
 function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);

package/docs/config-architecture.md

@@ -164,9 +164,9 @@ Project-authored skill and rule paths resolve from the project root and must
 exist for runtime use. If default skill files are missing, run `moka init` to
 install them before executing workflows.
 
-Default agent hooks are copied by `moka init` and `moka install-hooks` from the
-private `oisin-ee/agent-hooks` repository. That source repository has one
-canonical host-level layout:
+Default agent hooks are copied by `moka init` from the private
+`oisin-ee/agent-hooks` repository. That source repository has one canonical
+host-level layout:
 
 ```text
 claude-code/
@@ -215,7 +215,7 @@ OpenCode host resources are generated from the same profile registry:
 - `.opencode/skills/*/SKILL.md` is installed by `skills add`; Moka only
   generates agents, commands, plugins, and project config.
 - Additional manually authored OpenCode hook plugins can be copied from
-  `oisin-ee/agent-hooks/opencode/` by `moka install-hooks`.
+  `oisin-ee/agent-hooks/opencode/` by `moka init`.
 - `.opencode/plugins/pipeline-goal-context.ts` projects package-owned
   continuation context into OpenCode compaction.
 - `.opencode/opencode.json` contains the gateway MCP config, enables LSP, and
@@ -455,8 +455,8 @@ rather than re-emitting it into every project.
 
 ## Troubleshooting
 
-- Missing host resources: run `moka install-commands`; `moka run` loads the
-  installed package config.
+- Missing host resources: run `moka init`; `moka run` loads the installed
+  package config.
 - Capability error: reduce the profile grants or choose a runner whose declared
   capabilities include the requested tools, filesystem, network, output, rules,
   skills, or MCP access.

package/docs/mcp-gateway.md

@@ -94,7 +94,7 @@ contains only `pipeline-gateway`.
 OpenCode receives that gateway through `.opencode/opencode.json` alongside the
 package-owned runtime projection: `lsp: true`, pinned plugin entries, generated
 agents, projected skills, explicit permissions, and local TypeScript plugins.
-`moka init` and `moka install-commands` merge this OpenCode project config:
+`moka init` merges this OpenCode project config:
 existing repo-local plugin entries are preserved while missing package defaults
 such as `oc-codex-multi-auth` are appended. Existing `mcp.pipeline-gateway`
 settings are also preserved; use `moka mcp gateway configure-host` when the
@@ -116,8 +116,8 @@ Qdrant, Fallow, Serena, or Backlog declarations. Use
 health, required `tools/list` prefixes, local ToolHive availability for local
 mode, and legacy direct MCP entries. Use `moka init` to install generated
 OpenCode and Claude Code host surfaces with the singleton `pipeline-gateway`
-remote entry. Use `moka install-commands --host all` to refresh generated host
-files after package upgrades, and use
+remote entry, and `moka init --check` to verify generated host files are current
+after package upgrades. Use
 `moka mcp gateway configure-host` as an explicit migration or repair command
 when existing host MCP config must be rewritten with a backup. The hosted gateway
 requires `PIPELINE_MCP_GATEWAY_AUTHORIZATION` to be set in the OpenCode

package/docs/operator-guide.md

@@ -175,54 +175,29 @@ OpenBao, publish Secret values, or mutate ESO resources from this package.
 
 `moka init`
 
-Installs the package's default skills, generated host resources, and copied
-agent hooks from the private `oisin-ee/agent-hooks` repository. OpenCode is the
-package default runtime. `moka init` does not create repo-local `.pipeline`
-config files.
+Installs or refreshes the whole per-machine harness in one command: the
+package's default skills, generated host-native command surfaces and MCP
+entries, copied agent hooks from the private `oisin-ee/agent-hooks` repository,
+and global instruction files generated via rulesync from `oisin-ee/rules`.
+OpenCode is the package default runtime. The harness is always installed
+globally (`~/.claude`, `~/.config/opencode`, `~/.codex`); there is no `--scope`.
+`moka init` does not create repo-local `.pipeline` config files.
 
 ```shell
-moka init
+moka init             # install or refresh everything
+moka init --check     # verify the generated harness is current; fail if stale
+moka init --dry-run   # show planned changes without writing
+moka init --force     # overwrite manually edited harness files
 ```
 
-`moka install-commands`
-
-Refreshes or checks generated host-native command surfaces and MCP entries after
-package upgrades or manual edits. Initial setup should use `moka init`.
-
-```shell
-moka install-commands --host opencode --dry-run
-moka install-commands --host all --force
-```
-
-Host choices are `all` and `opencode`.
-
-`moka install-hooks`
-
-Copies manually authored hook files from the private `oisin-ee/agent-hooks`
-repository into the selected harness scope. The hook source repository has only
-host folders: `claude-code/`, `codex/`, and `opencode/`. Install scope controls
-the destination; it is not represented in the source repository.
-
-```shell
-moka install-hooks --scope global --check
-moka install-hooks --scope project --force
-```
-
-There is no source override flag and no symlink mode. Moka clones
+`--check` and `--dry-run` write nothing and skip the network skill install.
+By default `moka init` refuses to overwrite manually edited hook or command
+files; `--force` overwrites them. For agent hooks, Moka clones
 `oisin-ee/agent-hooks`, copies files, and tracks installed hashes so later runs
-can update unchanged owned files, delete removed owned files, and refuse to
-overwrite manually edited hook files unless `--force` is supplied.
-
-`moka refresh-harnesses`
-
-Force-refreshes package-owned skills, generated agent harnesses, and copied hook
-files, stages only owned harness/resource paths, and commits them with
-`--no-verify`. The default commit message is `chore: update agent harnesses`.
-
-```shell
-moka refresh-harnesses
-moka refresh-harnesses --message "chore: refresh moka harnesses"
-```
+update unchanged owned files, delete removed owned files, and (without `--force`)
+refuse to clobber manual edits. The hook source repository has only host folders
+(`claude-code/`, `codex/`, `opencode/`); there is no source override flag and no
+symlink mode.
 
 Use `PIPELINE_TARGET_PATH=/path/to/repo` when invoking `moka` from outside the
 target worktree.
@@ -399,7 +374,7 @@ OpenCode:    /moka-quick, /moka-execute, /moka-inspect
 Claude Code: /moka-quick, /moka-execute, /moka-inspect
 ```
 
-`moka init` and `moka install-commands --host opencode` generate:
+`moka init` generates, for OpenCode:
 
 - `.opencode/commands/moka-<entrypoint>.md` for `/moka-quick`, `/moka-execute`, and `/moka-inspect`
 - `.opencode/agents/*.md` for primary and subagent profiles with explicit
@@ -409,13 +384,12 @@ Claude Code: /moka-quick, /moka-execute, /moka-inspect
 - `.opencode/opencode.json` with LSP, the singleton `pipeline-gateway` MCP
   server, and pinned package-selected plugins
 
-`moka init` and `moka install-hooks` also copy hook files from
-`oisin-ee/agent-hooks` by overlaying `opencode/`, `claude-code/`, and `codex/`
-onto the selected host config roots. Hook files are authored in the hook repo,
-not generated by Moka.
+`moka init` also copies hook files from `oisin-ee/agent-hooks` by overlaying
+`opencode/`, `claude-code/`, and `codex/` onto the host config roots. Hook files
+are authored in the hook repo, not generated by Moka.
 
-`moka install-commands --host claude-code` generates `.claude/commands/moka-<entrypoint>.md`
-slash commands for Claude Code.
+For Claude Code, `moka init` generates `.claude/commands/moka-<entrypoint>.md`
+slash commands.
 
 Package defaults select OpenCode for built-in profiles and runner-command
 orchestration. Codex is not a supported runtime host.
@@ -554,7 +528,7 @@ After changing profile grants or registries, check all three surfaces:
 ```shell
 moka validate --strict
 moka explain-plan --workflow <workflow-id>
-moka install-commands --host all --check
+moka init --check
 ```
 
 ## Runner Image Verification

package/docs/slash-command-adapter-contract.md

@@ -8,7 +8,7 @@ Install generated resources during setup, then check drift with:
 
 ```sh
 moka init
-moka install-commands --host all --check
+moka init --check
 ```
 
 ## Host Mappings

package/package.json

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