@kici-dev/compiler 0.1.22 → 0.1.23

package/dist/cli.js

@@ -7,7 +7,7 @@ import { realpathSync } from "node:fs";
 import { Argument, Command, Option } from "commander";
 import pc from "picocolors";
 //#region src/cli.ts
-const version = "0.1.22";
+const version = "0.1.23";
 /**
 * Build the kici Commander program with every command registered. Exported so
 * the surface registry can walk the real command tree without parsing argv (no
@@ -44,7 +44,7 @@ function buildProgram() {
 		await fixtureCommand(event, options);
 	});
 	const runCommand = program.command("run").description("Execute workflows locally or remotely");
-	runCommand.command("local").argument("[event]", "Event type (e.g., push, pr:open, schedule) — optional with --pick").description("Execute workflows locally without orchestrator infrastructure").option("-p, --pick", "Interactively pick a workflow and trigger to simulate", false).option("--workflow <name>", "Run only the specified workflow").option("--job <name>", "Run only the specified job (and its dependencies)").option("--branch <name>", "Override detected git branch").option("--sha <hash>", "Override detected git SHA").option("--payload <path>", "Path to explicit event payload JSON file").option("--concurrency <n>", "Max parallel jobs (default: CPU cores)", parseInt).option("--keep-going", "Continue after job failure", false).option("--container", "Use Podman container isolation", false).option("--env <KEY=VALUE>", "Environment variable override (repeatable)", (val, prev) => [...prev, val], []).option("--quiet", "Suppress streaming output", false).option("--json", "Output structured JSON result", false).option("--junit <path>", "Output JUnit XML result").option("--files <path>", "Override changed file paths (repeatable, default: git diff)", (val, prev) => [...prev, val], []).option("--debug", "Verbose internals", false).option("--kici-dir <path>", "Path to .kici directory", ".kici").option("--in-place", "Run against the real working directory instead of an isolated tmp checkout", false).option("--keep", "Always retain the isolated tmp checkout (default: keep only on failure)", false).option("--check", "Run in check mode: report drift, change nothing", false).option("--fail-on-drift", "In check mode, exit non-zero if any step reports drift", false).action(async (event, options) => {
+	runCommand.command("local").argument("[event]", "Event type (e.g., push, pr:open, schedule) — optional with --pick").description("Execute workflows locally without orchestrator infrastructure").option("-p, --pick", "Interactively pick a workflow and trigger to simulate", false).option("--workflow <name>", "Run only the specified workflow").option("--job <name>", "Run only the specified job (and its dependencies)").option("--branch <name>", "Override detected git branch").option("--sha <hash>", "Override detected git SHA").option("--payload <path>", "Path to explicit event payload JSON file").option("--concurrency <n>", "Max parallel jobs (default: CPU cores)", parseInt).option("--keep-going", "Continue after job failure", false).option("--container", "Use Podman container isolation", false).option("--env <KEY=VALUE>", "Environment variable override (repeatable)", (val, prev) => [...prev, val], []).option("--input <KEY=VALUE>", "Typed workflow-dispatch input (repeatable)", (val, prev) => [...prev, val], []).option("--quiet", "Suppress streaming output", false).option("--json", "Output structured JSON result", false).option("--junit <path>", "Output JUnit XML result").option("--files <path>", "Override changed file paths (repeatable, default: git diff)", (val, prev) => [...prev, val], []).option("--debug", "Verbose internals", false).option("--kici-dir <path>", "Path to .kici directory", ".kici").option("--in-place", "Run against the real working directory instead of an isolated tmp checkout", false).option("--keep", "Always retain the isolated tmp checkout (default: keep only on failure)", false).option("--check", "Run in check mode: report drift, change nothing", false).option("--fail-on-drift", "In check mode, exit non-zero if any step reports drift", false).action(async (event, options) => {
 		if (options.pick && options.workflow) {
 			console.error("Error: --pick is mutually exclusive with --workflow.");
 			process.exit(2);
@@ -78,6 +78,7 @@ function buildProgram() {
 			keepGoing: options.keepGoing,
 			container: options.container,
 			env: options.env,
+			inputs: options.input,
 			quiet: options.quiet,
 			json: options.json,
 			junit: options.junit,
@@ -89,7 +90,19 @@ function buildProgram() {
 		});
 		process.exit(success ? 0 : 1);
 	});
-	runCommand.command("remote").argument("[fixture]", "Fixture name or glob pattern (omit to list available)").description("Execute fixtures remotely via orchestrator").option("--workflow <name>", "Run a specific workflow directly (bypass triggers)").option("--all", "Run all available fixtures", false).option("--parallel", "Run matching fixtures concurrently", false).option("--no-wait", "Fire and forget (print runIds, don't stream)").option("--quiet", "Suppress output except final result", false).option("--json", "Output structured JSON result", false).option("--junit <path>", "Output JUnit XML result").option("--history", "Show recent run history", false).option("--routing-key <key>", "Override routing key for this run").option("--org <id>", "Target organization (overrides the active org)").option("--orchestrator <name>", "Target orchestrator cluster (overrides the per-org default)").option("--debug", "Verbose internals", false).option("--kici-dir <path>", "Path to .kici directory", ".kici").option("--context <ctx.key=value>", "Inject a namespaced context secret, uploaded encrypted to the orchestrator (repeatable)", (val, prev) => [...prev, val], []).option("--env <KEY=VALUE>", "Provide a per-run secret (repeatable); uploaded encrypted to the orchestrator", (val, prev) => [...prev, val], []).option("--check", "Run in check mode: report drift, change nothing", false).option("--fail-on-drift", "In check mode, exit non-zero if any step reports drift", false).option("--target <selector>", "Narrow runsOnAll jobs to hosts matching this label selector (repeatable, AND-combined)", (val, prev) => [...prev, val], []).option("--target-allow-empty", "A --target that narrows a runsOnAll job to zero hosts skips it instead of failing", false).option("--approve-all, --yes", "Auto-approve every approval gate this run holds on (run-scoped; eligibility still enforced)", false).action(async (fixture, options) => {
+	runCommand.command("remote").argument("[fixture]", "Fixture name or glob pattern (omit to list available)").description("Execute fixtures remotely via orchestrator").option("--workflow <name>", "Run a specific workflow directly (bypass triggers)").option("--all", "Run all available fixtures", false).option("-p, --pick", "Interactively pick fixtures to run", false).option("--parallel", "Run matching fixtures concurrently", false).option("--no-wait", "Fire and forget (print runIds, don't stream)").option("--quiet", "Suppress output except final result", false).option("--json", "Output structured JSON result", false).option("--junit <path>", "Output JUnit XML result").option("--history", "Show recent run history", false).option("--routing-key <key>", "Override routing key for this run").option("--org <id>", "Target organization (overrides the active org)").option("--orchestrator <name>", "Target orchestrator cluster (overrides the per-org default)").option("--debug", "Verbose internals", false).option("--kici-dir <path>", "Path to .kici directory", ".kici").option("--context <ctx.key=value>", "Inject a namespaced context secret, uploaded encrypted to the orchestrator (repeatable)", (val, prev) => [...prev, val], []).option("--env <KEY=VALUE>", "Provide a per-run secret (repeatable); uploaded encrypted to the orchestrator", (val, prev) => [...prev, val], []).option("--check", "Run in check mode: report drift, change nothing", false).option("--fail-on-drift", "In check mode, exit non-zero if any step reports drift", false).option("--target <selector>", "Narrow runsOnAll jobs to hosts matching this label selector (repeatable, AND-combined)", (val, prev) => [...prev, val], []).option("--target-allow-empty", "A --target that narrows a runsOnAll job to zero hosts skips it instead of failing", false).option("--input <KEY=VALUE>", "Typed workflow-dispatch input (repeatable)", (val, prev) => [...prev, val], []).option("--approve-all, --yes", "Auto-approve every approval gate this run holds on (run-scoped; eligibility still enforced)", false).action(async (fixture, options) => {
+		if (options.pick && fixture) {
+			console.error("Error: --pick selects fixtures interactively; do not also pass a fixture name.");
+			process.exit(2);
+		}
+		if (options.pick && options.all) {
+			console.error("Error: --pick is mutually exclusive with --all.");
+			process.exit(2);
+		}
+		if (options.pick && options.workflow) {
+			console.error("Error: --pick is mutually exclusive with --workflow.");
+			process.exit(2);
+		}
 		const { runRemoteCommand } = await import("./commands/index.js");
 		const { resolveCheckMode } = await import("./commands/check-mode.js");
 		let checkMode;
@@ -108,7 +121,8 @@ function buildProgram() {
 			envFlags: options.env,
 			targets: options.target,
 			targetAllowEmpty: options.targetAllowEmpty,
-			approveAll: options.approveAll
+			approveAll: options.approveAll,
+			inputs: options.input
 		});
 		process.exit(success ? 0 : 1);
 	});
@@ -268,10 +282,10 @@ Environment variables:
 		const { docsCommand } = await import("./commands/index.js");
 		const success = await docsCommand({ open: options.open });
 		process.exit(success ? 0 : 1);
-	}).command("llm").description("Print the bundled LLM context (llms-full.txt) to stdout").option("--index", "Print the curated llms.txt index instead of the full bundle", false).option("--out <path>", "Write the bundle to a file instead of stdout").action(async (options) => {
+	}).command("llm [topic]").description("Print KiCI LLM docs bundles. No topic prints the llms.txt index; <topic> prints a task bundle (e.g. sdk, cli, patterns, features, providers, architecture, getting-started); \"full\" prints the complete bundle.").option("--out <path>", "Write the bundle to a file instead of stdout").action(async (topic, options) => {
 		const { docsLlmCommand } = await import("./commands/index.js");
 		const success = await docsLlmCommand({
-			index: options.index,
+			topic,
 			out: options.out
 		});
 		process.exit(success ? 0 : 1);

package/dist/commands/compile.d.ts

@@ -6,6 +6,12 @@ export interface CompileOptions {
     check: boolean;
     /** Verbose output */
     verbose: boolean;
+    /**
+     * Suppress the success line on stdout (and the auto-types success line) so a
+     * caller emitting machine-readable output keeps stdout pure. Validation
+     * errors are still reported.
+     */
+    quiet?: boolean;
 }
 /**
  * Execute the compile command.

package/dist/commands/compile.js

@@ -76,7 +76,7 @@ async function compileCommand(options) {
 		const lockJson = serializeLockFile(generateLockFile(workflowsWithSource));
 		if (!options.check) {
 			await fs.writeFile(lockPath, lockJson, "utf-8");
-			logger.info(pc.green("✓") + ` Compiled workflows → .kici/kici.lock.json` + pc.dim(` (${workflowsWithSource.length} workflow${workflowsWithSource.length !== 1 ? "s" : ""})`));
+			if (!options.quiet) logger.info(pc.green("✓") + ` Compiled workflows → .kici/kici.lock.json` + pc.dim(` (${workflowsWithSource.length} workflow${workflowsWithSource.length !== 1 ? "s" : ""})`));
 			try {
 				const { loadGlobalConfig } = await import("../remote/config.js");
 				const config = await loadGlobalConfig();
@@ -84,12 +84,15 @@ async function compileCommand(options) {
 				const hasEndpoint = Boolean(config.platformEndpoint ?? config.endpoint);
 				if (hasToken && hasEndpoint && config.activeOrgId) {
 					const { typesCommand } = await import("./types.js");
-					await typesCommand({ kiciDir });
+					await typesCommand({
+						kiciDir,
+						quiet: options.quiet
+					});
 				}
 			} catch {
 				logger.warn(pc.yellow("Could not refresh types (Platform unreachable). Compilation succeeded."));
 			}
-		} else logger.info(pc.green("✓") + ` Workflows are valid` + pc.dim(` (${workflowsWithSource.length} workflow${workflowsWithSource.length !== 1 ? "s" : ""})`));
+		} else if (!options.quiet) logger.info(pc.green("✓") + ` Workflows are valid` + pc.dim(` (${workflowsWithSource.length} workflow${workflowsWithSource.length !== 1 ? "s" : ""})`));
 		return true;
 	} catch (error) {
 		if (isCompilerError(error)) logger.error(formatError(error));

package/dist/commands/docs.d.ts

@@ -3,11 +3,11 @@ export interface DocsOptions {
     open?: boolean;
 }
 export interface DocsLlmOptions {
-    /** Print only the llms.txt index instead of the full markdown bundle. */
-    index?: boolean;
+    /** Task bundle id to print. Undefined → the llms.txt index; 'full' → llms-full.txt. */
+    topic?: string;
     /** Override the bundled output destination (overrides default stdout). */
     out?: string;
-    /** Override the directory holding llms.txt + llms-full.txt (test seam). */
+    /** Override the directory holding the llms*.txt files (test seam). */
     bundleDir?: string;
 }
 /**
@@ -15,12 +15,12 @@ export interface DocsLlmOptions {
  */
 export declare function docsCommand(options?: DocsOptions): Promise<boolean>;
 /**
- * Print the bundled llms.txt or llms-full.txt content to stdout (or a file).
+ * Print a KiCI LLM docs bundle to stdout (or a file).
  *
- * The bundle is generated at build time by hack/postbuild.mjs and shipped at
- * dist/llm-context/{llms.txt,llms-full.txt}. Customer-facing LLM tools can
- * pipe `kici docs llm` straight into an Anthropic / OpenAI context buffer to
- * brief the agent on KiCI authoring conventions without an internet round-trip.
+ * No topic prints the llms.txt index (a router listing every task bundle).
+ * A topic prints that task bundle (e.g. `sdk`, `cli`, `patterns`); `full`
+ * prints the everything-bundle. Pipe straight into a coding agent's context
+ * to brief it on KiCI authoring without an internet round-trip.
  */
 export declare function docsLlmCommand(options?: DocsLlmOptions): Promise<boolean>;
 //# sourceMappingURL=docs.d.ts.map

package/dist/commands/docs.js

@@ -2,12 +2,24 @@ import "../chunk-BTugEXQM.js";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import pc from "picocolors";
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, readdir, writeFile } from "node:fs/promises";
 import { logger, toErrorMessage } from "@kici-dev/core";
 import open from "open";
 //#region src/commands/docs.ts
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const DOCS_HOME_URL = "https://kici.dev/docs/";
+function bundleFilenameForTopic(topic) {
+	if (!topic) return "llms.txt";
+	if (topic === "full") return "llms-full.txt";
+	return `llms-${topic}.txt`;
+}
+async function availableTopics(bundleDir) {
+	try {
+		return [...(await readdir(bundleDir)).filter((n) => n.startsWith("llms-") && n.endsWith(".txt") && n !== "llms-full.txt").map((n) => n.slice(5, -4)).sort(), "full"];
+	} catch {
+		return ["full"];
+	}
+}
 /**
 * Open the published documentation site in the user's default browser.
 */
@@ -27,32 +39,39 @@ async function docsCommand(options = {}) {
 	}
 }
 /**
-* Print the bundled llms.txt or llms-full.txt content to stdout (or a file).
+* Print a KiCI LLM docs bundle to stdout (or a file).
 *
-* The bundle is generated at build time by hack/postbuild.mjs and shipped at
-* dist/llm-context/{llms.txt,llms-full.txt}. Customer-facing LLM tools can
-* pipe `kici docs llm` straight into an Anthropic / OpenAI context buffer to
-* brief the agent on KiCI authoring conventions without an internet round-trip.
+* No topic prints the llms.txt index (a router listing every task bundle).
+* A topic prints that task bundle (e.g. `sdk`, `cli`, `patterns`); `full`
+* prints the everything-bundle. Pipe straight into a coding agent's context
+* to brief it on KiCI authoring without an internet round-trip.
 */
 async function docsLlmCommand(options = {}) {
-	const filename = options.index ? "llms.txt" : "llms-full.txt";
+	const filename = bundleFilenameForTopic(options.topic);
 	const bundleDir = options.bundleDir ?? path.join(__dirname, "..", "llm-context");
 	const bundlePath = path.join(bundleDir, filename);
+	let content;
 	try {
-		const content = await readFile(bundlePath, "utf-8");
-		if (options.out) {
-			await writeFile(options.out, content, "utf-8");
-			logger.info(pc.gray(`Wrote ${filename} to ${options.out}`));
-			return true;
-		}
-		process.stdout.write(content);
-		if (!content.endsWith("\n")) process.stdout.write("\n");
-		return true;
+		content = await readFile(bundlePath, "utf-8");
 	} catch (error) {
+		if (options.topic && options.topic !== "full") {
+			const topics = await availableTopics(bundleDir);
+			logger.error(pc.red(`Unknown docs bundle "${options.topic}".`));
+			logger.info(pc.gray(`Available topics: ${topics.join(", ")} (no topic prints the index).`));
+			return false;
+		}
 		logger.error(pc.red(`Error reading bundled ${filename}: ${toErrorMessage(error)}`));
 		logger.info(pc.gray("The bundle ships with the @kici-dev/compiler package. If you built the package locally, run `pnpm build` in packages/compiler/."));
 		return false;
 	}
+	if (options.out) {
+		await writeFile(options.out, content, "utf-8");
+		logger.info(pc.gray(`Wrote ${filename} to ${options.out}`));
+		return true;
+	}
+	process.stdout.write(content);
+	if (!content.endsWith("\n")) process.stdout.write("\n");
+	return true;
 }
 //#endregion
 export { docsCommand, docsLlmCommand };

package/dist/commands/org.js

@@ -65,9 +65,9 @@ async function orgListCommand() {
 		const isActive = org.id === config.activeOrgId;
 		const marker = isActive ? pc.green("* ") : "  ";
 		const name = isActive ? pc.bold(org.displayName) : org.displayName;
-		const role = pc.gray(`(${org.role})`);
+		const ownership = pc.gray(`(${org.isOwner ? "owner" : "member"})`);
 		const id = pc.gray(org.id);
-		console.log(`  ${marker}${name.padEnd(nameWidth)} ${role}  ${id}`);
+		console.log(`  ${marker}${name.padEnd(nameWidth)} ${ownership}  ${id}`);
 	}
 	console.log("");
 	return true;

package/dist/commands/run.d.ts

@@ -1,4 +1,4 @@
-import type { HostTargetSelector } from '@kici-dev/engine';
+import { type HostTargetSelector, type InputsDescriptorMap } from '@kici-dev/engine';
 import type { RunLocalOptions } from '../local-executor/types.js';
 import type { RemoteRunOptions } from './test.js';
 /**
@@ -8,6 +8,21 @@ import type { RemoteRunOptions } from './test.js';
  * `--target-allow-empty` is set without at least one `--target`.
  */
 export declare function buildTargetSelector(targets: string[] | undefined, allowEmpty: boolean): HostTargetSelector | undefined;
+/**
+ * Look up the dispatch-trigger `inputs` descriptor for a workflow from a parsed
+ * inline lock file. When `workflowName` is given, only that workflow's dispatch
+ * triggers are considered; otherwise descriptors across all workflows are merged
+ * (best-effort fast-fail — the orchestrator re-validates against the matched
+ * workflow authoritatively). Returns undefined when no dispatch inputs declared.
+ */
+export declare function lookupDispatchInputsDescriptor(inlineLockFile: string | undefined, workflowName: string | undefined): InputsDescriptorMap | undefined;
+/**
+ * Validate raw `--input KEY=VALUE` pairs against the (optional) lock descriptor
+ * and return the raw operator pairs verbatim. The CLI fast-fails on malformed /
+ * invalid input for UX, but forwards the **raw** strings — the orchestrator is
+ * authoritative and applies coercion + defaults exactly once.
+ */
+export declare function buildDispatchInputs(pairs: string[], descriptor: InputsDescriptorMap | undefined): Record<string, string>;
 /**
  * Run a workflow locally using the local executor.
  * Thin wrapper that delegates to executeLocal from local-executor.

package/dist/commands/run.js

@@ -9,13 +9,17 @@ import { createOverlayTarball, getSizeWarning, uploadTarball } from "../remote/u
 import { formatJsonResult } from "../remote/output/json.js";
 import { formatJunitResult } from "../remote/output/junit.js";
 import { formatErrorHighlight, formatMultiFixtureSummary, formatSummary } from "../remote/output/summary.js";
+import { compileCommand } from "./compile.js";
 import { compileFixtures, filterFixtures } from "../fixtures/compiler.js";
+import { describeEvent } from "../fixtures/describe-event.js";
+import { FixturePickerCancelledError, runFixturePicker } from "../fixtures/picker.js";
 import { listHeldRunsForRun, resolveHeldRunContext } from "./held-run-client.js";
 import { handleNewHolds } from "./run-hold-watch.js";
 import path from "node:path";
 import pc from "picocolors";
 import { readFile, writeFile } from "node:fs/promises";
 import { formatBytes, logger, toErrorMessage } from "@kici-dev/core";
+import { coerceDispatchInputs, parseInputPairs } from "@kici-dev/engine";
 import { normalizeRunsOnToMatchers } from "@kici-dev/engine/labels/compile";
 import { confirm } from "@inquirer/prompts";
 //#region src/commands/run.ts
@@ -42,9 +46,65 @@ function buildTargetSelector(targets, allowEmpty) {
 		allowEmpty
 	};
 }
+/**
+* Look up the dispatch-trigger `inputs` descriptor for a workflow from a parsed
+* inline lock file. When `workflowName` is given, only that workflow's dispatch
+* triggers are considered; otherwise descriptors across all workflows are merged
+* (best-effort fast-fail — the orchestrator re-validates against the matched
+* workflow authoritatively). Returns undefined when no dispatch inputs declared.
+*/
+function lookupDispatchInputsDescriptor(inlineLockFile, workflowName) {
+	if (!inlineLockFile) return void 0;
+	let lock;
+	try {
+		lock = JSON.parse(inlineLockFile);
+	} catch {
+		return;
+	}
+	const merged = {};
+	let found = false;
+	for (const wf of lock.workflows ?? []) {
+		if (workflowName && wf.name !== workflowName) continue;
+		for (const trigger of wf.triggers ?? []) if (trigger._type === "dispatch" && trigger.inputs) {
+			Object.assign(merged, trigger.inputs);
+			found = true;
+		}
+	}
+	return found ? merged : void 0;
+}
+/**
+* Validate raw `--input KEY=VALUE` pairs against the (optional) lock descriptor
+* and return the raw operator pairs verbatim. The CLI fast-fails on malformed /
+* invalid input for UX, but forwards the **raw** strings — the orchestrator is
+* authoritative and applies coercion + defaults exactly once.
+*/
+function buildDispatchInputs(pairs, descriptor) {
+	if (!pairs.length) return {};
+	const raw = parseInputPairs(pairs);
+	if (descriptor) {
+		const r = coerceDispatchInputs(raw, descriptor);
+		if ("error" in r) throw r.error;
+	}
+	return raw;
+}
 /** Interval between status/log polls while a run is active. */
 const POLL_INTERVAL_MS = 750;
 /**
+* Recompile `.kici/workflows` → `kici.lock.json` before a remote run, mirroring
+* `kici run local`. The orchestrator matches triggers and dispatches against the
+* inline lock, so a stale lock would route an edited or newly-added workflow
+* incorrectly. Returns false on a compile/validation error so the caller can
+* abort before any upload or dispatch.
+*/
+async function compileBeforeRemoteRun(options) {
+	return compileCommand({
+		kiciDir: options.kiciDir ?? ".kici",
+		check: false,
+		verbose: options.debug ?? false,
+		quiet: Boolean(options.json || options.quiet)
+	});
+}
+/**
 * Run a workflow locally using the local executor.
 * Thin wrapper that delegates to executeLocal from local-executor.
 *
@@ -89,9 +149,20 @@ async function runRemoteCommand(fixture, options) {
 			return true;
 		}
 		const fixtures = await compileFixtures(path.join(kiciDir, "tests"));
-		if (!fixture && !options.all) return listFixtures(fixtures);
 		let selected;
-		if (options.all) selected = fixtures;
+		if (options.pick) {
+			if (fixtures.length === 0) return listFixtures(fixtures);
+			try {
+				selected = await runFixturePicker(fixtures);
+			} catch (err) {
+				if (err instanceof FixturePickerCancelledError) {
+					logger.info(pc.gray(err.message));
+					return false;
+				}
+				throw err;
+			}
+		} else if (!fixture && !options.all) return listFixtures(fixtures);
+		else if (options.all) selected = fixtures;
 		else selected = filterFixtures(fixtures, fixture);
 		if (selected.length === 0) {
 			logger.info(pc.yellow(`No fixtures matched: ${fixture ?? "(none)"}`));
@@ -132,17 +203,6 @@ function listFixtures(fixtures) {
 	return true;
 }
 /**
-* Describe the event type from a fixture's trigger config.
-*/
-function describeEvent(event) {
-	if (!event || typeof event !== "object") return "unknown";
-	const e = event;
-	if (e._type === "push") return "push";
-	if (e._type === "pr") return `pr:${e.action ?? "open"}`;
-	if (typeof e._type === "string") return String(e._type);
-	return "custom";
-}
-/**
 * Resolve the authenticated Platform client and the run target (org + cluster).
 *
 * Org resolution: `--org` → `config.activeOrgId` → error.
@@ -182,6 +242,7 @@ function resolvePlatformContext(config, options) {
 * Run fixtures remotely against the Platform.
 */
 async function runFixturesRemotely(fixtures, options) {
+	if (!await compileBeforeRemoteRun(options)) return false;
 	const config = await loadGlobalConfig();
 	const ctx = resolvePlatformContext(config, options);
 	if (!ctx) return false;
@@ -320,6 +381,11 @@ async function runSingleFixture(fixture, ctx, options, config, history) {
 			...(() => {
 				const target = buildTargetSelector(options.targets, options.targetAllowEmpty ?? false);
 				return target ? { target } : {};
+			})(),
+			...(() => {
+				const descriptor = lookupDispatchInputsDescriptor(overlay.inlineLockFile, opts.workflowName);
+				const dispatchInputs = buildDispatchInputs(options.inputs ?? [], descriptor);
+				return Object.keys(dispatchInputs).length ? { dispatchInputs } : {};
 			})()
 		});
 		if (triggerResult.status === "rejected") {
@@ -513,6 +579,7 @@ function buildEventFromFixture(opts) {
 * Platform.
 */
 async function runDirectWorkflow(workflowName, options) {
+	if (!await compileBeforeRemoteRun(options)) return false;
 	const ctx = resolvePlatformContext(await loadGlobalConfig(), options);
 	if (!ctx) return false;
 	if (options.json) options.quiet = true;
@@ -544,6 +611,11 @@ async function runDirectWorkflow(workflowName, options) {
 			...(() => {
 				const target = buildTargetSelector(options.targets, options.targetAllowEmpty ?? false);
 				return target ? { target } : {};
+			})(),
+			...(() => {
+				const descriptor = lookupDispatchInputsDescriptor(overlay.inlineLockFile, workflowName);
+				const dispatchInputs = buildDispatchInputs(options.inputs ?? [], descriptor);
+				return Object.keys(dispatchInputs).length ? { dispatchInputs } : {};
 			})()
 		});
 		if (!options.quiet) logger.info(pc.green(`Run started: ${triggerResult.runId}`));
@@ -572,6 +644,6 @@ function displayRemoteResults(results) {
 	logger.info("");
 }
 //#endregion
-export { buildTargetSelector, runLocalCommand, runRemoteCommand };
+export { buildDispatchInputs, buildTargetSelector, lookupDispatchInputsDescriptor, runLocalCommand, runRemoteCommand };
 
 //# sourceMappingURL=run.js.map

package/dist/commands/test.d.ts

@@ -19,6 +19,8 @@ export interface TestOptions extends PayloadOptions {
 export interface RemoteRunOptions extends TestOptions {
     /** Run all available fixtures */
     all?: boolean;
+    /** Interactively pick fixtures to run (multi-select checkbox). */
+    pick?: boolean;
     /** Run matching fixtures concurrently */
     parallel?: boolean;
     /** Fire and forget (print runIds, don't stream) */
@@ -55,6 +57,8 @@ export interface RemoteRunOptions extends TestOptions {
      * operator must still be clause-eligible per hold; an ineligible hold blocks.
      */
     approveAll?: boolean;
+    /** `--input KEY=VALUE` values (repeatable): typed workflow-dispatch inputs. */
+    inputs?: string[];
 }
 /** Result of a single remote fixture run */
 export interface RemoteRunResult {

package/dist/commands/types.d.ts

@@ -1,6 +1,8 @@
 export interface TypesOptions {
     /** Path to .kici directory (defaults to .kici) */
     kiciDir?: string;
+    /** Suppress the success line on stdout (so machine-readable output stays pure). */
+    quiet?: boolean;
 }
 /**
  * Generate TypeScript declarations for environment secrets.

package/dist/commands/types.js

@@ -33,7 +33,7 @@ async function typesCommand(options = {}) {
 		await fs.mkdir(typesDir, { recursive: true });
 		const outputPath = path.join(typesDir, "secrets.d.ts");
 		await fs.writeFile(outputPath, dtsContent, "utf-8");
-		console.log(pc.green("Types generated") + pc.dim(` ${outputPath}`));
+		if (!options.quiet) console.log(pc.green("Types generated") + pc.dim(` ${outputPath}`));
 		return true;
 	} catch (err) {
 		if (err instanceof DashboardClientError) {

package/dist/fixtures/describe-event.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Describe the event type from a fixture's trigger config, for the fixtures
+ * table and the interactive picker.
+ */
+export declare function describeEvent(event: unknown): string;
+//# sourceMappingURL=describe-event.d.ts.map

package/dist/fixtures/describe-event.js

@@ -0,0 +1,18 @@
+import "../chunk-BTugEXQM.js";
+//#region src/fixtures/describe-event.ts
+/**
+* Describe the event type from a fixture's trigger config, for the fixtures
+* table and the interactive picker.
+*/
+function describeEvent(event) {
+	if (!event || typeof event !== "object") return "unknown";
+	const e = event;
+	if (e._type === "push") return "push";
+	if (e._type === "pr") return `pr:${e.action ?? "open"}`;
+	if (typeof e._type === "string") return String(e._type);
+	return "custom";
+}
+//#endregion
+export { describeEvent };
+
+//# sourceMappingURL=describe-event.js.map

package/dist/fixtures/picker.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Interactive multi-select fixture picker for `kici run remote --pick`.
+ *
+ * Lists every available fixture with its source and event type, lets the user
+ * toggle one or more via a checkbox prompt, and returns the chosen fixtures.
+ * The caller feeds them into the standard remote-dispatch pipeline, so a picked
+ * run is identical to one selected by name / glob / --all.
+ */
+import type { CompiledFixture } from './compiler.js';
+export declare class FixturePickerCancelledError extends Error {
+    constructor(message: string);
+}
+/**
+ * Run the interactive multi-select fixture picker.
+ *
+ * @throws FixturePickerCancelledError when stdin is not a TTY or the user aborts.
+ */
+export declare function runFixturePicker(fixtures: CompiledFixture[]): Promise<CompiledFixture[]>;
+//# sourceMappingURL=picker.d.ts.map

package/dist/fixtures/picker.js

@@ -0,0 +1,64 @@
+import "../chunk-BTugEXQM.js";
+import { describeEvent } from "./describe-event.js";
+import path from "node:path";
+import pc from "picocolors";
+import { logger } from "@kici-dev/core";
+import { checkbox } from "@inquirer/prompts";
+//#region src/fixtures/picker.ts
+/**
+* Interactive multi-select fixture picker for `kici run remote --pick`.
+*
+* Lists every available fixture with its source and event type, lets the user
+* toggle one or more via a checkbox prompt, and returns the chosen fixtures.
+* The caller feeds them into the standard remote-dispatch pipeline, so a picked
+* run is identical to one selected by name / glob / --all.
+*/
+var FixturePickerCancelledError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "FixturePickerCancelledError";
+	}
+};
+function isStdinTty() {
+	return Boolean(process.stdin.isTTY);
+}
+/** Build a single fixture's display row: `id  <source>  <event type>`. */
+function fixtureRow(f) {
+	const opts = typeof f.fixture.options === "function" ? null : f.fixture.options;
+	const eventType = opts?.event ? describeEvent(opts.event) : "(async)";
+	const source = path.relative(process.cwd(), f.sourceFile);
+	return `${f.id}  ${pc.gray(source)}  ${eventType}`;
+}
+function printFixtureList(fixtures) {
+	logger.info(pc.bold("Available fixtures:"));
+	for (const f of fixtures) logger.info(`  ${pc.cyan(f.id)} — ${fixtureRow(f)}`);
+}
+/**
+* Run the interactive multi-select fixture picker.
+*
+* @throws FixturePickerCancelledError when stdin is not a TTY or the user aborts.
+*/
+async function runFixturePicker(fixtures) {
+	if (!isStdinTty()) {
+		printFixtureList(fixtures);
+		throw new FixturePickerCancelledError("--pick requires an interactive terminal. Pass a fixture name instead.");
+	}
+	let chosenIds;
+	try {
+		chosenIds = await checkbox({
+			message: "Select fixtures to run",
+			choices: fixtures.map((f) => ({
+				name: fixtureRow(f),
+				value: f.id
+			})),
+			required: true
+		});
+	} catch (err) {
+		throw new FixturePickerCancelledError(`Picker cancelled: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	return fixtures.filter((f) => chosenIds.includes(f.id));
+}
+//#endregion
+export { FixturePickerCancelledError, runFixturePicker };
+
+//# sourceMappingURL=picker.js.map