@kici-dev/compiler 0.1.21 → 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.21";
+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).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;
@@ -105,7 +118,11 @@ function buildProgram() {
 		const success = await runRemoteCommand(fixture, {
 			...options,
 			checkMode,
-			envFlags: options.env
+			envFlags: options.env,
+			targets: options.target,
+			targetAllowEmpty: options.targetAllowEmpty,
+			approveAll: options.approveAll,
+			inputs: options.input
 		});
 		process.exit(success ? 0 : 1);
 	});
@@ -127,7 +144,7 @@ function buildProgram() {
 		const success = await hookInstallCommand({ git: options.git });
 		process.exit(success ? 0 : 1);
 	});
-	program.command("login").description("Authenticate with KiCI via browser OAuth (default) or API key (--token)").option("--token <key>", "API key for direct authentication (legacy)").option("--device", "Force device authorization flow (for headless/SSH environments)").option("--platform-endpoint <url>", "Platform relay URL").option("--routing-key <key>", "Routing key for webhook source identification").addHelpText("after", `
+	program.command("login").description("Authenticate with KiCI via browser OAuth (default) or API key (--token)").option("--token <key>", "API key for direct authentication (legacy)").option("--device", "Force device authorization flow (for headless/SSH environments)").option("--platform-endpoint <url>", "Platform relay URL").option("--oidc-issuer <url>", "OIDC issuer URL (defaults to the hosted KiCI IdP unless a flag/env selects another)").option("--routing-key <key>", "Routing key for webhook source identification").addHelpText("after", `
 Environment variables:
   KICI_BROWSER_CMD     Custom browser command (use {url} placeholder, or 'none' to suppress)
   KICI_CALLBACK_PORT   Fixed port for OAuth PKCE callback server (default: random)
@@ -140,6 +157,7 @@ Environment variables:
 			token: options.token,
 			device: options.device,
 			platformEndpoint: options.platformEndpoint,
+			oidcIssuer: options.oidcIssuer,
 			routingKey: options.routingKey
 		});
 		process.exit(success ? 0 : 1);
@@ -264,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/held-run-client.d.ts

@@ -19,8 +19,13 @@ export interface HeldRunContext {
 export declare function resolveHeldRunContext(): Promise<HeldRunContext | null>;
 /** List the held runs for a single run id. */
 export declare function listHeldRunsForRun(ctx: HeldRunContext, runId: string): Promise<HeldRunSummary[]>;
-/** POST an approve decision for a held run. Returns true on success. */
-export declare function postApprove(ctx: HeldRunContext, heldRunId: string): Promise<boolean>;
+/**
+ * POST an approve decision for a held run. Returns true on success. When
+ * `autoApprove` is set, marks the approval as a `kici run --approve-all`
+ * breakglass so the orchestrator audits it as `held_run.auto_approve`
+ * (eligibility is still enforced server-side — never a bypass).
+ */
+export declare function postApprove(ctx: HeldRunContext, heldRunId: string, autoApprove?: boolean): Promise<boolean>;
 /** POST a reject decision (with reason) for a held run. Returns true on success. */
 export declare function postReject(ctx: HeldRunContext, heldRunId: string, reason: string): Promise<boolean>;
 //# sourceMappingURL=held-run-client.d.ts.map

package/dist/commands/held-run-client.js

@@ -52,9 +52,15 @@ async function listHeldRunsForRun(ctx, runId) {
 	if (!response.ok) throw new Error(await describeError(response));
 	return (await response.json()).heldRuns ?? [];
 }
-/** POST an approve decision for a held run. Returns true on success. */
-async function postApprove(ctx, heldRunId) {
-	const url = `${ctx.endpoint}/api/v1/orgs/${ctx.orgId}/held-runs/${heldRunId}/approve`;
+/**
+* POST an approve decision for a held run. Returns true on success. When
+* `autoApprove` is set, marks the approval as a `kici run --approve-all`
+* breakglass so the orchestrator audits it as `held_run.auto_approve`
+* (eligibility is still enforced server-side — never a bypass).
+*/
+async function postApprove(ctx, heldRunId, autoApprove = false) {
+	const query = autoApprove ? "?auto=1" : "";
+	const url = `${ctx.endpoint}/api/v1/orgs/${ctx.orgId}/held-runs/${heldRunId}/approve${query}`;
 	const response = await fetch(url, {
 		method: "POST",
 		headers: authHeaders(ctx.token)

package/dist/commands/held-run-resolve.d.ts

@@ -16,6 +16,11 @@ export interface HeldRunSummary {
     holdScope?: HeldRunScope;
     stepIndex?: number | null;
     status: string;
+    /** Computed drift payload for a `when: 'drift'` step hold; absent otherwise. */
+    payload?: {
+        summaryMarkdown: string;
+        drift?: unknown;
+    } | null;
 }
 /** Filters supplied on the command line. */
 export interface HeldRunFilter {

package/dist/commands/login.d.ts

@@ -3,6 +3,8 @@ export interface LoginOptions {
     token?: string;
     /** Platform relay URL */
     platformEndpoint?: string;
+    /** OIDC issuer URL override */
+    oidcIssuer?: string;
     /** Routing key for webhook source identification */
     routingKey?: string;
     /** Force device authorization flow regardless of environment */

package/dist/commands/login.js

@@ -1,5 +1,5 @@
 import "../chunk-BTugEXQM.js";
-import { getConfigPath, mergeGlobalConfig } from "../remote/config.js";
+import { getConfigPath, loadGlobalConfig, mergeGlobalConfig, saveGlobalConfig } from "../remote/config.js";
 import { deviceFlow, exchangeTokenForPat, pkceFlow } from "../remote/oauth.js";
 import "../remote/prod-defaults.js";
 import { isHeadless } from "../auth/headless-detect.js";
@@ -46,8 +46,9 @@ function checkPatExpiry(expiresAt) {
 * 4. Save PAT to global config
 */
 async function oauthLogin(options) {
+	const existing = await loadGlobalConfig();
 	const platformUrl = options.platformEndpoint || process.env.KICI_PLATFORM_URL || "https://api.kici.dev";
-	const issuer = process.env.KICI_OIDC_ISSUER || "https://auth.kici.dev/realms/kici-internal";
+	const issuer = options.oidcIssuer || process.env.KICI_OIDC_ISSUER || "https://auth.kici.dev/realms/kici-internal";
 	const clientId = process.env.KICI_OIDC_CLIENT_ID || "kici-cli";
 	console.log(pc.cyan("\n  Step 1/4: Detecting environment..."));
 	const browserCmdSet = !!process.env.KICI_BROWSER_CMD;
@@ -70,14 +71,21 @@ async function oauthLogin(options) {
 		machineName
 	});
 	console.log(pc.cyan("\n  Step 4/4: Saving credentials..."));
-	const configUpdate = {
+	const endpointChanged = existing.platformEndpoint !== platformUrl;
+	const next = {
+		...existing,
 		pat: patResult.token,
 		patId: patResult.id,
-		patExpiresAt: patResult.expiresAt
+		patExpiresAt: patResult.expiresAt,
+		platformEndpoint: platformUrl,
+		oidcIssuer: issuer
 	};
-	if (options.platformEndpoint) configUpdate.platformEndpoint = options.platformEndpoint;
-	if (options.routingKey) configUpdate.routingKey = options.routingKey;
-	await mergeGlobalConfig(configUpdate);
+	if (options.routingKey) next.routingKey = options.routingKey;
+	if (endpointChanged) {
+		delete next.activeOrgId;
+		delete next.defaultClusters;
+	}
+	await saveGlobalConfig(next);
 	const configPath = getConfigPath();
 	const expiryDate = new Date(patResult.expiresAt).toLocaleDateString();
 	console.log(pc.green(`\n  Authenticated successfully!`));

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-hold-watch.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Hold-visibility + inline approve/reject for `kici run remote`.
+ *
+ * While a run is being watched, the orchestrator may pause it on an approval
+ * gate (a `when: 'always'` step/job/workflow gate, or a `when: 'drift'` step
+ * gate that carries a computed-drift payload). The poll loop calls
+ * `handleNewHolds` each tick with the run's pending holds. For each hold not
+ * seen before it prints the payload (if any) and, in a TTY, prompts the
+ * operator to approve/reject inline — reusing the same Platform held-run HTTP
+ * path as `kici approve` / `kici reject`. In a non-TTY it prints guidance and
+ * keeps polling (the run stays held until resolved out-of-band).
+ */
+import type { HeldRunSummary } from './held-run-resolve.js';
+import { type HeldRunContext } from './held-run-client.js';
+/** A yes/no prompt; injected so the poll branch is unit-testable. */
+export type ConfirmPrompt = (message: string) => Promise<boolean>;
+/** What to do with a newly-observed hold. Pure — no IO. */
+export type HoldAction = {
+    kind: 'prompt';
+    hold: HeldRunSummary;
+} | {
+    kind: 'notify';
+    hold: HeldRunSummary;
+};
+/**
+ * Classify the holds observed this tick against the set already seen. Returns
+ * one action per genuinely-new pending hold (TTY ⇒ prompt, non-TTY ⇒ notify),
+ * and the updated seen-set. Pure: the caller performs the IO.
+ */
+export declare function classifyNewHolds(holds: readonly HeldRunSummary[], seen: Set<string>, isTty: boolean): {
+    actions: HoldAction[];
+    seen: Set<string>;
+};
+/**
+ * Process the new holds observed this tick: print each, and in a TTY prompt the
+ * operator to approve/reject inline (posting the decision via the shared
+ * held-run HTTP path). Returns the updated seen-set. A resolved context is
+ * resolved lazily on first need and cached for the run.
+ */
+export declare function handleNewHolds(args: {
+    holds: readonly HeldRunSummary[];
+    seen: Set<string>;
+    isTty: boolean;
+    confirm: ConfirmPrompt;
+    /**
+     * `--approve-all` breakglass: auto-approve each hold (run-scoped) instead of
+     * prompting, marking the approval as `auto_approve` so the orchestrator
+     * audits it distinctly. Eligibility is still enforced server-side.
+     */
+    approveAll?: boolean;
+    /** Override for tests; defaults to the shared Platform held-run context. */
+    resolveContext?: () => Promise<HeldRunContext | null>;
+    /** Override for tests. */
+    approve?: (ctx: HeldRunContext, heldRunId: string, autoApprove?: boolean) => Promise<boolean>;
+    reject?: (ctx: HeldRunContext, heldRunId: string, reason: string) => Promise<boolean>;
+}): Promise<Set<string>>;
+//# sourceMappingURL=run-hold-watch.d.ts.map

package/dist/commands/run-hold-watch.js

@@ -0,0 +1,87 @@
+import "../chunk-BTugEXQM.js";
+import { postApprove, postReject, resolveHeldRunContext } from "./held-run-client.js";
+import pc from "picocolors";
+import { logger } from "@kici-dev/core";
+//#region src/commands/run-hold-watch.ts
+/**
+* Hold-visibility + inline approve/reject for `kici run remote`.
+*
+* While a run is being watched, the orchestrator may pause it on an approval
+* gate (a `when: 'always'` step/job/workflow gate, or a `when: 'drift'` step
+* gate that carries a computed-drift payload). The poll loop calls
+* `handleNewHolds` each tick with the run's pending holds. For each hold not
+* seen before it prints the payload (if any) and, in a TTY, prompts the
+* operator to approve/reject inline — reusing the same Platform held-run HTTP
+* path as `kici approve` / `kici reject`. In a non-TTY it prints guidance and
+* keeps polling (the run stays held until resolved out-of-band).
+*/
+/**
+* Classify the holds observed this tick against the set already seen. Returns
+* one action per genuinely-new pending hold (TTY ⇒ prompt, non-TTY ⇒ notify),
+* and the updated seen-set. Pure: the caller performs the IO.
+*/
+function classifyNewHolds(holds, seen, isTty) {
+	const next = new Set(seen);
+	const actions = [];
+	for (const hold of holds) {
+		if (hold.status !== "pending") continue;
+		if (next.has(hold.id)) continue;
+		next.add(hold.id);
+		actions.push({
+			kind: isTty ? "prompt" : "notify",
+			hold
+		});
+	}
+	return {
+		actions,
+		seen: next
+	};
+}
+/** Print a hold's identity + its drift payload (when present) to stdout. */
+function printHold(hold) {
+	const scope = hold.holdScope ?? "job";
+	const where = scope === "step" && hold.stepIndex != null ? `step #${hold.stepIndex}${hold.jobId ? ` of job '${hold.jobId}'` : ""}` : hold.jobId ? `job '${hold.jobId}'` : scope;
+	logger.info(pc.yellow(`\n[kici] Run held for approval (${where}).`));
+	if (hold.payload?.summaryMarkdown) {
+		logger.info(pc.dim("Computed drift — review before approving:"));
+		for (const line of hold.payload.summaryMarkdown.split("\n")) logger.info(pc.dim(`    ${line}`));
+	}
+}
+/**
+* Process the new holds observed this tick: print each, and in a TTY prompt the
+* operator to approve/reject inline (posting the decision via the shared
+* held-run HTTP path). Returns the updated seen-set. A resolved context is
+* resolved lazily on first need and cached for the run.
+*/
+async function handleNewHolds(args) {
+	const { actions, seen } = classifyNewHolds(args.holds, args.seen, args.isTty);
+	if (actions.length === 0) return seen;
+	const resolveCtx = args.resolveContext ?? resolveHeldRunContext;
+	const doApprove = args.approve ?? postApprove;
+	const doReject = args.reject ?? postReject;
+	let ctx = null;
+	if (args.approveAll) logger.info(pc.yellow("[kici] --approve-all: auto-approving every gate for this run (eligibility enforced)."));
+	for (const action of actions) {
+		printHold(action.hold);
+		ctx = ctx ?? await resolveCtx();
+		if (!ctx) {
+			logger.info(pc.dim(`Run held; approve via \`kici approve ${action.hold.runId}\`.`));
+			continue;
+		}
+		if (args.approveAll) {
+			if (await doApprove(ctx, action.hold.id, true)) logger.info(pc.green("[kici] Auto-approved."));
+			continue;
+		}
+		if (action.kind === "notify") {
+			logger.info(pc.dim(`Run held; approve via the dashboard or \`kici approve ${action.hold.runId}\`.`));
+			continue;
+		}
+		const approved = await args.confirm("Approve this gate?");
+		if (approved ? await doApprove(ctx, action.hold.id) : await doReject(ctx, action.hold.id, "rejected via kici run")) logger.info(approved ? pc.green("[kici] Approved.") : pc.red("[kici] Rejected."));
+	}
+	return seen;
+}
+//#endregion
+export { classifyNewHolds, handleNewHolds };
+
+//# sourceMappingURL=run-hold-watch.js.map

package/dist/commands/run.d.ts

@@ -1,5 +1,28 @@
+import { type HostTargetSelector, type InputsDescriptorMap } from '@kici-dev/engine';
 import type { RunLocalOptions } from '../local-executor/types.js';
 import type { RemoteRunOptions } from './test.js';
+/**
+ * Compile `--target` selector strings into a {@link HostTargetSelector}. Each
+ * string becomes one AND value (its own include set); repeated values
+ * AND-combine. Returns undefined when no `--target` is given. Throws when
+ * `--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.