@kici-dev/compiler 0.1.23 → 0.1.24

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.23";
+const version = "0.1.24";
 /**
 * Build the kici Commander program with every command registered. Exported so
 * the surface registry can walk the real command tree without parsing argv (no
@@ -126,9 +126,9 @@ function buildProgram() {
 		});
 		process.exit(success ? 0 : 1);
 	});
-	program.command("test").argument("[event]", "Event type to preview (e.g., push, pr:open, schedule)").description("Preview which workflows match a trigger event (dry-run)").option("--branch <name>", "Override target branch for trigger matching (default: main)").option("--sha <hash>", "Override commit SHA").option("--workflow <name>", "Filter to specific workflow in display").option("--job <name>", "Filter to specific job in display").option("--debug", "Verbose internals", false).option("--kici-dir <path>", "Path to .kici directory", ".kici").option("--files <path>", "Simulate changed file path for trigger matching (repeatable)", (val, prev) => [...prev, val], []).option("--secret <key=value>", "Inject flat secret (repeatable)", (val, prev) => [...prev, val], []).option("--context <ctx.key=value>", "Inject context secret (repeatable)", (val, prev) => [...prev, val], []).action(async (event, options) => {
-		const { testCommand } = await import("./commands/index.js");
-		const success = await testCommand(event, options);
+	program.command("preview").argument("[event]", "Event type to preview (e.g., push, pr:open, schedule)").description("Preview which workflows match a trigger event (no execution)").option("--branch <name>", "Override target branch for trigger matching (default: main)").option("--sha <hash>", "Override commit SHA").option("--workflow <name>", "Filter to specific workflow in display").option("--job <name>", "Filter to specific job in display").option("--debug", "Verbose internals", false).option("--kici-dir <path>", "Path to .kici directory", ".kici").option("--files <path>", "Simulate changed file path for trigger matching (repeatable)", (val, prev) => [...prev, val], []).option("--secret <key=value>", "Inject flat secret (repeatable)", (val, prev) => [...prev, val], []).option("--context <ctx.key=value>", "Inject context secret (repeatable)", (val, prev) => [...prev, val], []).action(async (event, options) => {
+		const { previewCommand } = await import("./commands/index.js");
+		const success = await previewCommand(event, options);
 		process.exit(success ? 0 : 1);
 	});
 	program.command("init").description("Initialize .kici/ directory with default workflows").option("--force", "Overwrite existing .kici/ directory", false).option("--skip-install", "Create files without installing dependencies", false).option("--package-manager <npm|pnpm|yarn>", "Force a package manager for the install step (default: auto-detect)").option("--mjs", "JavaScript-only mode (no TypeScript, no dependencies)", false).option("--no-agents-md", "Skip writing .kici/AGENTS.md (LLM authoring context)").option("--private-registry <url>", "Scaffold a workflow registries: entry pointing at <url>").option("--private-registry-scope <scope>", "Optional npm package scope (e.g. @my-org) for the private registry").option("--private-registry-secret <ref>", "Qualified secret reference (env:NAME) the private registry token comes from", "production:NPM_TOKEN").addOption(new Option("--use-verdaccio-local").default(false).hideHelp()).action(async (options) => {
@@ -199,6 +199,16 @@ Environment variables:
 		const success = await secretsListCommand();
 		process.exit(success ? 0 : 1);
 	});
+	program.command("pat").description("Manage personal access tokens").command("create").description("Mint a personal access token (use --agent for a coding-agent token)").option("--name <name>", "Token name (defaults to the agent label)").option("--agent", "Mint an agent-kind PAT for the KiCI MCP server", false).option("--expires-in-days <n>", "Custom expiry in days", (v) => parseInt(v, 10)).action(async (options) => {
+		const { patCreateCommand } = await import("./commands/index.js");
+		const success = await patCreateCommand({
+			name: options.name,
+			agent: options.agent,
+			label: options.name,
+			expiresInDays: options.expiresInDays
+		});
+		process.exit(success ? 0 : 1);
+	});
 	const runsCommand = program.command("runs").description("Inspect and manage execution runs");
 	runsCommand.command("list").description("List execution runs (mirrors the dashboard Runs page)").option("--status <s>", "Filter by status").option("--workflow <w>", "Filter by workflow name").option("--branch <b>", "Filter by branch/ref").option("--repo <r>", "Filter by repository").option("--trigger <t>", "Filter by trigger type").option("--source <routingKey>", "Filter by source routing key").option("--since <ts>", "Only runs since (ISO-8601 or epoch ms)").option("--page <n>", "Page number", (v) => parseInt(v, 10)).option("--json", "Output raw JSON", false).action(async (options) => {
 		const { runsListCommand } = await import("./commands/index.js");
@@ -295,7 +305,7 @@ Environment variables:
 		const success = await drainWorkerCommand({ url: options.url });
 		process.exit(success ? 0 : 1);
 	});
-	program.command("verify-attestation").argument("[artifact]", "Artifact path to digest-check against the attestation subject (optional)").description("Verify a KiCI provenance attestation bundle offline").option("--bundle <path>", "Path or URL to the attestation bundle JSON").option("--trust-root <url-or-file>", "Trusted issuer URL, or a self-contained { issuer, jwks } file").option("--audience <aud>", "Expected token audience").option("--json", "Output structured JSON result", false).action(async (artifact, options) => {
+	program.command("verify-attestation").argument("[artifact]", "Artifact path to digest-check against the attestation subject (optional)").description("Verify a KiCI provenance attestation bundle offline").option("--bundle <path>", "Path or URL to the attestation bundle JSON").option("--trust-root <url-or-file>", "Trusted issuer URL, or a self-contained { issuer, jwks } file (default: hosted KiCI platform)").option("--audience <aud>", "Expected token audience").option("--json", "Output structured JSON result", false).action(async (artifact, options) => {
 		const { verifyAttestationCommand } = await import("./commands/index.js");
 		const success = await verifyAttestationCommand(artifact, options);
 		process.exit(success ? 0 : 1);

package/dist/commands/index.d.ts

@@ -3,8 +3,8 @@ export type { CompileOptions } from './compile.js';
 export { watchCommand } from './watch.js';
 export { fixtureCommand } from './fixture.js';
 export type { FixtureOptions } from './fixture.js';
-export { testCommand, testDryRun } from './test.js';
-export type { TestOptions, RemoteRunOptions, RemoteRunResult } from './test.js';
+export { previewCommand, previewEvent } from './preview.js';
+export type { PreviewOptions, RemoteRunOptions, RemoteRunResult } from './preview.js';
 export { runLocalCommand, runRemoteCommand } from './run.js';
 export { initCommand } from './init.js';
 export type { InitOptions } from './init.js';
@@ -14,6 +14,8 @@ export { loginCommand } from './login.js';
 export type { LoginOptions } from './login.js';
 export { secretsListCommand } from './secrets-list.js';
 export type { SecretsListOptions } from './secrets-list.js';
+export { patCreateCommand } from './pat.js';
+export type { PatCreateOptions } from './pat.js';
 export { runsListCommand } from './runs/list.js';
 export type { RunsListOptions } from './runs/list.js';
 export { runsShowCommand } from './runs/show.js';

package/dist/commands/index.js

@@ -8,11 +8,12 @@ import { endpointsCommand } from "./endpoints.js";
 import { fixtureCommand } from "./fixture.js";
 import { hookInstallCommand } from "./hook.js";
 import { watchCommand } from "./watch.js";
-import { testCommand, testDryRun } from "./test.js";
+import { previewCommand, previewEvent } from "./preview.js";
 import { runLocalCommand, runRemoteCommand } from "./run.js";
 import { initCommand } from "./init.js";
 import { loginCommand } from "./login.js";
 import { secretsListCommand } from "./secrets-list.js";
+import { patCreateCommand } from "./pat.js";
 import { runsListCommand } from "./runs/list.js";
 import { runsShowCommand } from "./runs/show.js";
 import { runsLogsCommand } from "./runs/logs.js";
@@ -25,4 +26,4 @@ import { logoutCommand } from "./logout.js";
 import { rejectCommand } from "./reject.js";
 import { workflowsListCommand } from "./workflows.js";
 import { verifyAttestationCommand } from "./verify-attestation.js";
-export { approveCommand, compileCommand, diagnosticsCommand, docsCommand, docsLlmCommand, drainWorkerCommand, endpointsCommand, fixtureCommand, hookInstallCommand, initCommand, loginCommand, logoutCommand, orchestratorsListCommand, orchestratorsUseCommand, orgCurrentCommand, orgListCommand, orgUseCommand, rejectCommand, runLocalCommand, runRemoteCommand, runsCancelCommand, runsListCommand, runsLogsCommand, runsRerunCommand, runsShowCommand, secretsListCommand, testCommand, testDryRun, typesCommand, verifyAttestationCommand, watchCommand, workflowsListCommand };
+export { approveCommand, compileCommand, diagnosticsCommand, docsCommand, docsLlmCommand, drainWorkerCommand, endpointsCommand, fixtureCommand, hookInstallCommand, initCommand, loginCommand, logoutCommand, orchestratorsListCommand, orchestratorsUseCommand, orgCurrentCommand, orgListCommand, orgUseCommand, patCreateCommand, previewCommand, previewEvent, rejectCommand, runLocalCommand, runRemoteCommand, runsCancelCommand, runsListCommand, runsLogsCommand, runsRerunCommand, runsShowCommand, secretsListCommand, typesCommand, verifyAttestationCommand, watchCommand, workflowsListCommand };

package/dist/commands/init.js

@@ -117,10 +117,10 @@ async function initCommand(options = {}) {
 		logger.info(pc.gray("  1. Edit workflows in .kici/workflows/"));
 		if (options.mjs || options.skipInstall) {
 			logger.info(pc.gray("  2. Run your package manager install in .kici/ to generate a lockfile"));
-			logger.info(pc.gray("  3. Test locally: kici test push"));
+			logger.info(pc.gray("  3. Preview matching: kici preview push"));
 			logger.info(pc.gray("  4. Commit .kici/ to your repository\n"));
 		} else {
-			logger.info(pc.gray("  2. Test locally: kici test push"));
+			logger.info(pc.gray("  2. Preview matching: kici preview push"));
 			logger.info(pc.gray("  3. Commit .kici/ to your repository\n"));
 		}
 		return true;

package/dist/commands/pat.d.ts

@@ -0,0 +1,27 @@
+export interface PatCreateOptions {
+    /** Token name shown in the dashboard PAT list. Defaults to the agent label. */
+    name?: string;
+    /** Mint an agent-kind PAT (the only credential the developer MCP server accepts). */
+    agent?: boolean;
+    /**
+     * Agent label (required with `--agent`) — the human-set name recorded on every
+     * audit row the agent produces. Also used as the token name when `--name` is
+     * omitted.
+     */
+    label?: string;
+    /** Custom expiry in days (server default: 120). */
+    expiresInDays?: number;
+    /** Injected fetch for tests. Defaults to the global fetch. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Mint a personal access token under the logged-in user's identity.
+ *
+ * `kici pat create --agent --name <label>` mints an agent-kind PAT: it inherits
+ * the user's permissions (provenance only, no authority change), carries its
+ * label into every audit row, and is the credential a coding agent points the
+ * KiCI developer MCP server at. The token is printed once — there is no way to
+ * retrieve it later.
+ */
+export declare function patCreateCommand(options?: PatCreateOptions): Promise<boolean>;
+//# sourceMappingURL=pat.d.ts.map

package/dist/commands/pat.js

@@ -0,0 +1,76 @@
+import "../chunk-BTugEXQM.js";
+import { loadGlobalConfig } from "../remote/config.js";
+import pc from "picocolors";
+import { toErrorMessage } from "@kici-dev/core";
+import { PatKind } from "@kici-dev/engine";
+//#region src/commands/pat.ts
+/**
+* Mint a personal access token under the logged-in user's identity.
+*
+* `kici pat create --agent --name <label>` mints an agent-kind PAT: it inherits
+* the user's permissions (provenance only, no authority change), carries its
+* label into every audit row, and is the credential a coding agent points the
+* KiCI developer MCP server at. The token is printed once — there is no way to
+* retrieve it later.
+*/
+async function patCreateCommand(options = {}) {
+	const doFetch = options.fetchImpl ?? fetch;
+	try {
+		const config = await loadGlobalConfig();
+		const token = config.pat ?? config.token;
+		const endpoint = config.platformEndpoint ?? config.endpoint;
+		if (!token || !endpoint) {
+			console.error(pc.red("Not logged in. Run `kici login` first."));
+			return false;
+		}
+		const kind = options.agent ? PatKind.enum.agent : PatKind.enum.user;
+		const label = options.label;
+		if (kind === PatKind.enum.agent && !label) {
+			console.error(pc.red("An agent PAT requires a label. Pass --name <label>."));
+			return false;
+		}
+		const name = options.name ?? label;
+		if (!name) {
+			console.error(pc.red("A token name is required. Pass --name <name>."));
+			return false;
+		}
+		const body = {
+			name,
+			kind
+		};
+		if (kind === PatKind.enum.agent) body.agentLabel = label;
+		if (options.expiresInDays !== void 0) body.expiresInDays = options.expiresInDays;
+		const res = await doFetch(`${endpoint.replace(/\/$/, "")}/api/v1/pats`, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${token}`
+			},
+			body: JSON.stringify(body)
+		});
+		if (!res.ok) {
+			let detail;
+			try {
+				detail = (await res.json()).error;
+			} catch {}
+			console.error(pc.red(`Failed to create token (${res.status}): ${detail ?? "request failed"}`));
+			return false;
+		}
+		const created = await res.json();
+		console.log(pc.bold(kind === PatKind.enum.agent ? "\nAgent PAT created.\n" : "\nPAT created.\n"));
+		console.log(`${pc.gray("Name:   ")}${created.name}`);
+		if (kind === PatKind.enum.agent) console.log(`${pc.gray("Agent:  ")}${label}`);
+		console.log(`${pc.gray("Expires:")} ${created.expiresAt}`);
+		console.log(`\n${pc.gray("Token (shown once — save it now):")}`);
+		console.log(pc.cyan(created.token));
+		if (kind === PatKind.enum.agent) console.log(pc.gray("\nPoint your coding agent at the KiCI MCP server with this token as the Bearer credential."));
+		return true;
+	} catch (err) {
+		console.error(pc.red(`Failed to create token: ${toErrorMessage(err)}`));
+		return false;
+	}
+}
+//#endregion
+export { patCreateCommand };
+
+//# sourceMappingURL=pat.js.map

package/dist/commands/preview.d.ts

@@ -0,0 +1,88 @@
+import { type PayloadOptions } from '../test-runner/payload-builder.js';
+import { type CheckMode } from '@kici-dev/engine';
+/** Options for the kici preview command (dry-run trigger preview) */
+export interface PreviewOptions extends PayloadOptions {
+    /** Filter to specific workflow */
+    workflow?: string;
+    /** Filter to specific job */
+    job?: string;
+    /** Enable debug output */
+    debug?: boolean;
+    /** Path to .kici directory (defaults to .kici) */
+    kiciDir?: string;
+    /** Flat secret overrides: KEY=VALUE */
+    secret?: string[];
+    /** Context secret overrides: contextName.KEY=VALUE */
+    context?: string[];
+}
+/** Options for the kici run remote command */
+export interface RemoteRunOptions extends PreviewOptions {
+    /** 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) */
+    wait?: boolean;
+    /** Suppress output except final result */
+    quiet?: boolean;
+    /** Output structured JSON result */
+    json?: boolean;
+    /** Output JUnit XML result */
+    junit?: string;
+    /** Override routing key for this run */
+    routingKey?: string;
+    /** Show recent run history */
+    history?: boolean;
+    /** --env KEY=VALUE flag values, uploaded as per-run secrets. */
+    envFlags?: string[];
+    /** Target organization id (overrides config.activeOrgId). */
+    org?: string;
+    /** Target orchestrator cluster name (overrides the per-org default). */
+    orchestrator?: string;
+    /**
+     * Run mode resolved from --check / --fail-on-drift, threaded onto the dispatch
+     * payload so the orchestrator runs the agent step loop in the requested mode.
+     * Defaults to `apply`.
+     */
+    checkMode?: CheckMode;
+    /** `--target <selector>` values (repeatable), AND-combined into host narrowing. */
+    targets?: string[];
+    /** `--target-allow-empty`: a target that zeroes a runsOnAll job skips it instead of failing. */
+    targetAllowEmpty?: boolean;
+    /**
+     * `--approve-all` (alias `--yes`): auto-approve every approval gate this run
+     * holds on (run-scoped only — the run id this invocation dispatched). The
+     * 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 {
+    fixtureId: string;
+    runId: string;
+    status: 'accepted' | 'rejected' | 'success' | 'failed' | 'cancelled' | 'error';
+    reason?: string;
+    observeUrl?: string;
+    durationMs?: number;
+    jobs?: Array<{
+        name: string;
+        status: string;
+        durationMs?: number;
+    }>;
+}
+/**
+ * Main preview command entry point.
+ *
+ * `kici preview <event>` is a dry-run trigger preview only — it executes nothing.
+ * If the argument looks like a fixture name (not a known event type), prints a migration message.
+ */
+export declare function previewCommand(event: string | undefined, options: PreviewOptions): Promise<boolean>;
+/**
+ * Local-only dry-run mode: compile workflows, match triggers, display what would execute.
+ */
+export declare function previewEvent(event: string, options: PreviewOptions): Promise<boolean>;
+//# sourceMappingURL=preview.d.ts.map

package/dist/commands/{test.js → preview.js}

@@ -9,30 +9,31 @@ import { loadSecretsFile } from "../test-runner/secrets-file.js";
 import path from "node:path";
 import pc from "picocolors";
 import { readFile } from "node:fs/promises";
+import { flattenStepInputs } from "@kici-dev/sdk";
 import { logger, toErrorMessage } from "@kici-dev/core";
 import { matchAllWorkflows } from "@kici-dev/engine";
 import { normalizeRunsOnToMatchers } from "@kici-dev/engine/labels/compile";
-//#region src/commands/test.ts
+//#region src/commands/preview.ts
 /**
-* Main test command entry point.
+* Main preview command entry point.
 *
-* `kici test <event>` is now dry-run trigger preview only.
+* `kici preview <event>` is a dry-run trigger preview only — it executes nothing.
 * If the argument looks like a fixture name (not a known event type), prints a migration message.
 */
-async function testCommand(event, options) {
+async function previewCommand(event, options) {
 	if (options.debug) {
 		process.env.KICI_DEBUG = "true";
 		logger.info(pc.gray("Debug mode enabled"));
 	}
 	try {
 		if (!event) {
-			logger.info(pc.bold("\nUsage: kici test <event>\n"));
+			logger.info(pc.bold("\nUsage: kici preview <event>\n"));
 			logger.info(pc.gray("Preview which workflows and jobs would run for a given event.\n"));
 			logger.info(pc.gray("Examples:"));
-			logger.info(pc.gray("  kici test push"));
-			logger.info(pc.gray("  kici test pr:open"));
-			logger.info(pc.gray("  kici test schedule"));
-			logger.info(pc.gray("  kici test lifecycle:workflow_complete\n"));
+			logger.info(pc.gray("  kici preview push"));
+			logger.info(pc.gray("  kici preview pr:open"));
+			logger.info(pc.gray("  kici preview schedule"));
+			logger.info(pc.gray("  kici preview lifecycle:workflow_complete\n"));
 			logger.info(pc.gray("For remote fixture execution, use: kici run remote [fixture] [options]"));
 			logger.info(pc.gray("For local workflow execution, use: kici run local <event> [options]\n"));
 			return true;
@@ -41,7 +42,7 @@ async function testCommand(event, options) {
 			logger.info(pc.yellow(`\nFixture-based testing has moved to \`kici run remote\`.\nRun \`kici run remote ${event}\` instead.\n`));
 			return false;
 		}
-		return await testDryRun(event, options);
+		return await previewEvent(event, options);
 	} catch (error) {
 		const message = toErrorMessage(error);
 		logger.error(pc.red(`\nError: ${message}\n`));
@@ -64,7 +65,7 @@ function isKnownEventArg(arg) {
 /**
 * Local-only dry-run mode: compile workflows, match triggers, display what would execute.
 */
-async function testDryRun(event, options) {
+async function previewEvent(event, options) {
 	try {
 		const kiciDir = resolveKiciDir(options.kiciDir);
 		logger.info(pc.gray(`KiCI directory: ${kiciDir}`));
@@ -144,7 +145,7 @@ function workflowsToLockFormat(workflows) {
 					if ("group" in n) return `__group:${n.group}`;
 					return n.name;
 				}) ?? [],
-				steps: j.steps.map((s) => {
+				steps: flattenStepInputs(j.steps).map((s) => {
 					if (typeof s === "function") return {
 						name: "",
 						hasOutputs: false
@@ -213,6 +214,6 @@ async function loadTestSecrets(kiciDir, secretFlags, contextFlags) {
 	return secrets;
 }
 //#endregion
-export { testCommand, testDryRun };
+export { previewCommand, previewEvent };
 
-//# sourceMappingURL=test.js.map
+//# sourceMappingURL=preview.js.map

package/dist/commands/run.d.ts

@@ -1,6 +1,6 @@
 import { type HostTargetSelector, type InputsDescriptorMap } from '@kici-dev/engine';
 import type { RunLocalOptions } from '../local-executor/types.js';
-import type { RemoteRunOptions } from './test.js';
+import type { RemoteRunOptions } from './preview.js';
 /**
  * Compile `--target` selector strings into a {@link HostTargetSelector}. Each
  * string becomes one AND value (its own include set); repeated values
@@ -23,6 +23,16 @@ export declare function lookupDispatchInputsDescriptor(inlineLockFile: string |
  * authoritative and applies coercion + defaults exactly once.
  */
 export declare function buildDispatchInputs(pairs: string[], descriptor: InputsDescriptorMap | undefined): Record<string, string>;
+/**
+ * Run `fn` with everything written to `process.stdout` redirected to
+ * `process.stderr`, then restore the original writer. Compiling a repo
+ * evaluates every user workflow / fixture module, and a `console.log` at a
+ * module's top level writes straight to stdout. On a machine-readable
+ * (`--json`) run that stdout MUST carry only the final JSON result, so the
+ * compile phases run inside this guard — workflow log output belongs on
+ * stderr regardless.
+ */
+export declare function withStdoutOnStderr<T>(fn: () => Promise<T>): Promise<T>;
 /**
  * Run a workflow locally using the local executor.
  * Thin wrapper that delegates to executeLocal from local-executor.

package/dist/commands/run.js

@@ -3,6 +3,7 @@ import { resolveKiciDir } from "../execution/executor.js";
 import "../execution/index.js";
 import { loadGlobalConfig } from "../remote/config.js";
 import { RunHistory } from "../remote/history.js";
+import { buildLocalRepoIdentity } from "../remote/local-repo-identity.js";
 import { AccessDeniedError, AmbiguousClusterError, AuthenticationError, ConnectionError, NoClusterError, PlatformRunClient } from "../remote/platform-client.js";
 import { buildEncryptedSecrets } from "../remote/secret-upload.js";
 import { createOverlayTarball, getSizeWarning, uploadTarball } from "../remote/uploader.js";
@@ -90,6 +91,24 @@ function buildDispatchInputs(pairs, descriptor) {
 /** Interval between status/log polls while a run is active. */
 const POLL_INTERVAL_MS = 750;
 /**
+* Run `fn` with everything written to `process.stdout` redirected to
+* `process.stderr`, then restore the original writer. Compiling a repo
+* evaluates every user workflow / fixture module, and a `console.log` at a
+* module's top level writes straight to stdout. On a machine-readable
+* (`--json`) run that stdout MUST carry only the final JSON result, so the
+* compile phases run inside this guard — workflow log output belongs on
+* stderr regardless.
+*/
+async function withStdoutOnStderr(fn) {
+	const realWrite = process.stdout.write.bind(process.stdout);
+	process.stdout.write = process.stderr.write.bind(process.stderr);
+	try {
+		return await fn();
+	} finally {
+		process.stdout.write = realWrite;
+	}
+}
+/**
 * 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
@@ -97,12 +116,14 @@ const POLL_INTERVAL_MS = 750;
 * abort before any upload or dispatch.
 */
 async function compileBeforeRemoteRun(options) {
-	return compileCommand({
+	const pureStdout = Boolean(options.json || options.quiet);
+	const compile = () => compileCommand({
 		kiciDir: options.kiciDir ?? ".kici",
 		check: false,
 		verbose: options.debug ?? false,
-		quiet: Boolean(options.json || options.quiet)
+		quiet: pureStdout
 	});
+	return pureStdout ? withStdoutOnStderr(compile) : compile();
 }
 /**
 * Run a workflow locally using the local executor.
@@ -148,7 +169,8 @@ async function runRemoteCommand(fixture, options) {
 			console.log(history.formatTable(entries));
 			return true;
 		}
-		const fixtures = await compileFixtures(path.join(kiciDir, "tests"));
+		const testsDir = path.join(kiciDir, "tests");
+		const fixtures = options.json ? await withStdoutOnStderr(() => compileFixtures(testsDir)) : await compileFixtures(testsDir);
 		let selected;
 		if (options.pick) {
 			if (fixtures.length === 0) return listFixtures(fixtures);
@@ -355,11 +377,12 @@ async function runSingleFixture(fixture, ctx, options, config, history) {
 		const uploaded = await initAndUpload(ctx, overlay, options);
 		const event = buildEventFromFixture(opts);
 		{
-			const repoName = path.basename(overlay.repoRoot);
+			const identity = buildLocalRepoIdentity(overlay.repoRoot);
 			const repo = event.payload.repository;
 			event.payload.repository = {
 				...repo ?? {},
-				full_name: `local/${repoName}`
+				full_name: identity.repoIdentifier,
+				provider: identity.provider
 			};
 		}
 		if (!options.quiet) logger.info(pc.gray("Triggering test run..."));
@@ -589,7 +612,11 @@ async function runDirectWorkflow(workflowName, options) {
 	try {
 		const overlay = await prepareOverlay(options);
 		const uploaded = await initAndUpload(ctx, overlay, options);
-		const payload = { repository: { full_name: `local/${path.basename(overlay.repoRoot)}` } };
+		const identity = buildLocalRepoIdentity(overlay.repoRoot);
+		const payload = { repository: {
+			full_name: identity.repoIdentifier,
+			provider: identity.provider
+		} };
 		const encrypted = await buildEncryptedSecrets(overlay.kiciDir, options.envFlags, options.context, uploaded.publicKey);
 		const triggerResult = await ctx.client.trigger(ctx.orgId, ctx.target, {
 			fixtureId,
@@ -644,6 +671,6 @@ function displayRemoteResults(results) {
 	logger.info("");
 }
 //#endregion
-export { buildDispatchInputs, buildTargetSelector, lookupDispatchInputsDescriptor, runLocalCommand, runRemoteCommand };
+export { buildDispatchInputs, buildTargetSelector, lookupDispatchInputsDescriptor, runLocalCommand, runRemoteCommand, withStdoutOnStderr };
 
 //# sourceMappingURL=run.js.map

package/dist/commands/verify-attestation.d.ts

@@ -1,7 +1,10 @@
 export interface VerifyAttestationOptions {
     /** Path or `http(s)` URL to the attestation bundle JSON. Required. */
     bundle?: string;
-    /** Trusted issuer URL (online discovery) or a self-contained `{ issuer, jwks }` file. Required. */
+    /**
+     * Trusted issuer URL (online discovery) or a self-contained `{ issuer, jwks }`
+     * file. Optional — defaults to the hosted KiCI Platform's provenance issuer.
+     */
     trustRoot?: string;
     /** Expected token audience (defaults to the KiCI provenance audience). */
     audience?: string;

package/dist/commands/verify-attestation.js

@@ -1,5 +1,6 @@
 import "../chunk-BTugEXQM.js";
 import { resolveTrustRoot } from "../provenance-trust-root.js";
+import "../remote/prod-defaults.js";
 import pc from "picocolors";
 import { readFile } from "node:fs/promises";
 import { logger, sha256File, toErrorMessage } from "@kici-dev/core";
@@ -7,13 +8,18 @@ import { KICI_PROVENANCE_AUDIENCE } from "@kici-dev/engine/provenance/bundle";
 import { verifyKiciBundle } from "@kici-dev/engine/provenance/verify";
 //#region src/commands/verify-attestation.ts
 /**
-* `kici verify-attestation [artifact] --bundle <path|url> --trust-root <url|file>`
+* `kici verify-attestation [artifact] --bundle <path|url> [--trust-root <url|file>]`
 *
 * Offline verification of a KiCI-signed provenance bundle: read the bundle,
-* resolve the trusted issuer + JWKS out-of-band (`--trust-root`), optionally
-* digest the artifact, and hand everything to the shared browser-safe
-* `verifyKiciBundle` core in `@kici-dev/engine`. The engine owns all crypto;
-* this command is the thin Node wrapper (fs / fetch / artifact digest / output).
+* resolve the trusted issuer + JWKS out-of-band, optionally digest the artifact,
+* and hand everything to the shared browser-safe `verifyKiciBundle` core in
+* `@kici-dev/engine`. The engine owns all crypto; this command is the thin Node
+* wrapper (fs / fetch / artifact digest / output).
+*
+* `--trust-root` is optional: when omitted it defaults to the hosted KiCI
+* Platform's provenance issuer, so the common case (verifying a bundle attested
+* on the hosted platform) needs no flag. Pass `--trust-root` to verify against a
+* different environment (e.g. staging) or an offline `{ issuer, jwks }` file.
 *
 * Returns a boolean (verified) so `cli.ts` can map it to an exit code (0/1).
 */
@@ -23,12 +29,22 @@ async function verifyAttestationCommand(artifact, options = {}) {
 			logger.error(pc.red("Error: --bundle <path|url> is required"));
 			return false;
 		}
-		if (!options.trustRoot) {
-			logger.error(pc.red("Error: --trust-root <url|file> is required"));
-			return false;
-		}
+		const trustRoot = options.trustRoot ?? "https://api.kici.dev";
+		const usingDefault = !options.trustRoot;
+		if (usingDefault) logger.info(pc.gray(`Using default trust root ${trustRoot} (pass --trust-root to override)`));
 		const bundle = JSON.parse(await readBundle(options.bundle));
-		const { issuer, jwks } = await resolveTrustRoot(options.trustRoot);
+		let resolved;
+		try {
+			resolved = await resolveTrustRoot(trustRoot);
+		} catch (error) {
+			const msg = toErrorMessage(error);
+			if (usingDefault && /\b503\b/.test(msg)) {
+				logger.error(pc.red(`Error: build provenance is not enabled on the hosted KiCI platform yet (${trustRoot} returned 503). Pass --trust-root to verify against another environment (e.g. staging) or an offline { issuer, jwks } file.`));
+				return false;
+			}
+			throw error;
+		}
+		const { issuer, jwks } = resolved;
 		const expectedDigest = artifact ? {
 			alg: "sha256",
 			hex: await sha256File(artifact)

package/dist/generators/secrets-dts.js

@@ -59,6 +59,8 @@ function generateSecretsDts(options) {
 	lines.push("  }");
 	lines.push("}");
 	lines.push("");
+	lines.push("export {};");
+	lines.push("");
 	return lines.join("\n");
 }
 //#endregion

package/dist/index.d.ts

@@ -3,8 +3,8 @@ export type { ExecutionResult } from './execution/index.js';
 export { validateConfig } from './validation/index.js';
 export type { ValidationResult } from './validation/index.js';
 export { generateLockFile, serializeLockFile } from './lockfile/index.js';
-export { SCHEMA_VERSION, isLockStaticJob } from './types.js';
-export type { LockFile, LockWorkflow, LockJob, LockDynamicJobFn, LockJobOrFactory, LockTrigger, LockPrTrigger, LockPushTrigger, LockMatrix, LockRule, LockStep, LockApproval, LockSource, LockBranchPattern, } from './types.js';
+export { SCHEMA_VERSION, isLockStaticJob, isLockParallelStep } from './types.js';
+export type { LockFile, LockWorkflow, LockJob, LockDynamicJobFn, LockJobOrFactory, LockTrigger, LockPrTrigger, LockPushTrigger, LockMatrix, LockRule, LockStep, LockParallelStep, LockStepEntry, LockApproval, LockSource, LockBranchPattern, } from './types.js';
 export { formatError, compilerError, isCompilerError } from './errors/index.js';
 export type { SourceLocation, CompilerError } from './errors/index.js';
 export { CapabilityGapError, formatCapabilityGapError } from './errors/index.js';

package/dist/index.js

@@ -6,7 +6,7 @@ import { executeConfig } from "./execution/executor.js";
 import "./execution/index.js";
 import { validateConfig } from "./validation/validator.js";
 import "./validation/index.js";
-import { SCHEMA_VERSION, isLockStaticJob } from "./types.js";
+import { SCHEMA_VERSION, isLockParallelStep, isLockStaticJob } from "./types.js";
 import { generateLockFile, serializeLockFile } from "./lockfile/generator.js";
 import "./lockfile/index.js";
-export { CapabilityGapError, SCHEMA_VERSION, compilerError, executeConfig, formatCapabilityGapError, formatError, generateLockFile, isCompilerError, isLockStaticJob, serializeLockFile, validateConfig };
+export { CapabilityGapError, SCHEMA_VERSION, compilerError, executeConfig, formatCapabilityGapError, formatError, generateLockFile, isCompilerError, isLockParallelStep, isLockStaticJob, serializeLockFile, validateConfig };

package/dist/llm-context/llms-architecture.txt

@@ -376,7 +376,7 @@ Source: https://docs.kici.dev/architecture/data-flows/
 
 This document describes the key data flows through the KiCI architecture: webhook delivery, job execution, developer-initiated remote runs, dependency caching, re-run and cancel, trace ID propagation, internal event routing, and generic webhook ingestion.
 
-> **Lock file schema version:** The lock file uses schema version 21, which adds the `CheckMode` / `CheckStepOutcome` enums for check-mode step execution on top of v20's `LabelMatcher` (exact/regex) selectors for `runsOn`/`runsOnAll`/`excludeLabels`, v19's `maxParallel`/`failFast` fan-out concurrency, v18's `runsOnAll` host fan-out predicate and `onUnreachable` policy, v17's typed init presets (`mise` / `{ mise }`) and `auto` detection, v16's normalized approval config, v15's per-job init config, v14's declarative cache specs, v11's `LockInlineValue` for pure function inline evaluation, v10's simplified negative patterns (! prefix in repos/paths arrays), v9's global workflow repos matching, and v8's runsOn polymorphic type support.
+> **Lock file schema version:** The lock file uses schema version 29. The orchestrator rejects any fetched lock whose `schemaVersion` does not exactly match the engine version it was built against, so a stale lock must be recompiled with `kici compile` and pushed again after any SDK upgrade that bumps the schema.
 
 ## Webhook delivery flow
 
@@ -582,7 +582,7 @@ Dep cache misses alone do **not** trigger a build job. Deps are platform-specifi
 
 ### Cross-source / no-contentHash workflows
 
-- **Lock files without `contentHash`** (schema v1) skip the source cache entirely; agents compile from source. Regenerate lock files with `kici compile` to enable caching. The current lock file schema version is 21.
+- **Lock files without `contentHash`** (schema v1) skip the source cache entirely; agents compile from source. Regenerate lock files with `kici compile` to enable caching. The current lock file schema version is 29.
 - **Cross-source / global-workflow dispatch** (a workflow registered against source A fired by a webhook on source B) bypasses both caches. The registration's lock file entry still carries `contentHash`, but the cross-source path always clone-and-installs — the eval temp dir doesn't ship `@kici-dev/sdk`. The execution agent still verifies `contentHash` against the cloned source for drift detection.
 
 ### Build deduplication
@@ -1150,7 +1150,7 @@ The compiler processes the workflow definition:
 
 ### Execution time (local test runner)
 
-When `kici test` runs a workflow:
+When `kici run local` runs a workflow:
 
 1. **SDK module resolution:** The runner resolves `setStepOutputsMap` / `setJobOutputsMap` from the same `@kici-dev/sdk` module instance that the workflow uses (ensures the proxy reads from the same map)
 2. **Map injection:** Fresh `OutputsMap` and `StepRefMap` are created and injected via `setStepOutputsMap()` / `setStepRefMap()` before each job